for merge

flutter/lib/models/chat_model.dart

@@ -0,0 +1,103 @@
+import 'dart:convert';
+
+import 'package:dash_chat/dash_chat.dart';
+import 'package:flutter/material.dart';
+
+import '../widgets/overlay.dart';
+import 'model.dart';
+
+class ChatModel with ChangeNotifier {
+  static final clientModeID = -1;
+
+  final Map<int, List<ChatMessage>> _messages = Map()..[clientModeID] = [];
+
+  final ChatUser me = ChatUser(
+    uid: "",
+    name: "Me",
+  );
+
+  final _scroller = ScrollController();
+
+  var _currentID = clientModeID;
+
+  ScrollController get scroller => _scroller;
+
+  Map<int, List<ChatMessage>> get messages => _messages;
+
+  int get currentID => _currentID;
+
+  ChatUser get currentUser =>
+      FFI.serverModel.clients[_currentID]?.chatUser ?? me;
+
+  changeCurrentID(int id) {
+    if (_messages.containsKey(id)) {
+      _currentID = id;
+      notifyListeners();
+    } else {
+      final chatUser = FFI.serverModel.clients[id]?.chatUser;
+      if (chatUser == null) {
+        return debugPrint(
+            "Failed to changeCurrentID,remote user doesn't exist");
+      }
+      _messages[id] = [];
+      _currentID = id;
+    }
+  }
+
+  receive(int id, String text) {
+    if (text.isEmpty) return;
+    // first message show overlay icon
+    if (chatIconOverlayEntry == null) {
+      showChatIconOverlay();
+    }
+    late final chatUser;
+    if (id == clientModeID) {
+      chatUser = ChatUser(
+        name: FFI.ffiModel.pi.username,
+        uid: FFI.getId(),
+      );
+    } else {
+      chatUser = FFI.serverModel.clients[id]?.chatUser;
+    }
+    if (chatUser == null) {
+      return debugPrint("Failed to receive msg,user doesn't exist");
+    }
+    if (!_messages.containsKey(id)) {
+      _messages[id] = [];
+    }
+    _messages[id]!.add(ChatMessage(text: text, user: chatUser));
+    _currentID = id;
+    notifyListeners();
+    scrollToBottom();
+  }
+
+  scrollToBottom() {
+    Future.delayed(Duration(milliseconds: 500), () {
+      _scroller.animateTo(_scroller.position.maxScrollExtent,
+          duration: Duration(milliseconds: 200),
+          curve: Curves.fastLinearToSlowEaseIn);
+    });
+  }
+
+  send(ChatMessage message) {
+    if (message.text != null && message.text!.isNotEmpty) {
+      _messages[_currentID]?.add(message);
+      if (_currentID == clientModeID) {
+        FFI.setByName("chat_client_mode", message.text!);
+      } else {
+        final msg = Map()
+          ..["id"] = _currentID
+          ..["text"] = message.text!;
+        FFI.setByName("chat_server_mode", jsonEncode(msg));
+      }
+    }
+    notifyListeners();
+    scrollToBottom();
+  }
+
+  close() {
+    hideChatIconOverlay();
+    hideChatWindowOverlay();
+    notifyListeners();
+  }
+}

flutter/lib/models/file_model.dart

