DEV Community: RustDesk

How to make Flutter 3.24 run on Windows 7?

RustDesk — Mon, 02 Dec 2024 08:58:21 +0000

We recently introduced Flutter 3.24.5 in RustDesk, which resulted in it not running on Windows 7. To solve this problem, we attempted to modify the Flutter Engine.

Solution for Running Flutter 3.24.5 on Windows 7

Given that the Flutter and Dart officials have announced that Dart 3.3 and Flutter 3.19 will be the last versions to support Windows 7 and 8, we are facing the issue of Flutter 3.24.5 not running on Windows 7. To solve this problem, we need to revert some changes in Dart to restore support for Windows 7. Here are the changes that need to be reverted:

1. Fix the issue with `Platform.localHostname` in Chinese environments

Originally, Dart used the gethostname API, which caused Platform.localHostname to fail in Chinese environments. To solve this problem, Dart switched to the GetHostNameW API, which is only available in Windows 8 and later versions. To make Flutter run on Windows 7, we need to revert this change. Note that reverting this change will affect the functionality of Platform.localHostname in Chinese environments.

2. Remove the handling of unwinding records API for Windows 7

Dart had previously made compatibility modifications for the lack of the RtlAddGrowableFunctionTable API in Windows 7, but this modification has now been removed. To maintain compatibility with Windows 7, we need to revert the commit that removed this handling.

3. Fix the issue where relative symbolic links to directories do not work on Windows

Dart had previously fixed the issue where relative symbolic links to directories did not work on Windows and modified the File::GetType method. This modification used the PathCchCombineEx API, which is only available in Windows 8 and later versions. To restore support for Windows 7, we also need to revert this modification.

Conclusion

To make Flutter 3.24.5 run on Windows 7, we need to revert some key modifications in Dart. These reverts will have side effects, such as affecting the use of Platform.localHostname in Chinese environments and issues with relative symbolic links. However, for users who rely on Windows 7, these reverts are necessary steps.

For full implementation, please check our CI.

Here is how we apply the modified engine to our project.

Use Telegram bot to receive 2FA verification code (OTP) with the help of Copilot

RustDesk — Sat, 29 Jun 2024 02:49:36 +0000

One week ago, I saw a post on RustDesk subreddit, https://www.reddit.com/r/rustdesk/comments/1dk4mzp/how_can_i_be_notified_track_when_someone_connects/. It gave me hint to send the notification to Telegram bot, because I had been using it to receive news and signals while I traded FX before. This also inspired to me to receive OTP through Telegram bot.

So I started to ask Copilot.

"Please write a function to send OTP to telegram bot"



async fn send_otp_to_telegram(bot_token: &str, chat_id: &str, otp: &str) -> Result<()> {
    let client = Client::new();
    let url = format!("https://api.telegram.org/bot{}/sendMessage", bot_token);
    let payload = json!({
        "chat_id": chat_id,
        "text": otp
    });

    let response = client.post(&url)
        .json(&payload)
        .send()
        .await?;

    if response.status().is_success() {
        Ok(())
    } else {
        Err(anyhow!("Failed to send OTP to Telegram: {}", response.status()))
    }
}

"Please write a function to send OTP to telegram bot, use reqwest"



use reqwest::Client;
use serde_json::json;
use std::error::Error;

async fn send_otp_to_telegram(otp: &str, bot_token: &str, chat_id: &str) -> Result<(), Box<dyn Error>> {
    let client = Client::new();
    let telegram_api_url = format!("https://api.telegram.org/bot{}/sendMessage", bot_token);
    let message = format!("Your OTP is: {}", otp);

    let response = client.post(&telegram_api_url)
        .json(&json!({
            "chat_id": chat_id,
            "text": message,
        }))
        .send()
        .await?;

    if response.status().is_success() {
        Ok(())
    } else {
        Err(Box::new(std::io::Error::new(std::io::ErrorKind::Other, "Failed to send OTP")))
    }
}

"How can I get telegram bot chat id with reqwest?"



async fn fetch_telegram_chat_id(bot_token: &str) -> Result<Vec<i64>, Box<dyn Error>> {
    let client = Client::new();
    let url = format!("https://api.telegram.org/bot{}/getUpdates", bot_token);

    let res = client.get(&url).send().await?;
    let body = res.text().await?;
    let json: Value = serde_json::from_str(&body)?;

    let mut chat_ids = Vec::new();
    if let Some(updates) = json["result"].as_array() {
        for update in updates {
            if let Some(chat_id) = update["message"]["chat"]["id"].as_i64() {
                chat_ids.push(chat_id);
            }
        }
    }

    Ok(chat_ids)
}