@@ -0,0 +1,775 @@
+import 'dart:async';
+import 'dart:convert';
+import 'package:flutter_hbb/common.dart';
+import 'package:flutter_hbb/pages/file_manager_page.dart';
+import 'package:flutter/material.dart';
+import 'package:flutter_smart_dialog/flutter_smart_dialog.dart';
+import 'package:path/path.dart' as Path;
+
+import 'model.dart';
+
+enum SortBy { Name, Type, Modified, Size }
+
+class FileModel extends ChangeNotifier {
+  var _isLocal = false;
+  var _selectMode = false;
+
+  var _localOption = DirectoryOption();
+  var _remoteOption = DirectoryOption();
+
+  var _jobId = 0;
+
+  var _jobProgress = JobProgress(); // from rust update
+
+  bool get isLocal => _isLocal;
+
+  bool get selectMode => _selectMode;
+
+  JobProgress get jobProgress => _jobProgress;
+
+  JobState get jobState => _jobProgress.state;
+
+  SortBy _sortStyle = SortBy.Name;
+
+  SortBy get sortStyle => _sortStyle;
+
+  FileDirectory _currentLocalDir = FileDirectory();
+
+  FileDirectory get currentLocalDir => _currentLocalDir;
+
+  FileDirectory _currentRemoteDir = FileDirectory();
+
+  FileDirectory get currentRemoteDir => _currentRemoteDir;
+
+  FileDirectory get currentDir => _isLocal ? currentLocalDir : currentRemoteDir;
+
+  String get currentHome => _isLocal ? _localOption.home : _remoteOption.home;
+
+  String get currentShortPath {
+    if (currentDir.path.startsWith(currentHome)) {
+      var path = currentDir.path.replaceFirst(currentHome, "");
+      if (path.length == 0) return "";
+      if (path[0] == "/" || path[0] == "\\") {
+        // remove more '/' or '\'
+        path = path.replaceFirst(path[0], "");
+      }
+      return path;
+    } else {
+      return currentDir.path.replaceFirst(currentHome, "");
+    }
+  }
+
+  bool get currentShowHidden =>
+      _isLocal ? _localOption.showHidden : _remoteOption.showHidden;
+
+  bool get currentIsWindows =>
+      _isLocal ? _localOption.isWindows : _remoteOption.isWindows;
+
+  final _fileFetcher = FileFetcher();
+
+  final _jobResultListener = JobResultListener<Map<String, dynamic>>();
+
+  toggleSelectMode() {
+    if (jobState == JobState.inProgress) {
+      return;
+    }
+    _selectMode = !_selectMode;
+    notifyListeners();
+  }
+
+  togglePage() {
+    _isLocal = !_isLocal;
+    notifyListeners();
+  }
+
+  toggleShowHidden({bool? showHidden, bool? local}) {
+    final isLocal = local ?? _isLocal;
+    if (isLocal) {
+      _localOption.showHidden = showHidden ?? !_localOption.showHidden;
+    } else {
+      _remoteOption.showHidden = showHidden ?? !_remoteOption.showHidden;
+    }
+    refresh();
+  }
+
+  tryUpdateJobProgress(Map<String, dynamic> evt) {
+    try {
+      int id = int.parse(evt['id']);
+      _jobProgress.id = id;
+      _jobProgress.fileNum = int.parse(evt['file_num']);
+      _jobProgress.speed = double.parse(evt['speed']);
+      _jobProgress.finishedSize = int.parse(evt['finished_size']);
+      notifyListeners();
+    } catch (e) {
+      debugPrint("Failed to tryUpdateJobProgress,evt:${evt.toString()}");
+    }
+  }
+
+  receiveFileDir(Map<String, dynamic> evt) {
+    if (_remoteOption.home.isEmpty && evt['is_local'] == "false") {
+      // init remote home, the connection will automatic read remote home when established,
+      try {
+        final fd = FileDirectory.fromJson(jsonDecode(evt['value']));
+        fd.format(_remoteOption.isWindows, sort: _sortStyle);
+        _remoteOption.home = fd.path;
+        debugPrint("init remote home:${fd.path}");
+        _currentRemoteDir = fd;
+        notifyListeners();
+        return;
+      } finally {}
+    }
+    _fileFetcher.tryCompleteTask(evt['value'], evt['is_local']);
+  }
+
+  jobDone(Map<String, dynamic> evt) {
+    if (_jobResultListener.isListening) {
+      _jobResultListener.complete(evt);
+      return;
+    }
+    _selectMode = false;
+    _jobProgress.state = JobState.done;
+    refresh();
+  }
+
+  jobError(Map<String, dynamic> evt) {
+    if (_jobResultListener.isListening) {
+      _jobResultListener.complete(evt);
+      return;
+    }
+
+    debugPrint("jobError $evt");
+    _selectMode = false;
+    _jobProgress.clear();
+    _jobProgress.state = JobState.error;
+    notifyListeners();
+  }
+
+  jobReset() {
+    _jobProgress.clear();
+    notifyListeners();
+  }
+
+  onReady() async {
+    _localOption.home = FFI.getByName("get_home_dir");
+    _localOption.showHidden =
+        FFI.getByName("peer_option", "local_show_hidden").isNotEmpty;
+
+    _remoteOption.showHidden =
+        FFI.getByName("peer_option", "remote_show_hidden").isNotEmpty;
+    _remoteOption.isWindows = FFI.ffiModel.pi.platform == "Windows";
+
+    debugPrint("remote platform: ${FFI.ffiModel.pi.platform}");
+
+    await Future.delayed(Duration(milliseconds: 100));
+
+    final local = FFI.getByName("peer_option", "local_dir");
+    final remote = FFI.getByName("peer_option", "remote_dir");
+    openDirectory(local.isEmpty ? _localOption.home : local, isLocal: true);
+    openDirectory(remote.isEmpty ? _remoteOption.home : remote, isLocal: false);
+    await Future.delayed(Duration(seconds: 1));
+    if (_currentLocalDir.path.isEmpty) {
+      openDirectory(_localOption.home, isLocal: true);
+    }
+    if (_currentRemoteDir.path.isEmpty) {
+      openDirectory(_remoteOption.home, isLocal: false);
+    }
+  }
+
+  onClose() {
+    SmartDialog.dismiss();
+
+    // save config
+    Map<String, String> msg = Map();
+
+    msg["name"] = "local_dir";
+    msg["value"] = _currentLocalDir.path;
+    FFI.setByName('peer_option', jsonEncode(msg));
+
+    msg["name"] = "local_show_hidden";
+    msg["value"] = _localOption.showHidden ? "Y" : "";
+    FFI.setByName('peer_option', jsonEncode(msg));
+
+    msg["name"] = "remote_dir";
+    msg["value"] = _currentRemoteDir.path;
+    FFI.setByName('peer_option', jsonEncode(msg));
+
+    msg["name"] = "remote_show_hidden";
+    msg["value"] = _remoteOption.showHidden ? "Y" : "";
+    FFI.setByName('peer_option', jsonEncode(msg));
+    _currentLocalDir.clear();
+    _currentRemoteDir.clear();
+    _localOption.clear();
+    _remoteOption.clear();
+  }
+
+  refresh() {
+    openDirectory(currentDir.path);
+  }
+
+  openDirectory(String path, {bool? isLocal}) async {
+    isLocal = isLocal ?? _isLocal;
+    final showHidden =
+        isLocal ? _localOption.showHidden : _remoteOption.showHidden;
+    final isWindows =
+        isLocal ? _localOption.isWindows : _remoteOption.isWindows;
+    try {
+      final fd = await _fileFetcher.fetchDirectory(path, isLocal, showHidden);
+      fd.format(isWindows, sort: _sortStyle);
+      if (isLocal) {
+        _currentLocalDir = fd;
+      } else {
+        _currentRemoteDir = fd;
+      }
+      notifyListeners();
+    } catch (e) {
+      debugPrint("Failed to openDirectory :$e");
+    }
+  }
+
+  goHome() {
+    openDirectory(currentHome);
+  }
+
+  goToParentDirectory() {
+    final parent = PathUtil.dirname(currentDir.path, currentIsWindows);
+    openDirectory(parent);
+  }
+
+  sendFiles(SelectedItems items) {
+    if (items.isLocal == null) {
+      debugPrint("Failed to sendFiles ,wrong path state");
+      return;
+    }
+    _jobProgress.state = JobState.inProgress;
+    final toPath =
+        items.isLocal! ? currentRemoteDir.path : currentLocalDir.path;
+    final isWindows =
+        items.isLocal! ? _localOption.isWindows : _remoteOption.isWindows;
+    final showHidden =
+        items.isLocal! ? _localOption.showHidden : _remoteOption.showHidden;
+    items.items.forEach((from) {
+      _jobId++;
+      final msg = {
+        "id": _jobId.toString(),
+        "path": from.path,
+        "to": PathUtil.join(toPath, from.name, isWindows),
+        "show_hidden": showHidden.toString(),
+        "is_remote": (!(items.isLocal!)).toString()
+      };
+      FFI.setByName("send_files", jsonEncode(msg));
+    });
+  }
+
+  bool removeCheckboxRemember = false;
+
+  removeAction(SelectedItems items) async {
+    removeCheckboxRemember = false;
+    if (items.isLocal == null) {
+      debugPrint("Failed to removeFile, wrong path state");
+      return;
+    }
+    final isWindows =
+        items.isLocal! ? _localOption.isWindows : _remoteOption.isWindows;
+    await Future.forEach(items.items, (Entry item) async {
+      _jobId++;
+      var title = "";
+      var content = "";
+      late final List<Entry> entries;
+      if (item.isFile) {
+        title = translate("Are you sure you want to delete this file?");
+        content = "${item.name}";
+        entries = [item];
+      } else if (item.isDirectory) {
+        title = translate("Not an empty directory");
+        showLoading(translate("Waiting"));
+        final fd = await _fileFetcher.fetchDirectoryRecursive(
+            _jobId, item.path, items.isLocal!, true);
+        if (fd.path.isEmpty) {
+          fd.path = item.path;
+        }
+        fd.format(isWindows);
+        SmartDialog.dismiss();
+        if (fd.entries.isEmpty) {
+          final confirm = await showRemoveDialog(
+              translate(
+                  "Are you sure you want to delete this empty directory?"),
+              item.name,
+              false);
+          if (confirm == true) {
+            sendRemoveEmptyDir(item.path, 0, items.isLocal!);
+          }
+          return;
+        }
+        entries = fd.entries;
+      } else {
+        entries = [];
+      }
+
+      for (var i = 0; i < entries.length; i++) {
+        final dirShow = item.isDirectory
+            ? "${translate("Are you sure you want to delete the file of this directory?")}\n"
+            : "";
+        final count = entries.length > 1 ? "${i + 1}/${entries.length}" : "";
+        content = dirShow + "$count \n${entries[i].path}";
+        final confirm =
+            await showRemoveDialog(title, content, item.isDirectory);
+        try {
+          if (confirm == true) {
+            sendRemoveFile(entries[i].path, i, items.isLocal!);
+            final res = await _jobResultListener.start();
+            // handle remove res;
+            if (item.isDirectory &&
+                res['file_num'] == (entries.length - 1).toString()) {
+              sendRemoveEmptyDir(item.path, i, items.isLocal!);
+            }
+          }
+          if (removeCheckboxRemember) {
+            if (confirm == true) {
+              for (var j = i + 1; j < entries.length; j++) {
+                sendRemoveFile(entries[j].path, j, items.isLocal!);
+                final res = await _jobResultListener.start();
+                if (item.isDirectory &&
+                    res['file_num'] == (entries.length - 1).toString()) {
+                  sendRemoveEmptyDir(item.path, i, items.isLocal!);
+                }
+              }
+            }
+            break;
+          }
+        } catch (e) {}
+      }
+    });
+    _selectMode = false;
+    refresh();
+  }
+
+  Future<bool?> showRemoveDialog(
+      String title, String content, bool showCheckbox) async {
+    return await DialogManager.show<bool>(
+        (setState, Function(bool v) close) => CustomAlertDialog(
+                title: Row(
+                  children: [
+                    Icon(Icons.warning, color: Colors.red),
+                    SizedBox(width: 20),
+                    Text(title)
+                  ],
+                ),
+                content: Column(
+                    crossAxisAlignment: CrossAxisAlignment.start,
+                    mainAxisSize: MainAxisSize.min,
+                    children: [
+                      Text(content),
+                      SizedBox(height: 5),
+                      Text(translate("This is irreversible!"),
+                          style: TextStyle(fontWeight: FontWeight.bold)),
+                      showCheckbox
+                          ? CheckboxListTile(
+                              contentPadding: const EdgeInsets.all(0),
+                              dense: true,
+                              controlAffinity: ListTileControlAffinity.leading,
+                              title: Text(
+                                translate("Do this for all conflicts"),
+                              ),
+                              value: removeCheckboxRemember,
+                              onChanged: (v) {
+                                if (v == null) return;
+                                setState(() => removeCheckboxRemember = v);
+                              },
+                            )
+                          : SizedBox.shrink()
+                    ]),
+                actions: [
+                  TextButton(
+                      style: flatButtonStyle,
+                      onPressed: () => close(false),
+                      child: Text(translate("Cancel"))),
+                  TextButton(
+                      style: flatButtonStyle,
+                      onPressed: () => close(true),
+                      child: Text(translate("OK"))),
+                ]),
+        useAnimation: false);
+  }
+
+  sendRemoveFile(String path, int fileNum, bool isLocal) {
+    final msg = {
+      "id": _jobId.toString(),
+      "path": path,
+      "file_num": fileNum.toString(),
+      "is_remote": (!(isLocal)).toString()
+    };
+    FFI.setByName("remove_file", jsonEncode(msg));
+  }
+
+  sendRemoveEmptyDir(String path, int fileNum, bool isLocal) {
+    final msg = {
+      "id": _jobId.toString(),
+      "path": path,
+      "is_remote": (!isLocal).toString()
+    };
+    FFI.setByName("remove_all_empty_dirs", jsonEncode(msg));
+  }
+
+  createDir(String path) {
+    _jobId++;
+    final msg = {
+      "id": _jobId.toString(),
+      "path": path,
+      "is_remote": (!isLocal).toString()
+    };
+    FFI.setByName("create_dir", jsonEncode(msg));
+  }
+
+  cancelJob(int id) {
+    FFI.setByName("cancel_job", id.toString());
+    jobReset();
+  }
+
+  changeSortStyle(SortBy sort) {
+    _sortStyle = sort;
+    _currentLocalDir.changeSortStyle(sort);
+    _currentRemoteDir.changeSortStyle(sort);
+    notifyListeners();
+  }
+}
+
+class JobResultListener<T> {
+  Completer<T>? _completer;
+  Timer? _timer;
+  int _timeoutSecond = 5;
+
+  bool get isListening => _completer != null;
+
+  clear() {
+    if (_completer != null) {
+      _timer?.cancel();
+      _timer = null;
+      _completer!.completeError("Cancel manually");
+      _completer = null;
+      return;
+    }
+  }
+
+  Future<T> start() {
+    if (_completer != null) return Future.error("Already start listen");
+    _completer = Completer();
+    _timer = Timer(Duration(seconds: _timeoutSecond), () {
+      if (!_completer!.isCompleted) {
+        _completer!.completeError("Time out");
+      }
+      _completer = null;
+    });
+    return _completer!.future;
+  }
+
+  complete(T res) {
+    if (_completer != null) {
+      _timer?.cancel();
+      _timer = null;
+      _completer!.complete(res);
+      _completer = null;
+      return;
+    }
+  }
+}
+
+class FileFetcher {
+  // Map<String,Completer<FileDirectory>> localTasks = Map(); // now we only use read local dir sync
+  Map<String, Completer<FileDirectory>> remoteTasks = Map();
+  Map<int, Completer<FileDirectory>> readRecursiveTasks = Map();
+
+  Future<FileDirectory> registerReadTask(bool isLocal, String path) {
+    // final jobs = isLocal?localJobs:remoteJobs; // maybe we will use read local dir async later
+    final tasks = remoteTasks; // bypass now
+    if (tasks.containsKey(path)) {
+      throw "Failed to registerReadTask, already have same read job";
+    }
+    final c = Completer<FileDirectory>();
+    tasks[path] = c;
+
+    Timer(Duration(seconds: 2), () {
+      tasks.remove(path);
+      if (c.isCompleted) return;
+      c.completeError("Failed to read dir,timeout");
+    });
+    return c.future;
+  }
+
+  Future<FileDirectory> registerReadRecursiveTask(int id) {
+    final tasks = readRecursiveTasks;
+    if (tasks.containsKey(id)) {
+      throw "Failed to registerRemoveTask, already have same ReadRecursive job";
+    }
+    final c = Completer<FileDirectory>();
+    tasks[id] = c;
+
+    Timer(Duration(seconds: 2), () {
+      tasks.remove(id);
+      if (c.isCompleted) return;
+      c.completeError("Failed to read dir,timeout");
+    });
+    return c.future;
+  }
+
+  tryCompleteTask(String? msg, String? isLocalStr) {
+    if (msg == null || isLocalStr == null) return;
+    late final isLocal;
+    late final tasks;
+    if (isLocalStr == "true") {
+      isLocal = true;
+    } else if (isLocalStr == "false") {
+      isLocal = false;
+    } else {
+      return;
+    }
+    try {
+      final fd = FileDirectory.fromJson(jsonDecode(msg));
+      if (fd.id > 0) {
+        // fd.id > 0 is result for read recursive
+        // to-do later,will be better if every fetch use ID,so that there will only one task map for read and recursive read
+        tasks = readRecursiveTasks;
+        final completer = tasks.remove(fd.id);
+        completer?.complete(fd);
+      } else if (fd.path.isNotEmpty) {
+        // result for normal read dir
+        // final jobs = isLocal?localJobs:remoteJobs; // maybe we will use read local dir async later
+        tasks = remoteTasks; // bypass now
+        final completer = tasks.remove(fd.path);
+        completer?.complete(fd);
+      }
+    } catch (e) {
+      debugPrint("tryCompleteJob err :$e");
+    }
+  }
+
+  Future<FileDirectory> fetchDirectory(
+      String path, bool isLocal, bool showHidden) async {
+    try {
+      final msg = {"path": path, "show_hidden": showHidden.toString()};
+      if (isLocal) {
+        final res = FFI.getByName("read_local_dir_sync", jsonEncode(msg));
+        final fd = FileDirectory.fromJson(jsonDecode(res));
+        return fd;
+      } else {
+        FFI.setByName("read_remote_dir", jsonEncode(msg));
+        return registerReadTask(isLocal, path);
+      }
+    } catch (e) {
+      return Future.error(e);
+    }
+  }
+
+  Future<FileDirectory> fetchDirectoryRecursive(
+      int id, String path, bool isLocal, bool showHidden) async {
+    // TODO test Recursive is show hidden default?
+    try {
+      final msg = {
+        "id": id.toString(),
+        "path": path,
+        "show_hidden": showHidden.toString(),
+        "is_remote": (!isLocal).toString()
+      };
+      FFI.setByName("read_dir_recursive", jsonEncode(msg));
+      return registerReadRecursiveTask(id);
+    } catch (e) {
+      return Future.error(e);
+    }
+  }
+}
+
+class FileDirectory {
+  List<Entry> entries = [];
+  int id = 0;
+  String path = "";
+
+  FileDirectory();
+
+  FileDirectory.fromJson(Map<String, dynamic> json) {
+    id = json['id'];
+    path = json['path'];
+    json['entries'].forEach((v) {
+      entries.add(new Entry.fromJson(v));
+    });
+  }
+
+  // generate full path for every entry , init sort style if need.
+  format(bool isWindows, {SortBy? sort}) {
+    entries.forEach((entry) {
+      entry.path = PathUtil.join(path, entry.name, isWindows);
+    });
+    if (sort != null) {
+      changeSortStyle(sort);
+    }
+  }
+
+  changeSortStyle(SortBy sort) {
+    entries = _sortList(entries, sort);
+  }
+
+  clear() {
+    entries = [];
+    id = 0;
+    path = "";
+  }
+}
+
+class Entry {
+  int entryType = 4;
+  int modifiedTime = 0;
+  String name = "";
+  String path = "";
+  int size = 0;
+
+  Entry();
+
+  Entry.fromJson(Map<String, dynamic> json) {
+    entryType = json['entry_type'];
+    modifiedTime = json['modified_time'];
+    name = json['name'];
+    size = json['size'];
+  }
+
+  bool get isFile => entryType > 3;
+
+  bool get isDirectory => entryType <= 3;
+
+  DateTime lastModified() {
+    return DateTime.fromMillisecondsSinceEpoch(modifiedTime * 1000);
+  }
+}
+
+enum JobState { none, inProgress, done, error }
+
+class JobProgress {
+  JobState state = JobState.none;
+  var id = 0;
+  var fileNum = 0;
+  var speed = 0.0;
+  var finishedSize = 0;
+
+  clear() {
+    state = JobState.none;
+    id = 0;
+    fileNum = 0;
+    speed = 0;
+    finishedSize = 0;
+  }
+}
+
+class _PathStat {
+  final String path;
+  final DateTime dateTime;
+
+  _PathStat(this.path, this.dateTime);
+}
+
+class PathUtil {
+  static final windowsContext = Path.Context(style: Path.Style.windows);
+  static final posixContext = Path.Context(style: Path.Style.posix);
+
+  static String join(String path1, String path2, bool isWindows) {
+    final pathUtil = isWindows ? windowsContext : posixContext;
+    return pathUtil.join(path1, path2);
+  }
+
+  static List<String> split(String path, bool isWindows) {
+    final pathUtil = isWindows ? windowsContext : posixContext;
+    return pathUtil.split(path);
+  }
+
+  static String dirname(String path, bool isWindows) {
+    final pathUtil = isWindows ? windowsContext : posixContext;
+    return pathUtil.dirname(path);
+  }
+}
+
+class DirectoryOption {
+  String home;
+  bool showHidden;
+  bool isWindows;
+
+  DirectoryOption(
+      {this.home = "", this.showHidden = false, this.isWindows = false});
+
+  clear() {
+    home = "";
+    showHidden = false;
+    isWindows = false;
+  }
+}
+
+// code from file_manager pkg after edit
+List<Entry> _sortList(List<Entry> list, SortBy sortType) {
+  if (sortType == SortBy.Name) {
+    // making list of only folders.
+    final dirs = list.where((element) => element.isDirectory).toList();
+    // sorting folder list by name.
+    dirs.sort((a, b) => a.name.toLowerCase().compareTo(b.name.toLowerCase()));
+
+    // making list of only flies.
+    final files = list.where((element) => element.isFile).toList();
+    // sorting files list by name.
+    files.sort((a, b) => a.name.toLowerCase().compareTo(b.name.toLowerCase()));
+
+    // first folders will go to list (if available) then files will go to list.
+    return [...dirs, ...files];
+  } else if (sortType == SortBy.Modified) {
+    // making the list of Path & DateTime
+    List<_PathStat> _pathStat = [];
+    for (Entry e in list) {
+      _pathStat.add(_PathStat(e.name, e.lastModified()));
+    }
+
+    // sort _pathStat according to date
+    _pathStat.sort((b, a) => a.dateTime.compareTo(b.dateTime));
+
+    // sorting [list] according to [_pathStat]
+    list.sort((a, b) => _pathStat
+        .indexWhere((element) => element.path == a.name)
+        .compareTo(_pathStat.indexWhere((element) => element.path == b.name)));
+    return list;
+  } else if (sortType == SortBy.Type) {
+    // making list of only folders.
+    final dirs = list.where((element) => element.isDirectory).toList();
+
+    // sorting folders by name.
+    dirs.sort((a, b) => a.name.toLowerCase().compareTo(b.name.toLowerCase()));
+
+    // making the list of files
+    final files = list.where((element) => element.isFile).toList();
+
+    // sorting files list by extension.
+    files.sort((a, b) => a.name
+        .toLowerCase()
+        .split('.')
+        .last
+        .compareTo(b.name.toLowerCase().split('.').last));
+    return [...dirs, ...files];
+  } else if (sortType == SortBy.Size) {
+    // create list of path and size
+    Map<String, int> _sizeMap = {};
+    for (Entry e in list) {
+      _sizeMap[e.name] = e.size;
+    }
+
+    // making list of only folders.
+    final dirs = list.where((element) => element.isDirectory).toList();
+    // sorting folder list by name.
+    dirs.sort((a, b) => a.name.toLowerCase().compareTo(b.name.toLowerCase()));
+
+    // making list of only flies.
+    final files = list.where((element) => element.isFile).toList();
+
+    // creating sorted list of [_sizeMapList] by size.
+    final List<MapEntry<String, int>> _sizeMapList = _sizeMap.entries.toList();
+    _sizeMapList.sort((b, a) => a.value.compareTo(b.value));
+
+    // sort [list] according to [_sizeMapList]
+    files.sort((a, b) => _sizeMapList
+        .indexWhere((element) => element.key == a.name)
+        .compareTo(
+            _sizeMapList.indexWhere((element) => element.key == b.name)));
+    return [...dirs, ...files];
+  }
+  return [];
+}

flutter/lib/models/model.dart

@@ -0,0 +1,967 @@
+import 'package:flutter/services.dart';
+import 'package:flutter_hbb/models/chat_model.dart';
+import 'package:flutter_hbb/models/file_model.dart';
+import 'package:flutter_hbb/models/server_model.dart';
+import 'package:flutter_smart_dialog/flutter_smart_dialog.dart';
+import 'package:shared_preferences/shared_preferences.dart';
+import 'dart:math';
+import 'dart:convert';
+import 'dart:typed_data';
+import 'dart:ui' as ui;
+import 'package:flutter/material.dart';
+import 'package:tuple/tuple.dart';
+import 'dart:async';
+import '../common.dart';
+import '../widgets/dialog.dart';
+import '../widgets/overlay.dart';
+import 'native_model.dart' if (dart.library.html) 'web_model.dart';
+
+typedef HandleMsgBox = void Function(Map<String, dynamic> evt, String id);
+
+class FfiModel with ChangeNotifier {
+  PeerInfo _pi = PeerInfo();
+  Display _display = Display();
+  var _decoding = false;
+  bool _waitForImage = false;
+  var _inputBlocked = false;
+  final _permissions = Map<String, bool>();
+  bool? _secure;
+  bool? _direct;
+  bool _touchMode = false;
+  Timer? _timer;
+  var _reconnects = 1;
+
+  Map<String, bool> get permissions => _permissions;
+
+  Display get display => _display;
+
+  bool? get secure => _secure;
+
+  bool? get direct => _direct;
+
+  PeerInfo get pi => _pi;
+
+  bool get inputBlocked => _inputBlocked;
+
+  bool get touchMode => _touchMode;
+
+  bool get isPeerAndroid => _pi.platform == "Android";
+
+  set inputBlocked(v) {
+    _inputBlocked = v;
+  }
+
+  FfiModel() {
+    Translator.call = translate;
+    clear();
+  }
+
+  Future<void> init() async {
+    await PlatformFFI.init();
+  }
+
+  void toggleTouchMode() {
+    if (!isPeerAndroid) {
+      _touchMode = !_touchMode;
+      notifyListeners();
+    }
+  }
+
+  void updatePermission(Map<String, dynamic> evt) {
+    evt.forEach((k, v) {
+      if (k == 'name') return;
+      _permissions[k] = v == 'true';
+    });
+    print('$_permissions');
+    notifyListeners();
+  }
+
+  void updateUser() {
+    notifyListeners();
+  }
+
+  bool keyboard() => _permissions['keyboard'] != false;
+
+  void clear() {
+    _pi = PeerInfo();
+    _display = Display();
+    _waitForImage = false;
+    _secure = null;
+    _direct = null;
+    _inputBlocked = false;
+    _timer?.cancel();
+    _timer = null;
+    clearPermissions();
+  }
+
+  void setConnectionType(bool secure, bool direct) {
+    _secure = secure;
+    _direct = direct;
+  }
+
+  Image? getConnectionImage() {
+    String? icon;
+    if (secure == true && direct == true) {
+      icon = 'secure';
+    } else if (secure == false && direct == true) {
+      icon = 'insecure';
+    } else if (secure == false && direct == false) {
+      icon = 'insecure_relay';
+    } else if (secure == true && direct == false) {
+      icon = 'secure_relay';
+    }
+    return icon == null
+        ? null
+        : Image.asset('assets/$icon.png', width: 48, height: 48);
+  }
+
+  void clearPermissions() {
+    _inputBlocked = false;
+    _permissions.clear();
+  }
+
+  void update(String peerId) {
+    var pos;
+    for (;;) {
+      var evt = FFI.popEvent();
+      if (evt == null) break;
+      var name = evt['name'];
+      if (name == 'msgbox') {
+        handleMsgBox(evt, peerId);
+      } else if (name == 'peer_info') {
+        handlePeerInfo(evt);
+      } else if (name == 'connection_ready') {
+        FFI.ffiModel.setConnectionType(
+            evt['secure'] == 'true', evt['direct'] == 'true');
+      } else if (name == 'switch_display') {
+        handleSwitchDisplay(evt);
+      } else if (name == 'cursor_data') {
+        FFI.cursorModel.updateCursorData(evt);
+      } else if (name == 'cursor_id') {
+        FFI.cursorModel.updateCursorId(evt);
+      } else if (name == 'cursor_position') {
+        pos = evt;
+      } else if (name == 'clipboard') {
+        Clipboard.setData(ClipboardData(text: evt['content']));
+      } else if (name == 'permission') {
+        FFI.ffiModel.updatePermission(evt);
+      } else if (name == 'chat_client_mode') {
+        FFI.chatModel.receive(ChatModel.clientModeID, evt['text'] ?? "");
+      } else if (name == 'chat_server_mode') {
+        FFI.chatModel
+            .receive(int.parse(evt['id'] as String), evt['text'] ?? "");
+      } else if (name == 'file_dir') {
+        FFI.fileModel.receiveFileDir(evt);
+      } else if (name == 'job_progress') {
+        FFI.fileModel.tryUpdateJobProgress(evt);
+      } else if (name == 'job_done') {
+        FFI.fileModel.jobDone(evt);
+      } else if (name == 'job_error') {
+        FFI.fileModel.jobError(evt);
+      } else if (name == 'try_start_without_auth') {
+        FFI.serverModel.loginRequest(evt);
+      } else if (name == 'on_client_authorized') {
+        FFI.serverModel.onClientAuthorized(evt);
+      } else if (name == 'on_client_remove') {
+        FFI.serverModel.onClientRemove(evt);
+      }
+    }
+    if (pos != null) FFI.cursorModel.updateCursorPosition(pos);
+    if (!_decoding) {
+      var rgba = PlatformFFI.getRgba();
+      if (rgba != null) {
+        if (_waitForImage) {
+          _waitForImage = false;
+          SmartDialog.dismiss();
+        }
+        _decoding = true;
+        final pid = FFI.id;
+        ui.decodeImageFromPixels(rgba, _display.width, _display.height,
+            isWeb ? ui.PixelFormat.rgba8888 : ui.PixelFormat.bgra8888, (image) {
+          PlatformFFI.clearRgbaFrame();
+          _decoding = false;
+          if (FFI.id != pid) return;
+          try {
+            // my throw exception, because the listener maybe already dispose
+            FFI.imageModel.update(image);
+          } catch (e) {
+            print('update image: $e');
+          }
+        });
+      }
+    }
+  }
+
+  void handleSwitchDisplay(Map<String, dynamic> evt) {
+    var old = _pi.currentDisplay;
+    _pi.currentDisplay = int.parse(evt['display']);
+    _display.x = double.parse(evt['x']);
+    _display.y = double.parse(evt['y']);
+    _display.width = int.parse(evt['width']);
+    _display.height = int.parse(evt['height']);
+    if (old != _pi.currentDisplay)
+      FFI.cursorModel.updateDisplayOrigin(_display.x, _display.y);
+    notifyListeners();
+  }
+
+  void handleMsgBox(Map<String, dynamic> evt, String id) {
+    var type = evt['type'];
+    var title = evt['title'];
+    var text = evt['text'];
+    if (type == 're-input-password') {
+      wrongPasswordDialog(id);
+    } else if (type == 'input-password') {
+      enterPasswordDialog(id);
+    } else {
+      var hasRetry = evt['hasRetry'] == 'true';
+      print(evt);
+      showMsgBox(type, title, text, hasRetry);
+    }
+  }
+
+  void showMsgBox(String type, String title, String text, bool hasRetry) {
+    msgBox(type, title, text);
+    if (hasRetry) {
+      _timer?.cancel();
+      _timer = Timer(Duration(seconds: _reconnects), () {
+        FFI.reconnect();
+        showLoading(translate('Connecting...'));
+      });
+      _reconnects *= 2;
+    } else {
+      _reconnects = 1;
+    }
+  }
+
+  void handlePeerInfo(Map<String, dynamic> evt) {
+    SmartDialog.dismiss();
+    _pi.version = evt['version'];
+    _pi.username = evt['username'];
+    _pi.hostname = evt['hostname'];
+    _pi.platform = evt['platform'];
+    _pi.sasEnabled = evt['sas_enabled'] == "true";
+    _pi.currentDisplay = int.parse(evt['current_display']);
+
+    if (isPeerAndroid) {
+      _touchMode = true;
+      if (FFI.ffiModel.permissions['keyboard'] != false) {
+        showMobileActionsOverlay();
+      }
+    } else {
+      _touchMode = FFI.getByName('peer_option', "touch-mode") != '';
+    }
+
+    if (evt['is_file_transfer'] == "true") {
+      FFI.fileModel.onReady();
+    } else {
+      _pi.displays = [];
+      List<dynamic> displays = json.decode(evt['displays']);
+      for (int i = 0; i < displays.length; ++i) {
+        Map<String, dynamic> d0 = displays[i];
+        var d = Display();
+        d.x = d0['x'].toDouble();
+        d.y = d0['y'].toDouble();
+        d.width = d0['width'];
+        d.height = d0['height'];
+        _pi.displays.add(d);
+      }
+      if (_pi.currentDisplay < _pi.displays.length) {
+        _display = _pi.displays[_pi.currentDisplay];
+      }
+      if (displays.length > 0) {
+        showLoading(translate('Connected, waiting for image...'));
+        _waitForImage = true;
+        _reconnects = 1;
+      }
+    }
+    notifyListeners();
+  }
+}
+
+class ImageModel with ChangeNotifier {
+  ui.Image? _image;
+
+  ui.Image? get image => _image;
+
+  void update(ui.Image? image) {
+    if (_image == null && image != null) {
+      if (isDesktop) {
+        FFI.canvasModel.updateViewStyle();
+      } else {
+        final size = MediaQueryData.fromWindow(ui.window).size;
+        final xscale = size.width / image.width;
+        final yscale = size.height / image.height;
+        FFI.canvasModel.scale = max(xscale, yscale);
+      }
+      initializeCursorAndCanvas();
+      Future.delayed(Duration(milliseconds: 1), () {
+        if (FFI.ffiModel.isPeerAndroid) {
+          FFI.setByName(
+              'peer_option', '{"name": "view-style", "value": "shrink"}');
+          FFI.canvasModel.updateViewStyle();
+        }
+      });
+    }
+    _image = image;
+    if (image != null) notifyListeners();
+  }
+
+  double get maxScale {
+    if (_image == null) return 1.0;
+    final size = MediaQueryData.fromWindow(ui.window).size;
+    final xscale = size.width / _image!.width;
+    final yscale = size.height / _image!.height;
+    return max(1.0, max(xscale, yscale));
+  }
+
+  double get minScale {
+    if (_image == null) return 1.0;
+    final size = MediaQueryData.fromWindow(ui.window).size;
+    final xscale = size.width / _image!.width;
+    final yscale = size.height / _image!.height;
+    return min(xscale, yscale);
+  }
+}
+
+class CanvasModel with ChangeNotifier {
+  double _x = 0;
+  double _y = 0;
+  double _scale = 1.0;
+
+  CanvasModel();
+
+  double get x => _x;
+
+  double get y => _y;
+
+  double get scale => _scale;
+
+  void updateViewStyle() {
+    final s = FFI.getByName('peer_option', 'view-style');
+    final size = MediaQueryData.fromWindow(ui.window).size;
+    final s1 = size.width / FFI.ffiModel.display.width;
+    final s2 = size.height / FFI.ffiModel.display.height;
+    if (s == 'shrink') {
+      final s = s1 < s2 ? s1 : s2;
+      if (s < 1) {
+        _scale = s;
+      }
+    } else if (s == 'stretch') {
+      final s = s1 > s2 ? s1 : s2;
+      if (s > 1) {
+        _scale = s;
+      }
+    } else {
+      _scale = 1;
+    }
+    _x = (size.width - FFI.ffiModel.display.width * _scale) / 2;
+    _y = (size.height - FFI.ffiModel.display.height * _scale) / 2;
+    notifyListeners();
+  }
+
+  void update(double x, double y, double scale) {
+    _x = x;
+    _y = y;
+    _scale = scale;
+    notifyListeners();
+  }
+
+  void moveDesktopMouse(double x, double y) {
+    final size = MediaQueryData.fromWindow(ui.window).size;
+    final dw = FFI.ffiModel.display.width * _scale;
+    final dh = FFI.ffiModel.display.height * _scale;
+    var dxOffset = 0;
+    var dyOffset = 0;
+    if (dw > size.width) {
+      dxOffset = (x - dw * (x / size.width) - _x).toInt();
+    }
+    if (dh > size.height) {
+      dyOffset = (y - dh * (y / size.height) - _y).toInt();
+    }
+    _x += dxOffset;
+    _y += dyOffset;
+    if (dxOffset != 0 || dyOffset != 0) {
+      notifyListeners();
+    }
+    FFI.cursorModel.moveLocal(x, y);
+  }
+
+  set scale(v) {
+    _scale = v;
+    notifyListeners();
+  }
+
+  void panX(double dx) {
+    _x += dx;
+    notifyListeners();
+  }
+
+  void resetOffset() {
+    if (isDesktop) {
+      updateViewStyle();
+    } else {
+      _x = 0;
+      _y = 0;
+    }
+    notifyListeners();
+  }
+
+  void panY(double dy) {
+    _y += dy;
+    notifyListeners();
+  }
+
+  void updateScale(double v) {
+    if (FFI.imageModel.image == null) return;
+    final offset = FFI.cursorModel.offset;
+    var r = FFI.cursorModel.getVisibleRect();
+    final px0 = (offset.dx - r.left) * _scale;
+    final py0 = (offset.dy - r.top) * _scale;
+    _scale *= v;
+    final maxs = FFI.imageModel.maxScale;
+    final mins = FFI.imageModel.minScale;
+    if (_scale > maxs) _scale = maxs;
+    if (_scale < mins) _scale = mins;
+    r = FFI.cursorModel.getVisibleRect();
+    final px1 = (offset.dx - r.left) * _scale;
+    final py1 = (offset.dy - r.top) * _scale;
+    _x -= px1 - px0;
+    _y -= py1 - py0;
+    notifyListeners();
+  }
+
+  void clear([bool notify = false]) {
+    _x = 0;
+    _y = 0;
+    _scale = 1.0;
+    if (notify) notifyListeners();
+  }
+}
+
+class CursorModel with ChangeNotifier {
+  ui.Image? _image;
+  final _images = Map<int, Tuple3<ui.Image, double, double>>();
+  double _x = -10000;
+  double _y = -10000;
+  double _hotx = 0;
+  double _hoty = 0;
+  double _displayOriginX = 0;
+  double _displayOriginY = 0;
+
+  ui.Image? get image => _image;
+
+  double get x => _x - _displayOriginX;
+
+  double get y => _y - _displayOriginY;
+
+  Offset get offset => Offset(_x, _y);
+
+  double get hotx => _hotx;
+
+  double get hoty => _hoty;
+
+  // remote physical display coordinate
+  Rect getVisibleRect() {
+    final size = MediaQueryData.fromWindow(ui.window).size;
+    final xoffset = FFI.canvasModel.x;
+    final yoffset = FFI.canvasModel.y;
+    final scale = FFI.canvasModel.scale;
+    final x0 = _displayOriginX - xoffset / scale;
+    final y0 = _displayOriginY - yoffset / scale;
+    return Rect.fromLTWH(x0, y0, size.width / scale, size.height / scale);
+  }
+
+  double adjustForKeyboard() {
+    final m = MediaQueryData.fromWindow(ui.window);
+    var keyboardHeight = m.viewInsets.bottom;
+    final size = m.size;
+    if (keyboardHeight < 100) return 0;
+    final s = FFI.canvasModel.scale;
+    final thresh = (size.height - keyboardHeight) / 2;
+    var h = (_y - getVisibleRect().top) * s; // local physical display height
+    return h - thresh;
+  }
+
+  void touch(double x, double y, MouseButtons button) {
+    moveLocal(x, y);
+    FFI.moveMouse(_x, _y);
+    FFI.tap(button);
+  }
+
+  void move(double x, double y) {
+    moveLocal(x, y);
+    FFI.moveMouse(_x, _y);
+  }
+
+  void moveLocal(double x, double y) {
+    final scale = FFI.canvasModel.scale;
+    final xoffset = FFI.canvasModel.x;
+    final yoffset = FFI.canvasModel.y;
+    _x = (x - xoffset) / scale + _displayOriginX;
+    _y = (y - yoffset) / scale + _displayOriginY;
+    notifyListeners();
+  }
+
+  void reset() {
+    _x = _displayOriginX;
+    _y = _displayOriginY;
+    FFI.moveMouse(_x, _y);
+    FFI.canvasModel.clear(true);
+    notifyListeners();
+  }
+
+  void updatePan(double dx, double dy, bool touchMode) {
+    if (FFI.imageModel.image == null) return;
+    if (touchMode) {
+      final scale = FFI.canvasModel.scale;
+      _x += dx / scale;
+      _y += dy / scale;
+      FFI.moveMouse(_x, _y);
+      notifyListeners();
+      return;
+    }
+    final scale = FFI.canvasModel.scale;
+    dx /= scale;
+    dy /= scale;
+    final r = getVisibleRect();
+    var cx = r.center.dx;
+    var cy = r.center.dy;
+    var tryMoveCanvasX = false;
+    if (dx > 0) {
+      final maxCanvasCanMove = _displayOriginX +
+          FFI.imageModel.image!.width -
+          r.right.roundToDouble();
+      tryMoveCanvasX = _x + dx > cx && maxCanvasCanMove > 0;
+      if (tryMoveCanvasX) {
+        dx = min(dx, maxCanvasCanMove);
+      } else {
+        final maxCursorCanMove = r.right - _x;
+        dx = min(dx, maxCursorCanMove);
+      }
+    } else if (dx < 0) {
+      final maxCanvasCanMove = _displayOriginX - r.left.roundToDouble();
+      tryMoveCanvasX = _x + dx < cx && maxCanvasCanMove < 0;
+      if (tryMoveCanvasX) {
+        dx = max(dx, maxCanvasCanMove);
+      } else {
+        final maxCursorCanMove = r.left - _x;
+        dx = max(dx, maxCursorCanMove);
+      }
+    }
+    var tryMoveCanvasY = false;
+    if (dy > 0) {
+      final mayCanvasCanMove = _displayOriginY +
+          FFI.imageModel.image!.height -
+          r.bottom.roundToDouble();
+      tryMoveCanvasY = _y + dy > cy && mayCanvasCanMove > 0;
+      if (tryMoveCanvasY) {
+        dy = min(dy, mayCanvasCanMove);
+      } else {
+        final mayCursorCanMove = r.bottom - _y;
+        dy = min(dy, mayCursorCanMove);
+      }
+    } else if (dy < 0) {
+      final mayCanvasCanMove = _displayOriginY - r.top.roundToDouble();
+      tryMoveCanvasY = _y + dy < cy && mayCanvasCanMove < 0;
+      if (tryMoveCanvasY) {
+        dy = max(dy, mayCanvasCanMove);
+      } else {
+        final mayCursorCanMove = r.top - _y;
+        dy = max(dy, mayCursorCanMove);
+      }
+    }
+
+    if (dx == 0 && dy == 0) return;
+    _x += dx;
+    _y += dy;
+    if (tryMoveCanvasX && dx != 0) {
+      FFI.canvasModel.panX(-dx);
+    }
+    if (tryMoveCanvasY && dy != 0) {
+      FFI.canvasModel.panY(-dy);
+    }
+
+    FFI.moveMouse(_x, _y);
+    notifyListeners();
+  }
+
+  void updateCursorData(Map<String, dynamic> evt) {
+    var id = int.parse(evt['id']);
+    _hotx = double.parse(evt['hotx']);
+    _hoty = double.parse(evt['hoty']);
+    var width = int.parse(evt['width']);
+    var height = int.parse(evt['height']);
+    List<dynamic> colors = json.decode(evt['colors']);
+    final rgba = Uint8List.fromList(colors.map((s) => s as int).toList());
+    var pid = FFI.id;
+    ui.decodeImageFromPixels(rgba, width, height, ui.PixelFormat.rgba8888,
+        (image) {
+      if (FFI.id != pid) return;
+      _image = image;
+      _images[id] = Tuple3(image, _hotx, _hoty);
+      try {
+        // my throw exception, because the listener maybe already dispose
+        notifyListeners();
+      } catch (e) {
+        print('notify cursor: $e');
+      }
+    });
+  }
+
+  void updateCursorId(Map<String, dynamic> evt) {
+    final tmp = _images[int.parse(evt['id'])];
+    if (tmp != null) {
+      _image = tmp.item1;
+      _hotx = tmp.item2;
+      _hoty = tmp.item3;
+      notifyListeners();
+    }
+  }
+
+  void updateCursorPosition(Map<String, dynamic> evt) {
+    _x = double.parse(evt['x']);
+    _y = double.parse(evt['y']);
+    notifyListeners();
+  }
+
+  void updateDisplayOrigin(double x, double y) {
+    _displayOriginX = x;
+    _displayOriginY = y;
+    _x = x + 1;
+    _y = y + 1;
+    FFI.moveMouse(x, y);
+    FFI.canvasModel.resetOffset();
+    notifyListeners();
+  }
+
+  void updateDisplayOriginWithCursor(
+      double x, double y, double xCursor, double yCursor) {
+    _displayOriginX = x;
+    _displayOriginY = y;
+    _x = xCursor;
+    _y = yCursor;
+    FFI.moveMouse(x, y);
+    notifyListeners();
+  }
+
+  void clear() {
+    _x = -10000;
+    _x = -10000;
+    _image = null;
+    _images.clear();
+  }
+}
+
+enum MouseButtons { left, right, wheel }
+
+extension ToString on MouseButtons {
+  String get value {
+    switch (this) {
+      case MouseButtons.left:
+        return "left";
+      case MouseButtons.right:
+        return "right";
+      case MouseButtons.wheel:
+        return "wheel";
+    }
+  }
+}
+
+class FFI {
+  static var id = "";
+  static var shift = false;
+  static var ctrl = false;
+  static var alt = false;
+  static var command = false;
+  static var version = "";
+  static final imageModel = ImageModel();
+  static final ffiModel = FfiModel();
+  static final cursorModel = CursorModel();
+  static final canvasModel = CanvasModel();
+  static final serverModel = ServerModel();
+  static final chatModel = ChatModel();
+  static final fileModel = FileModel();
+
+  static String getId() {
+    return getByName('remote_id');
+  }
+
+  static void tap(MouseButtons button) {
+    sendMouse('down', button);
+    sendMouse('up', button);
+  }
+
+  static void scroll(double y) {
+    var y2 = y.round();
+    if (y2 == 0) return;
+    setByName('send_mouse',
+        json.encode(modify({'type': 'wheel', 'y': y2.toString()})));
+  }
+
+  static void reconnect() {
+    setByName('reconnect');
+    FFI.ffiModel.clearPermissions();
+  }
+
+  static void resetModifiers() {
+    shift = ctrl = alt = command = false;
+  }
+
+  static Map<String, String> modify(Map<String, String> evt) {
+    if (ctrl) evt['ctrl'] = 'true';
+    if (shift) evt['shift'] = 'true';
+    if (alt) evt['alt'] = 'true';
+    if (command) evt['command'] = 'true';
+    return evt;
+  }
+
+  static void sendMouse(String type, MouseButtons button) {
+    if (!ffiModel.keyboard()) return;
+    setByName('send_mouse',
+        json.encode(modify({'type': type, 'buttons': button.value})));
+  }
+
+  static void inputKey(String name, {bool? down, bool? press}) {
+    if (!ffiModel.keyboard()) return;
+    setByName(
+        'input_key',
+        json.encode(modify({
+          'name': name,
+          'down': (down ?? false).toString(),
+          'press': (press ?? true).toString()
+        })));
+  }
+
+  static void moveMouse(double x, double y) {
+    if (!ffiModel.keyboard()) return;
+    var x2 = x.toInt();
+    var y2 = y.toInt();
+    setByName('send_mouse', json.encode(modify({'x': '$x2', 'y': '$y2'})));
+  }
+
+  static List<Peer> peers() {
+    try {
+      var str = getByName('peers');
+      if (str == "") return [];
+      List<dynamic> peers = json.decode(str);
+      return peers
+          .map((s) => s as List<dynamic>)
+          .map((s) =>
+              Peer.fromJson(s[0] as String, s[1] as Map<String, dynamic>))
+          .toList();
+    } catch (e) {
+      print('peers(): $e');
+    }
+    return [];
+  }
+
+  static void connect(String id, {bool isFileTransfer = false}) {
+    if (isFileTransfer) {
+      setByName('connect_file_transfer', id);
+    } else {
+      setByName('connect', id);
+    }
+    FFI.id = id;
+  }
+
+  static Map<String, dynamic>? popEvent() {
+    var s = getByName('event');
+    if (s == '') return null;
+    try {
+      Map<String, dynamic> event = json.decode(s);
+      return event;
+    } catch (e) {
+      print('popEvent(): $e');
+    }
+    return null;
+  }
+
+  static void login(String password, bool remember) {
+    setByName(
+        'login',
+        json.encode({
+          'password': password,
+          'remember': remember ? 'true' : 'false',
+        }));
+  }
+
+  static void close() {
+    chatModel.close();
+    if (FFI.imageModel.image != null && !isDesktop) {
+      savePreference(id, cursorModel.x, cursorModel.y, canvasModel.x,
+          canvasModel.y, canvasModel.scale, ffiModel.pi.currentDisplay);
+    }
+    id = "";
+    setByName('close', '');
+    imageModel.update(null);
+    cursorModel.clear();
+    ffiModel.clear();
+    canvasModel.clear();
+    resetModifiers();
+  }
+
+  static String getByName(String name, [String arg = '']) {
+    return PlatformFFI.getByName(name, arg);
+  }
+
+  static void setByName(String name, [String value = '']) {
+    PlatformFFI.setByName(name, value);
+  }
+
+  static handleMouse(Map<String, dynamic> evt) {
+    var type = '';
+    var isMove = false;
+    switch (evt['type']) {
+      case 'mousedown':
+        type = 'down';
+        break;
+      case 'mouseup':
+        type = 'up';
+        break;
+      case 'mousemove':
+        isMove = true;
+        break;
+      default:
+        return;
+    }
+    evt['type'] = type;
+    var x = evt['x'];
+    var y = evt['y'];
+    if (isMove) {
+      FFI.canvasModel.moveDesktopMouse(x, y);
+    }
+    final d = FFI.ffiModel.display;
+    x -= FFI.canvasModel.x;
+    y -= FFI.canvasModel.y;
+    if (!isMove && (x < 0 || x > d.width || y < 0 || y > d.height)) {
+      return;
+    }
+    x /= FFI.canvasModel.scale;
+    y /= FFI.canvasModel.scale;
+    x += d.x;
+    y += d.y;
+    if (type != '') {
+      x = 0;
+      y = 0;
+    }
+    evt['x'] = '${x.round()}';
+    evt['y'] = '${y.round()}';
+    var buttons = '';
+    switch (evt['buttons']) {
+      case 1:
+        buttons = 'left';
+        break;
+      case 2:
+        buttons = 'right';
+        break;
+      case 4:
+        buttons = 'wheel';
+        break;
+    }
+    evt['buttons'] = buttons;
+    setByName('send_mouse', json.encode(evt));
+  }
+
+  static listenToMouse(bool yesOrNo) {
+    if (yesOrNo) {
+      PlatformFFI.startDesktopWebListener();
+    } else {
+      PlatformFFI.stopDesktopWebListener();
+    }
+  }
+
+  static void setMethodCallHandler(FMethod callback) {
+    PlatformFFI.setMethodCallHandler(callback);
+  }
+
+  static Future<bool> invokeMethod(String method, [dynamic arguments]) async {
+    return await PlatformFFI.invokeMethod(method, arguments);
+  }
+}
+
+class Peer {
+  final String id;
+  final String username;
+  final String hostname;
+  final String platform;
+
+  Peer.fromJson(String id, Map<String, dynamic> json)
+      : id = id,
+        username = json['username'],
+        hostname = json['hostname'],
+        platform = json['platform'];
+}
+
+class Display {
+  double x = 0;
+  double y = 0;
+  int width = 0;
+  int height = 0;
+}
+
+class PeerInfo {
+  String version = "";
+  String username = "";
+  String hostname = "";
+  String platform = "";
+  bool sasEnabled = false;
+  int currentDisplay = 0;
+  List<Display> displays = [];
+}
+
+void savePreference(String id, double xCursor, double yCursor, double xCanvas,
+    double yCanvas, double scale, int currentDisplay) async {
+  SharedPreferences prefs = await SharedPreferences.getInstance();
+  final p = Map<String, dynamic>();
+  p['xCursor'] = xCursor;
+  p['yCursor'] = yCursor;
+  p['xCanvas'] = xCanvas;
+  p['yCanvas'] = yCanvas;
+  p['scale'] = scale;
+  p['currentDisplay'] = currentDisplay;
+  prefs.setString('peer' + id, json.encode(p));
+}
+
+Future<Map<String, dynamic>?> getPreference(String id) async {
+  if (!isDesktop) return null;
+  SharedPreferences prefs = await SharedPreferences.getInstance();
+  var p = prefs.getString('peer' + id);
+  if (p == null) return null;
+  Map<String, dynamic> m = json.decode(p);
+  return m;
+}
+
+void removePreference(String id) async {
+  SharedPreferences prefs = await SharedPreferences.getInstance();
+  prefs.remove('peer' + id);
+}
+
+void initializeCursorAndCanvas() async {
+  var p = await getPreference(FFI.id);
+  int currentDisplay = 0;
+  if (p != null) {
+    currentDisplay = p['currentDisplay'];
+  }
+  if (p == null || currentDisplay != FFI.ffiModel.pi.currentDisplay) {
+    FFI.cursorModel
+        .updateDisplayOrigin(FFI.ffiModel.display.x, FFI.ffiModel.display.y);
+    return;
+  }
+  double xCursor = p['xCursor'];
+  double yCursor = p['yCursor'];
+  double xCanvas = p['xCanvas'];
+  double yCanvas = p['yCanvas'];
+  double scale = p['scale'];
+  FFI.cursorModel.updateDisplayOriginWithCursor(
+      FFI.ffiModel.display.x, FFI.ffiModel.display.y, xCursor, yCursor);
+  FFI.canvasModel.update(xCanvas, yCanvas, scale);
+}
+
+String translate(String name) {
+  if (name.startsWith('Failed to') && name.contains(': ')) {
+    return name.split(': ').map((x) => translate(x)).join(': ');
+  }
+  var a = 'translate';
+  var b = '{"locale": "$localeName", "text": "$name"}';
+  return FFI.getByName(a, b);
+}