After some polish, I finished my job,

Rust https://github.com/rustdesk/rustdesk/blob/9f72d05749a88bffa577784099d97374c4276ee3/src/auth_2fa.rs#L158 ```

// https://gist.github.com/dideler/85de4d64f66c1966788c1b2304b9caf1
pub async fn send_2fa_code_to_telegram(text: &str, bot: TelegramBot) -> ResultType<()> {
let url = format!("https://api.telegram.org/bot{}/sendMessage", bot.token_str);
let params = serde_json::json!({"chat_id": bot.chat_id, "text": text});
crate::post_request(url, params.to_string(), "").await?;
Ok(())
}

pub fn get_chatid_telegram(bot_token: &str) -> ResultType> {
let url = format!("https://api.telegram.org/bot{}/getUpdates", bot_token);
// because caller is in tokio runtime, so we must call post_request_sync in new thread.
let handle = std:🧵:spawn(move || {
crate::post_request_sync(url, "".to_owned(), "")
});
let resp = handle.join().map_err(|_| anyhow!("Thread panicked"))??;
let value = serde_json::from_str::(&resp).map_err(|e| anyhow!(e))?;

// Check for an error_code in the response
if let Some(error_code) = value.get("error_code").and_then(|code| code.as_i64()) {
    // If there's an error_code, try to use the description for the error message
    let description = value["description"]
        .as_str()
        .unwrap_or("Unknown error occurred");
    return Err(anyhow!(
        "Telegram API error: {} (error_code: {})",
        description,
        error_code
    ));
}

let chat_id = &value["result"][0]["message"]["chat"]["id"];
let chat_id = if let Some(id) = chat_id.as_i64() {
    Some(id.to_string())
} else if let Some(id) = chat_id.as_str() {
    Some(id.to_owned())
} else {
    None
};

if let Some(chat_id) = chat_id.as_ref() {
    let bot = TelegramBot {
        token_str: bot_token.to_owned(),
        chat_id: chat_id.to_owned(),
        ..Default::default()
    };
    bot.save()?;
}

Ok(chat_id)

}


- Flutter UI
https://github.com/rustdesk/rustdesk/blob/a632718e80649f2be8a1a7cc1df20a6056b119b9/flutter/lib/common/widgets/dialog.dart#L1769

void changeBot({Function()? callback}) async {
if (bind.mainHasValidBotSync()) {
await bind.mainSetOption(key: "bot", value: "");
callback?.call();
return;
}
String errorText = '';
bool loading = false;
final controller = TextEditingController();
gFFI.dialogManager.show((setState, close, context) {
onVerify() async {
final token = controller.text.trim();
if (token == "") return;
loading = true;
errorText = '';
setState(() {});
final error = await bind.mainVerifyBot(token: token);
if (error == "") {
callback?.call();
close();
} else {
errorText = translate(error);
loading = false;
setState(() {});
}
}

final codeField = TextField(
  autofocus: true,
  controller: controller,
  decoration: InputDecoration(
    hintText: translate('Token'), 
  ),
);

return CustomAlertDialog(
  title: Text(translate("Telegram bot")),
  content: Column(
    crossAxisAlignment: CrossAxisAlignment.start,
    children: [
      SelectableText(translate("enable-bot-desc"),
              style: TextStyle(fontSize: 12))
          .marginOnly(bottom: 12),
      Row(children: [Expanded(child: codeField)]),
      if (errorText != '')
        Text(errorText, style: TextStyle(color: Colors.red))
            .marginOnly(top: 12),
    ],
  ),
  actions: [
    dialogButton("Cancel", onPressed: close, isOutline: true),
    loading
        ? CircularProgressIndicator()
        : dialogButton("OK", onPressed: onVerify),
  ],
  onCancel: close,
);

});
}