flutter/lib/models/native_model.dart

@@ -0,0 +1,136 @@
+import 'dart:io';
+import 'dart:typed_data';
+import 'dart:ffi';
+import 'package:ffi/ffi.dart';
+import 'package:path_provider/path_provider.dart';
+import 'package:device_info/device_info.dart';
+import 'package:package_info/package_info.dart';
+import 'package:external_path/external_path.dart';
+import 'package:flutter/services.dart';
+import '../common.dart';
+
+class RgbaFrame extends Struct {
+  @Uint32()
+  external int len;
+  external Pointer<Uint8> data;
+}
+
+typedef F2 = Pointer<Utf8> Function(Pointer<Utf8>, Pointer<Utf8>);
+typedef F3 = void Function(Pointer<Utf8>, Pointer<Utf8>);
+typedef F4 = void Function(Pointer<RgbaFrame>);
+typedef F5 = Pointer<RgbaFrame> Function();
+
+class PlatformFFI {
+  static Pointer<RgbaFrame>? _lastRgbaFrame;
+  static String _dir = '';
+  static String _homeDir = '';
+  static F2? _getByName;
+  static F3? _setByName;
+  static F4? _freeRgba;
+  static F5? _getRgba;
+
+  static void clearRgbaFrame() {
+    if (_lastRgbaFrame != null &&
+        _lastRgbaFrame != nullptr &&
+        _freeRgba != null) _freeRgba!(_lastRgbaFrame!);
+  }
+
+  static Uint8List? getRgba() {
+    if (_getRgba == null) return null;
+    _lastRgbaFrame = _getRgba!();
+    if (_lastRgbaFrame == null || _lastRgbaFrame == nullptr) return null;
+    final ref = _lastRgbaFrame!.ref;
+    return Uint8List.sublistView(ref.data.asTypedList(ref.len));
+  }
+
+  static Future<String> getVersion() async {
+    PackageInfo packageInfo = await PackageInfo.fromPlatform();
+    return packageInfo.version;
+  }
+
+  static String getByName(String name, [String arg = '']) {
+    if (_getByName == null) return '';
+    var a = name.toNativeUtf8();
+    var b = arg.toNativeUtf8();
+    var p = _getByName!(a, b);
+    assert(p != nullptr);
+    var res = p.toDartString();
+    calloc.free(p);
+    calloc.free(a);
+    calloc.free(b);
+    return res;
+  }
+
+  static void setByName(String name, [String value = '']) {
+    if (_setByName == null) return;
+    var a = name.toNativeUtf8();
+    var b = value.toNativeUtf8();
+    _setByName!(a, b);
+    calloc.free(a);
+    calloc.free(b);
+  }
+
+  static Future<Null> init() async {
+    isIOS = Platform.isIOS;
+    isAndroid = Platform.isAndroid;
+    final dylib = Platform.isAndroid
+        ? DynamicLibrary.open('librustdesk.so')
+        : DynamicLibrary.process();
+    print('initializing FFI');
+    try {
+      _getByName = dylib.lookupFunction<F2, F2>('get_by_name');
+      _setByName =
+          dylib.lookupFunction<Void Function(Pointer<Utf8>, Pointer<Utf8>), F3>(
+              'set_by_name');
+      _freeRgba = dylib
+          .lookupFunction<Void Function(Pointer<RgbaFrame>), F4>('free_rgba');
+      _getRgba = dylib.lookupFunction<F5, F5>('get_rgba');
+      _dir = (await getApplicationDocumentsDirectory()).path;
+      try {
+        _homeDir = (await ExternalPath.getExternalStorageDirectories())[0];
+      } catch (e) {
+        print(e);
+      }
+      String id = 'NA';
+      String name = 'Flutter';
+      DeviceInfoPlugin deviceInfo = DeviceInfoPlugin();
+      if (Platform.isAndroid) {
+        AndroidDeviceInfo androidInfo = await deviceInfo.androidInfo;
+        name = '${androidInfo.brand}-${androidInfo.model}';
+        id = androidInfo.id.hashCode.toString();
+        androidVersion = androidInfo.version.sdkInt;
+      } else {
+        IosDeviceInfo iosInfo = await deviceInfo.iosInfo;
+        name = iosInfo.utsname.machine;
+        id = iosInfo.identifierForVendor.hashCode.toString();
+      }
+      print("info1-id:$id,info2-name:$name,dir:$_dir,homeDir:$_homeDir");
+      setByName('info1', id);
+      setByName('info2', name);
+      setByName('home_dir', _homeDir);
+      setByName('init', _dir);
+    } catch (e) {
+      print(e);
+    }
+    version = await getVersion();
+  }
+
+  static void startDesktopWebListener() {}
+
+  static void stopDesktopWebListener() {}
+
+  static void setMethodCallHandler(FMethod callback) {
+    toAndroidChannel.setMethodCallHandler((call) async {
+      callback(call.method, call.arguments);
+      return null;
+    });
+  }
+
+  static invokeMethod(String method, [dynamic arguments]) async {
+    if (!isAndroid) return Future<bool>(() => false);
+    return await toAndroidChannel.invokeMethod(method, arguments);
+  }
+}
+
+final localeName = Platform.localeName;
+final toAndroidChannel = MethodChannel("mChannel");