![The UI to set bot token and also get chat id implicitly](https://dev-to-uploads.s3.amazonaws.com/uploads/articles/21d02vaxp6an9ojhumn5.png)

Thanks to Copilot.

Build a cross-platform ChatGPT application using Rust + Tauri in two days

RustDesk — Mon, 08 May 2023 08:04:48 +0000

On the rare leisurely May Day holiday, with an itchy hand, I spent two days building a cross-platform ChatGPT application using Rust + Tauri.

I noticed that there are four open-source ChatGPT applications on GitHub with relatively high popularity, including a wrapped desktop version, a naive-ui web version, a nextjs version, and a pure HTML version without server dependencies. So I wanted to write a cross-platform version. The reason for choosing Rust as the backend instead of directly calling the client API is to expect greater scalability in the future and embed my own models.

The project is now online and included in awesome tauri. The front-end reuses web-chatgpt, while the backend is rewritten in Rust. It can currently run smoothly on desktops, the web, and mobile phones.

The official version of Tauri does not yet support mobile devices, so we use the latest version 2.0.0-alpha.8, and the documentation is available here: Guides | Tauri Apps. Tauri does not currently support using proxies in browsers, but this can be solved using native Rust.

Prerequisite

Directory structure

src: the front-end part, modified from web-chatgpt
server: the web backend, using axum. Here, in order to write stream, a lot of time was wasted mainly because there were few examples online, and also because it was the first time encountering the concept of stream and there were some misunderstandings.
shared: Rust backend logic part, currently only implements the OpenAI API call. It has to be said that Rust's ecosystem is still slightly inferior to nodejs. The functionality of the OpenAI API SDK is slightly inferior. Here, combined with the async-openai crate and nodejs chatgpt-api, the context function is implemented, and our own model will be added here in the future.
src-tauri : Tauri implementation, which is relatively simple because the main logic is in shared, which is shared with server.

Run desktop

pnpm tauri dev

Run web



  
  
  run backend


cargo run --bin server

  
  
  start frontend dev


pnpm dev

Run iOS

pnpm tauri ios dev

Flutter Desktop Development Practice

RustDesk — Tue, 20 Sep 2022 04:11:39 +0000

We mentioned earlier that RustDesk's original Html / Js (Sciter)-based front-end was migrated to Flutter. We have to admit the migration progress was much slower than expected. It seems wrong to choose Flutter, but there were no other better choices indeed.

Tauri seems to be the best choice, but the performance does not meet our requirement. Sciter uses Html / Js, but it has its own rendering engine with native Video interface. Tauri uses its Wry to unify the API interfaces of browsers on various platforms, but it cannot break the limitations of browser boundary, and the customizability and compatibility are also worse than Electron. I still like Tauri very much, because it is small and pretty, convenient for development and debugging, and efficient enough to meet the production needs of most scenes. I look forward to its future, and I hope their own rendering implementation can be achieved as soon as possible.

Qt seems a more practical choice, but after seeing its unsafe Rust binding of Qt, we gave up.

The front-end development of Flutter is similar to the native UI development, the complexity is significantly higher than classic Web technology. This can be seen from the number of lines of source code after our migration. The code is much more verbose and bloated, although it leads to better engineering practices and maintainability (This doesn't mean too much for a small team like us in my opinion).

Flutter desktop is still buggy, and much more worse than expected. Here are some featured problems we have encountered, and our solutions.

1，Multiple Windows Support

https://github.com/Kingtous/rustdesk_desktop_multi_window

This Pub supports Flutter <=3.0.5 on Windows. There is a related issue on Flutter repo, but the priority is low. As a work around, We stick to the old version of Flutter. We haven't seen any obvious improvements for Windows in the new Flutter version, using new Flutter version is not that important. It seems that the Flutter team focuses on Android / iOS, and many basic problems of Flutter desktop (multi-level menus, local cursor, scrollbar) have been ignored.

2，Better Window Operation

https://github.com/leanflutter/window_manager/pull/205

https://github.com/leanflutter/window_manager/pull/203

3，Native Cursor

https://github.com/flutter/engine/pull/36143

https://github.com/Kingtous/rustdesk_flutter_custom_cursor

4，Multi-level Menus

We try to avoid using multi-level menus. There is a native menu implementation, but it is not easy to customize.

5，Scroolbar

The wheel speed is slow, and the wheel stops to work when the cursor is moved on the scrollbar.

https://github.com/Kingtous/flutter_improved_scrolling

6，Bridge

https://github.com/fzyzcjy/flutter_rust_bridge/pull/663

7，Wayland

https://github.com/leanflutter/screen_retriever/pull/3

8，CJK Font

https://github.com/flutter/flutter/issues/103811#issuecomment-1199227834
https://github.com/rustdesk/rustdesk/pull/1581/files

RustDesk is migrated from Sciter to Flutter

RustDesk — Fri, 26 Aug 2022 11:33:00 +0000

Yesterday, the RustDesk project officially merged the flutter_desktop branch into the master branch in preparation for the final release.

The first desktop version of RustDesk used Sciter. The primary reason for choosing Sciter was its light weight, but Sciter is not open source. The author of Sciter launched an open source Kickstarter last year, but it failed.

We decided to migrate in this May, and hosted an discussion about chosing Flutter or Tauri, https://github.com/rustdesk/rustdesk/discussions/533.

Now RustDesk fully embraces Flutter, Flutter is adopted on all platforms (iOS / Android / Windows / Linux / Mac / Web). But since Flutter does not support 32bit Windows, Sciter still has to continue to serve for 32bit Windows.

Summary of Flutter vs Tauri

RustDesk — Mon, 30 May 2022 14:24:37 +0000

Last week we posted a discussion on the selection of Flutter and Tauri on GitHub, and we are glad that both the author of Tauri and the author flutter_rust_bridge have participated. In the end, the voting score of Tauri is higher. Although we favored Tauri originally, but we still choose Flutter for the time being due to the poor IPC performance of Tauri. I will summarize the discussion, hope it can help you choose between Flutter and Tauri in your future job.

Pros of Tauri:

Tauri ecosystem is richer, with massive resources of html/css/js
Tauri community is awesome
Tauri is based on the browser kernel which is more mature than Flutter in the desktop environment
Tauri is simpler, easier to build, easier to learn, and easier to get more contributors
Simpler integration with Rust, even you can call Rust async functions (I haven't tried it)
Smaller application after compilation

Cons of Tauri:

IPC performance is not good (The author of Tauri mentioned the reasons for discarding shared memory support mentioned in the discussion, as well as the problems of IPC, and incomming optimizations, but I can not find it any more)
Due to the use of the browser kernel, bigger memory footprint. There are also browser compatibility issues on different platforms.
Win7 without WebView installed is a trouble. You can make a big package yourself, or you can install it online, which are not very friendly.
Not support mobile. The author mentioned that the mobile version will be launched this year. It is said to be based on EGUI, but there is still a long way to reach stable version.

Pros of Flutter:

The ecosystem is also rich
Desktop + mobile
Good FFI performance
Supported by Google

Cons of Flutter:

32-bit Windows are not supported, Google has explicitly stated that they won't support 32-bit Windows.
Building, debugging, and integration with Rust is a bit more complicated
The final package is slightly larger, a hello world under Windows is 20MB, after zip compression it is 8.36MB, similar size under Linux
No static link library

How does RustDesk work? OpenSource TeamViewer Alternative.

RustDesk — Thu, 26 May 2022 10:03:26 +0000

https://github.com/rustdesk/rustdesk/wiki/How-does-RustDesk-work%3F

Tauri or Flutter v3 for a Rust desktop app?

RustDesk — Tue, 17 May 2022 05:25:19 +0000

Though our open source mobile side is Flutter, but I can not decide either. Our desktop side uses Sciter, similar to html/js. We can use most of old html/js with Tauri. We can also reuse some mobile Flutter code, but our desktop design is super different from mobile. Flutter is not css based, few code can be shared between mobile and desktop per my understanding.

Drawback of flutter:

Debugging rust with Flutter is not conveninent.
Both of them are open source, but Tauri has much smaller code base, we can do code change on Tauri, but it is hard for us on Flutter.

I created a pool on my github discussions.

https://github.com/rustdesk/rustdesk/discussions/533

Debugging a Crash in Unsafe Rust with Windbg

RustDesk — Thu, 03 Jun 2021 03:51:42 +0000

Lately, I had a crash in my Rust project on Windows. It is hard to get any clue from the console messages, because it is a segmentfault crash related to unsafe rust code.

error: process didn't exit successfully: `target\debug\rustdesk.exe` (exit code: 0xc0000374, STATUS_HEAP_CORRUPTION)

I am familiar with Linux debugging tools like GDB and Valgrind. So I attempted to use Windbg.

Install Windbg

Download and install Windbg via below link first.
https://docs.microsoft.com/en-us/windows-hardware/drivers/debugger/debugger-download-tools

Debug with Windbg

Start your program cargo run. It is ok to run release version, but debug version has a bit of nicer symbol information.

Open Windbg, and attach your process as below.

Then the process is attached and paused. Please click on "Go" button on Windbg toolbar to continue the process.

Now you can run your program until it crashes, and get a crash stack in Windbg as below.

This is not the exact location that caused the crash，but it does help me solve the problem.