flutter/lib/models/server_model.dart

@@ -0,0 +1,510 @@
+import 'dart:async';
+import 'dart:convert';
+import 'package:dash_chat/dash_chat.dart';
+import 'package:flutter/material.dart';
+import 'package:wakelock/wakelock.dart';
+import '../common.dart';
+import '../pages/server_page.dart';
+import 'model.dart';
+
+const loginDialogTag = "LOGIN";
+final _emptyIdShow = translate("Generating ...");
+
+class ServerModel with ChangeNotifier {
+  Timer? _interval;
+  bool _isStart = false; // Android MainService status
+  bool _mediaOk = false;
+  bool _inputOk = false;
+  bool _audioOk = false;
+  bool _fileOk = false;
+  int _connectStatus = 0; // Rendezvous Server status
+
+  final _serverId = TextEditingController(text: _emptyIdShow);
+  final _serverPasswd = TextEditingController(text: "");
+
+  Map<int, Client> _clients = {};
+
+  bool get isStart => _isStart;
+
+  bool get mediaOk => _mediaOk;
+
+  bool get inputOk => _inputOk;
+
+  bool get audioOk => _audioOk;
+
+  bool get fileOk => _fileOk;
+
+  int get connectStatus => _connectStatus;
+
+  TextEditingController get serverId => _serverId;
+
+  TextEditingController get serverPasswd => _serverPasswd;
+
+  Map<int, Client> get clients => _clients;
+
+  final controller = ScrollController();
+
+  ServerModel() {
+    () async {
+      /**
+       * 1. check android permission
+       * 2. check config
+       * audio true by default (if permission on) (false default < Android 10)
+       * file true by default (if permission on)
+       * input false by default (it need turning on manually everytime)
+       */
+      await Future.delayed(Duration(seconds: 1));
+
+      // audio
+      if (androidVersion < 30 || !await PermissionManager.check("audio")) {
+        _audioOk = false;
+        FFI.setByName(
+            'option',
+            jsonEncode(Map()
+              ..["name"] = "enable-audio"
+              ..["value"] = "N"));
+      } else {
+        final audioOption = FFI.getByName('option', 'enable-audio');
+        _audioOk = audioOption.isEmpty;
+      }
+
+      // file
+      if (!await PermissionManager.check("file")) {
+        _fileOk = false;
+        FFI.setByName(
+            'option',
+            jsonEncode(Map()
+              ..["name"] = "enable-file-transfer"
+              ..["value"] = "N"));
+      } else {
+        final fileOption = FFI.getByName('option', 'enable-file-transfer');
+        _fileOk = fileOption.isEmpty;
+      }
+
+      // input (mouse control)
+      Map<String, String> res = Map()
+        ..["name"] = "enable-keyboard"
+        ..["value"] = 'N';
+      FFI.setByName('option', jsonEncode(res)); // input false by default
+      notifyListeners();
+    }();
+
+    Timer.periodic(Duration(seconds: 1), (timer) {
+      var status = int.tryParse(FFI.getByName('connect_statue')) ?? 0;
+      if (status > 0) {
+        status = 1;
+      }
+      if (status != _connectStatus) {
+        _connectStatus = status;
+        notifyListeners();
+      }
+      final res =
+          FFI.getByName('check_clients_length', _clients.length.toString());
+      if (res.isNotEmpty) {
+        debugPrint("clients not match!");
+        updateClientState(res);
+      }
+    });
+  }
+
+  toggleAudio() async {
+    if (!_audioOk && !await PermissionManager.check("audio")) {
+      final res = await PermissionManager.request("audio");
+      if (!res) {
+        // TODO handle fail
+        return;
+      }
+    }
+
+    _audioOk = !_audioOk;
+    Map<String, String> res = Map()
+      ..["name"] = "enable-audio"
+      ..["value"] = _audioOk ? '' : 'N';
+    FFI.setByName('option', jsonEncode(res));
+    notifyListeners();
+  }
+
+  toggleFile() async {
+    if (!_fileOk && !await PermissionManager.check("file")) {
+      final res = await PermissionManager.request("file");
+      if (!res) {
+        // TODO handle fail
+        return;
+      }
+    }
+
+    _fileOk = !_fileOk;
+    Map<String, String> res = Map()
+      ..["name"] = "enable-file-transfer"
+      ..["value"] = _fileOk ? '' : 'N';
+    FFI.setByName('option', jsonEncode(res));
+    notifyListeners();
+  }
+
+  toggleInput() {
+    if (_inputOk) {
+      FFI.invokeMethod("stop_input");
+    } else {
+      showInputWarnAlert();
+    }
+  }
+
+  toggleService() async {
+    if (_isStart) {
+      final res =
+          await DialogManager.show<bool>((setState, close) => CustomAlertDialog(
+                title: Row(children: [
+                  Icon(Icons.warning_amber_sharp,
+                      color: Colors.redAccent, size: 28),
+                  SizedBox(width: 10),
+                  Text(translate("Warning")),
+                ]),
+                content: Text(translate("android_stop_service_tip")),
+                actions: [
+                  TextButton(
+                      onPressed: () => close(),
+                      child: Text(translate("Cancel"))),
+                  ElevatedButton(
+                      onPressed: () => close(true),
+                      child: Text(translate("OK"))),
+                ],
+              ));
+      if (res == true) {
+        stopService();
+      }
+    } else {
+      final res =
+          await DialogManager.show<bool>((setState, close) => CustomAlertDialog(
+                title: Row(children: [
+                  Icon(Icons.warning_amber_sharp,
+                      color: Colors.redAccent, size: 28),
+                  SizedBox(width: 10),
+                  Text(translate("Warning")),
+                ]),
+                content: Text(translate("android_service_will_start_tip")),
+                actions: [
+                  TextButton(
+                      onPressed: () => close(),
+                      child: Text(translate("Cancel"))),
+                  ElevatedButton(
+                      onPressed: () => close(true),
+                      child: Text(translate("OK"))),
+                ],
+              ));
+      if (res == true) {
+        startService();
+      }
+    }
+  }
+
+  Future<Null> startService() async {
+    _isStart = true;
+    notifyListeners();
+    FFI.setByName("ensure_init_event_queue");
+    _interval?.cancel();
+    _interval = Timer.periodic(Duration(milliseconds: 30), (timer) {
+      FFI.ffiModel.update("");
+    });
+    await FFI.invokeMethod("init_service");
+    FFI.setByName("start_service");
+    getIDPasswd();
+    updateClientState();
+    Wakelock.enable();
+  }
+
+  Future<Null> stopService() async {
+    _isStart = false;
+    _interval?.cancel();
+    _interval = null;
+    FFI.serverModel.closeAll();
+    await FFI.invokeMethod("stop_service");
+    FFI.setByName("stop_service");
+    notifyListeners();
+    Wakelock.disable();
+  }
+
+  Future<Null> initInput() async {
+    await FFI.invokeMethod("init_input");
+  }
+
+  Future<bool> updatePassword(String pw) async {
+    final oldPasswd = _serverPasswd.text;
+    FFI.setByName("update_password", pw);
+    await Future.delayed(Duration(milliseconds: 500));
+    await getIDPasswd(force: true);
+
+    // check result
+    if (pw == "") {
+      if (_serverPasswd.text.isNotEmpty && _serverPasswd.text != oldPasswd) {
+        return true;
+      } else {
+        return false;
+      }
+    } else {
+      if (_serverPasswd.text == pw) {
+        return true;
+      } else {
+        return false;
+      }
+    }
+  }
+
+  getIDPasswd({bool force = false}) async {
+    if (!force && _serverId.text != _emptyIdShow && _serverPasswd.text != "") {
+      return;
+    }
+    var count = 0;
+    const maxCount = 10;
+    while (count < maxCount) {
+      await Future.delayed(Duration(seconds: 1));
+      final id = FFI.getByName("server_id");
+      final passwd = FFI.getByName("server_password");
+      if (id.isEmpty) {
+        continue;
+      } else {
+        _serverId.text = id;
+      }
+
+      if (passwd.isEmpty) {
+        continue;
+      } else {
+        _serverPasswd.text = passwd;
+      }
+
+      debugPrint(
+          "fetch id & passwd again at $count:id:${_serverId.text},passwd:${_serverPasswd.text}");
+      count++;
+      if (_serverId.text != _emptyIdShow && _serverPasswd.text.isNotEmpty) {
+        break;
+      }
+    }
+    notifyListeners();
+  }
+
+  changeStatue(String name, bool value) {
+    debugPrint("changeStatue value $value");
+    switch (name) {
+      case "media":
+        _mediaOk = value;
+        if (value && !_isStart) {
+          startService();
+        }
+        break;
+      case "input":
+        if (_inputOk != value) {
+          Map<String, String> res = Map()
+            ..["name"] = "enable-keyboard"
+            ..["value"] = value ? '' : 'N';
+          FFI.setByName('option', jsonEncode(res));
+        }
+        _inputOk = value;
+        break;
+      default:
+        return;
+    }
+    notifyListeners();
+  }
+
+  updateClientState([String? json]) {
+    var res = json ?? FFI.getByName("clients_state");
+    try {
+      final List clientsJson = jsonDecode(res);
+      for (var clientJson in clientsJson) {
+        final client = Client.fromJson(clientJson);
+        _clients[client.id] = client;
+      }
+      notifyListeners();
+    } catch (e) {
+      debugPrint("Failed to updateClientState:$e");
+    }
+  }
+
+  void loginRequest(Map<String, dynamic> evt) {
+    try {
+      final client = Client.fromJson(jsonDecode(evt["client"]));
+      if (_clients.containsKey(client.id)) {
+        return;
+      }
+      _clients[client.id] = client;
+      scrollToBottom();
+      notifyListeners();
+      showLoginDialog(client);
+    } catch (e) {
+      debugPrint("Failed to call loginRequest,error:$e");
+    }
+  }
+
+  void showLoginDialog(Client client) {
+    DialogManager.show(
+        (setState, close) => CustomAlertDialog(
+              title: Row(
+                  mainAxisAlignment: MainAxisAlignment.spaceBetween,
+                  children: [
+                    Text(translate(client.isFileTransfer
+                        ? "File Connection"
+                        : "Screen Connection")),
+                    IconButton(
+                        onPressed: () {
+                          close();
+                        },
+                        icon: Icon(Icons.close))
+                  ]),
+              content: Column(
+                mainAxisSize: MainAxisSize.min,
+                mainAxisAlignment: MainAxisAlignment.center,
+                crossAxisAlignment: CrossAxisAlignment.start,
+                children: [
+                  Text(translate("Do you accept?")),
+                  clientInfo(client),
+                  Text(
+                    translate("android_new_connection_tip"),
+                    style: TextStyle(color: Colors.black54),
+                  ),
+                ],
+              ),
+              actions: [
+                TextButton(
+                    child: Text(translate("Dismiss")),
+                    onPressed: () {
+                      sendLoginResponse(client, false);
+                      close();
+                    }),
+                ElevatedButton(
+                    child: Text(translate("Accept")),
+                    onPressed: () {
+                      sendLoginResponse(client, true);
+                      close();
+                    }),
+              ],
+            ),
+        tag: getLoginDialogTag(client.id));
+  }
+
+  scrollToBottom() {
+    Future.delayed(Duration(milliseconds: 200), () {
+      controller.animateTo(controller.position.maxScrollExtent,
+          duration: Duration(milliseconds: 200),
+          curve: Curves.fastLinearToSlowEaseIn);
+    });
+  }
+
+  void sendLoginResponse(Client client, bool res) {
+    final Map<String, dynamic> response = Map();
+    response["id"] = client.id;
+    response["res"] = res;
+    if (res) {
+      FFI.setByName("login_res", jsonEncode(response));
+      if (!client.isFileTransfer) {
+        FFI.invokeMethod("start_capture");
+      }
+      FFI.invokeMethod("cancel_notification", client.id);
+      _clients[client.id]?.authorized = true;
+      notifyListeners();
+    } else {
+      FFI.setByName("login_res", jsonEncode(response));
+      FFI.invokeMethod("cancel_notification", client.id);
+      _clients.remove(client.id);
+    }
+  }
+
+  void onClientAuthorized(Map<String, dynamic> evt) {
+    try {
+      final client = Client.fromJson(jsonDecode(evt['client']));
+      DialogManager.dismissByTag(getLoginDialogTag(client.id));
+      _clients[client.id] = client;
+      scrollToBottom();
+      notifyListeners();
+    } catch (e) {}
+  }
+
+  void onClientRemove(Map<String, dynamic> evt) {
+    try {
+      final id = int.parse(evt['id'] as String);
+      if (_clients.containsKey(id)) {
+        _clients.remove(id);
+        DialogManager.dismissByTag(getLoginDialogTag(id));
+        FFI.invokeMethod("cancel_notification", id);
+      }
+      notifyListeners();
+    } catch (e) {
+      debugPrint("onClientRemove failed,error:$e");
+    }
+  }
+
+  closeAll() {
+    _clients.forEach((id, client) {
+      FFI.setByName("close_conn", id.toString());
+    });
+    _clients.clear();
+  }
+}
+
+class Client {
+  int id = 0; // client connections inner count id
+  bool authorized = false;
+  bool isFileTransfer = false;
+  String name = "";
+  String peerId = ""; // peer user's id,show at app
+  bool keyboard = false;
+  bool clipboard = false;
+  bool audio = false;
+  late ChatUser chatUser;
+
+  Client(this.authorized, this.isFileTransfer, this.name, this.peerId,
+      this.keyboard, this.clipboard, this.audio);
+
+  Client.fromJson(Map<String, dynamic> json) {
+    id = json['id'];
+    authorized = json['authorized'];
+    isFileTransfer = json['is_file_transfer'];
+    name = json['name'];
+    peerId = json['peer_id'];
+    keyboard = json['keyboard'];
+    clipboard = json['clipboard'];
+    audio = json['audio'];
+    chatUser = ChatUser(
+      uid: peerId,
+      name: name,
+    );
+  }
+
+  Map<String, dynamic> toJson() {
+    final Map<String, dynamic> data = new Map<String, dynamic>();
+    data['id'] = this.id;
+    data['is_start'] = this.authorized;
+    data['is_file_transfer'] = this.isFileTransfer;
+    data['name'] = this.name;
+    data['peer_id'] = this.peerId;
+    data['keyboard'] = this.keyboard;
+    data['clipboard'] = this.clipboard;
+    data['audio'] = this.audio;
+    return data;
+  }
+}
+
+String getLoginDialogTag(int id) {
+  return loginDialogTag + id.toString();
+}
+
+showInputWarnAlert() {
+  DialogManager.show((setState, close) => CustomAlertDialog(
+        title: Text(translate("How to get Android input permission?")),
+        content: Column(
+          mainAxisSize: MainAxisSize.min,
+          children: [
+            Text(translate("android_input_permission_tip1")),
+            SizedBox(height: 10),
+            Text(translate("android_input_permission_tip2")),
+          ],
+        ),
+        actions: [
+          TextButton(child: Text(translate("Cancel")), onPressed: close),
+          ElevatedButton(
+              child: Text(translate("Open System Setting")),
+              onPressed: () {
+                FFI.serverModel.initInput();
+                close();
+              }),
+        ],
+      ));
+}

flutter/lib/models/web_model.dart

@@ -0,0 +1,60 @@
+import 'dart:typed_data';
+import 'dart:js' as js;
+
+import '../common.dart';
+import 'dart:html';
+import 'dart:async';
+
+final List<StreamSubscription<MouseEvent>> mouseListeners = [];
+final List<StreamSubscription<KeyboardEvent>> keyListeners = [];
+int lastMouseDownButtons = 0;
+bool mouseIn = false;
+
+class PlatformFFI {
+  static void clearRgbaFrame() {}
+
+  static Uint8List? getRgba() {
+    return js.context.callMethod('getRgba');
+  }
+
+  static String getByName(String name, [String arg = '']) {
+    return js.context.callMethod('getByName', [name, arg]);
+  }
+
+  static void setByName(String name, [String value = '']) {
+    js.context.callMethod('setByName', [name, value]);
+  }
+
+  static Future<Null> init() async {
+    isWeb = true;
+    isDesktop = !js.context.callMethod('isMobile');
+    js.context.callMethod('init');
+    version = getByName('version');
+  }
+
+  static void startDesktopWebListener() {
+    mouseIn = true;
+    mouseListeners.add(
+        window.document.onContextMenu.listen((evt) => evt.preventDefault()));
+  }
+
+  static void stopDesktopWebListener() {
+    mouseIn = true;
+    mouseListeners.forEach((l) {
+      l.cancel();
+    });
+    mouseListeners.clear();
+    keyListeners.forEach((l) {
+      l.cancel();
+    });
+    keyListeners.clear();
+  }
+
+  static void setMethodCallHandler(FMethod callback) {}
+
+  static Future<bool> invokeMethod(String method, [dynamic arguments]) async {
+    return true;
+  }
+}
+
+final localeName = window.navigator.language;