refactor(bindings/dart)!: support macos and use exists api (#5884)

Signed-off-by: yihong0618 <zouzou0208@gmail.com>

Author: yihong0618

.github/workflows/ci_bindings_dart.yml

@@ -77,6 +77,10 @@ jobs:
         working-directory: bindings/dart
         run: flutter pub get
 
+      - name: Check Clippy
+        working-directory: bindings/dart/rust
+        run: cargo clippy -- -D warnings
+
       - name: build lib
         working-directory: bindings/dart/rust
         run: |

bindings/dart/lib/opendal.dart

@@ -36,11 +36,49 @@ class Storage {
       var path = "rust/target/release/";  // default path
       final name = Platform.operatingSystem;
       final arch = SysInfo.kernelArchitecture;
-      // if (name == "linux" && arch == "x86_64"){
-      //   path = "rust/target/x86_64-unknown-linux-gnu/release/";
-      // }
-      // todo: more system and arch
-
+      // Set appropriate binary path based on OS and architecture
+      final nameLower = name.toLowerCase();
+      final archLower = arch.toString().toLowerCase();
+      
+      if (nameLower == "linux") {
+        if (archLower == "x86_64") {
+          path = "rust/target/x86_64-unknown-linux-gnu/release/";
+        } else if (archLower == "aarch64" || archLower == "arm64") {
+          path = "rust/target/aarch64-unknown-linux-gnu/release/";
+        } else if (archLower == "arm") {
+          path = "rust/target/armv7-unknown-linux-gnueabihf/release/";
+        }
+      } else if (nameLower == "windows") {
+        if (archLower == "x86_64" || archLower == "amd64") {
+          path = "rust/target/x86_64-pc-windows-msvc/release/";
+        } else if (archLower == "x86" || archLower == "i386") {
+          path = "rust/target/i686-pc-windows-msvc/release/";
+        } else if (archLower == "aarch64" || archLower == "arm64") {
+          path = "rust/target/aarch64-pc-windows-msvc/release/";
+        }
+      } else if (nameLower == "macos") {
+        if (archLower == "x86_64") {
+          path = "rust/target/x86_64-apple-darwin/release/";
+        } else if (archLower == "aarch64" || archLower == "arm64") {
+          path = "rust/target/aarch64-apple-darwin/release/";
+        }
+      } else if (nameLower == "android") {
+        if (archLower == "aarch64" || archLower == "arm64") {
+          path = "rust/target/aarch64-linux-android/release/";
+        } else if (archLower == "x86_64") {
+          path = "rust/target/x86_64-linux-android/release/";
+        } else if (archLower == "x86" || archLower == "i386") {
+          path = "rust/target/i686-linux-android/release/";
+        } else if (archLower == "arm") {
+          path = "rust/target/armv7-linux-androideabi/release/";
+        }
+      } else if (nameLower == "ios") {
+        if (archLower == "aarch64" || archLower == "arm64") {
+          path = "rust/target/aarch64-apple-ios/release/";
+        } else if (archLower == "x86_64") {
+          path = "rust/target/x86_64-apple-ios/release/";
+        }
+      }
       var config = ExternalLibraryLoaderConfig( // https://github.com/fzyzcjy/flutter_rust_bridge/issues/2460
         stem: 'opendal_dart',
         ioDirectory: path,
@@ -70,11 +108,11 @@ class File {
       : _operator = operator;
 
   Future<bool> exists() {
-    return _operator.isExist(path: path);
+    return _operator.exists(path: path);
   }
 
   bool existsSync() {
-    return _operator.isExistSync(path: path);
+    return _operator.existsSync(path: path);
   }
 
   Future<Metadata> stat() {
@@ -118,11 +156,11 @@ class Directory {
   }
 
   Future<bool> exists() {
-    return _operator.isExist(path: path);
+    return _operator.exists(path: path);
   }
 
   bool existsSync() {
-    return _operator.isExistSync(path: path);
+    return _operator.existsSync(path: path);
   }
 
   Future<void> rename(String newPath) {

bindings/dart/lib/src/rust/api/opendal_api.dart

@@ -47,9 +47,9 @@ abstract class Operator implements RustOpaqueInterface {
 
   void deleteSync({required String path});
 
-  Future<bool> isExist({required String path});
+  Future<bool> exists({required String path});
 
-  bool isExistSync({required String path});
+  bool existsSync({required String path});
 
   factory Operator(
           {required String schemeStr, required Map<String, String> map}) =>

bindings/dart/lib/src/rust/frb_generated.dart

@@ -66,7 +66,7 @@ class RustLib extends BaseEntrypoint<RustLibApi, RustLibApiImpl, RustLibWire> {
   String get codegenVersion => '2.8.0';
 
   @override
-  int get rustContentHash => 229275691;
+  int get rustContentHash => 775125233;
 
   static const kDefaultExternalLibraryLoaderConfig =
       ExternalLibraryLoaderConfig(
@@ -108,10 +108,10 @@ abstract class RustLibApi extends BaseApi {
   void crateApiOpendalApiOperatorDeleteSync(
       {required Operator that, required String path});
 
-  Future<bool> crateApiOpendalApiOperatorIsExist(
+  Future<bool> crateApiOpendalApiOperatorExists(
       {required Operator that, required String path});
 
-  bool crateApiOpendalApiOperatorIsExistSync(
+  bool crateApiOpendalApiOperatorExistsSync(
       {required Operator that, required String path});
 
   Operator crateApiOpendalApiOperatorNew(
@@ -492,7 +492,7 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi {
       );
 
   @override
-  Future<bool> crateApiOpendalApiOperatorIsExist(
+  Future<bool> crateApiOpendalApiOperatorExists(
       {required Operator that, required String path}) {
     return handler.executeNormal(NormalTask(
       callFfi: (port_) {
@@ -507,20 +507,20 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi {
         decodeSuccessData: sse_decode_bool,
         decodeErrorData: null,
       ),
-      constMeta: kCrateApiOpendalApiOperatorIsExistConstMeta,
+      constMeta: kCrateApiOpendalApiOperatorExistsConstMeta,
       argValues: [that, path],
       apiImpl: this,
     ));
   }
 
-  TaskConstMeta get kCrateApiOpendalApiOperatorIsExistConstMeta =>
+  TaskConstMeta get kCrateApiOpendalApiOperatorExistsConstMeta =>
       const TaskConstMeta(
-        debugName: "Operator_is_exist",
+        debugName: "Operator_exists",
         argNames: ["that", "path"],
       );
 
   @override
-  bool crateApiOpendalApiOperatorIsExistSync(
+  bool crateApiOpendalApiOperatorExistsSync(
       {required Operator that, required String path}) {
     return handler.executeSync(SyncTask(
       callFfi: () {
@@ -534,15 +534,15 @@ class RustLibApiImpl extends RustLibApiImplPlatform implements RustLibApi {
         decodeSuccessData: sse_decode_bool,
         decodeErrorData: null,
       ),
-      constMeta: kCrateApiOpendalApiOperatorIsExistSyncConstMeta,
+      constMeta: kCrateApiOpendalApiOperatorExistsSyncConstMeta,
       argValues: [that, path],
       apiImpl: this,
     ));
   }
 
-  TaskConstMeta get kCrateApiOpendalApiOperatorIsExistSyncConstMeta =>
+  TaskConstMeta get kCrateApiOpendalApiOperatorExistsSyncConstMeta =>
       const TaskConstMeta(
-        debugName: "Operator_is_exist_sync",
+        debugName: "Operator_exists_sync",
         argNames: ["that", "path"],
       );
 
@@ -1257,11 +1257,11 @@ class OperatorImpl extends RustOpaque implements Operator {
   void deleteSync({required String path}) => RustLib.instance.api
       .crateApiOpendalApiOperatorDeleteSync(that: this, path: path);
 
-  Future<bool> isExist({required String path}) => RustLib.instance.api
-      .crateApiOpendalApiOperatorIsExist(that: this, path: path);
+  Future<bool> exists({required String path}) => RustLib.instance.api
+      .crateApiOpendalApiOperatorExists(that: this, path: path);
 
-  bool isExistSync({required String path}) => RustLib.instance.api
-      .crateApiOpendalApiOperatorIsExistSync(that: this, path: path);
+  bool existsSync({required String path}) => RustLib.instance.api
+      .crateApiOpendalApiOperatorExistsSync(that: this, path: path);
 
   Future<void> rename({required String from, required String to}) =>
       RustLib.instance.api

bindings/dart/rust/src/api/opendal_api.rs

@@ -42,39 +42,36 @@ impl Operator {
 
         Metadata(meta)
     }
-    pub async fn check(&self) -> () {
+    pub async fn check(&self) {
         self.0.check().await.unwrap()
     }
-    pub async fn is_exist(&self, path: String) -> bool {
-        self.0.is_exist(&path).await.unwrap()
+    pub async fn exists(&self, path: String) -> bool {
+        self.0.exists(&path).await.unwrap()
     }
-    pub async fn delete(&self, path: String) -> () {
+    pub async fn delete(&self, path: String) {
         self.0.delete(&path).await.unwrap()
     }
     #[frb(sync)]
     pub fn delete_sync(&self, path: String) -> () {
         self.0.blocking().delete(&path).unwrap()
     }
     #[frb(sync)]
-    pub fn is_exist_sync(&self, path: String) -> bool {
-        self.0.blocking().is_exist(&path).unwrap()
+    pub fn exists_sync(&self, path: String) -> bool {
+        self.0.blocking().exists(&path).unwrap()
     }
-    pub async fn create_dir(&self, path: String) -> () {
+    pub async fn create_dir(&self, path: String) {
         self.0.create_dir(&path).await.unwrap()
     }
     #[frb(sync)]
     pub fn create_dir_sync(&self, path: String) -> () {
         self.0.blocking().create_dir(&path).unwrap()
     }
-    pub async fn rename(&self, from: String, to: String) -> () {
+    pub async fn rename(&self, from: String, to: String) {
         self.0.rename(&from, &to).await.unwrap()
     }
     #[frb(sync)]
     pub fn rename_sync(&self, from: String, to: String) -> () {
-        self.0
-            .blocking()
-            .rename(&from, &to)
-            .unwrap()
+        self.0.blocking().rename(&from, &to).unwrap()
     }
 }
 
@@ -132,4 +129,3 @@ impl Metadata {
         self.0.last_modified().map(|ta| ta.to_rfc3339())
     }
 }
-

bindings/dart/rust/src/frb_generated.rs

@@ -38,7 +38,7 @@ flutter_rust_bridge::frb_generated_boilerplate!(
     default_rust_auto_opaque = RustAutoOpaqueMoi,
 );
 pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_VERSION: &str = "2.8.0";
-pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_CONTENT_HASH: i32 = 229275691;
+pub(crate) const FLUTTER_RUST_BRIDGE_CODEGEN_CONTENT_HASH: i32 = 775125233;
 
 // Section: executor
 
@@ -705,15 +705,15 @@ fn wire__crate__api__opendal_api__Operator_delete_sync_impl(
         },
     )
 }
-fn wire__crate__api__opendal_api__Operator_is_exist_impl(
+fn wire__crate__api__opendal_api__Operator_exists_impl(
     port_: flutter_rust_bridge::for_generated::MessagePort,
     ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
     rust_vec_len_: i32,
     data_len_: i32,
 ) {
     FLUTTER_RUST_BRIDGE_HANDLER.wrap_async::<flutter_rust_bridge::for_generated::SseCodec, _, _, _>(
         flutter_rust_bridge::for_generated::TaskInfo {
-            debug_name: "Operator_is_exist",
+            debug_name: "Operator_exists",
             port: Some(port_),
             mode: flutter_rust_bridge::for_generated::FfiCallMode::Normal,
         },
@@ -753,7 +753,7 @@ fn wire__crate__api__opendal_api__Operator_is_exist_impl(
                         }
                         let api_that_guard = api_that_guard.unwrap();
                         let output_ok = Result::<_, ()>::Ok(
-                            crate::api::opendal_api::Operator::is_exist(&*api_that_guard, api_path)
+                            crate::api::opendal_api::Operator::exists(&*api_that_guard, api_path)
                                 .await,
                         )?;
                         Ok(output_ok)
@@ -764,14 +764,14 @@ fn wire__crate__api__opendal_api__Operator_is_exist_impl(
         },
     )
 }
-fn wire__crate__api__opendal_api__Operator_is_exist_sync_impl(
+fn wire__crate__api__opendal_api__Operator_exists_sync_impl(
     ptr_: flutter_rust_bridge::for_generated::PlatformGeneralizedUint8ListPtr,
     rust_vec_len_: i32,
     data_len_: i32,
 ) -> flutter_rust_bridge::for_generated::WireSyncRust2DartSse {
     FLUTTER_RUST_BRIDGE_HANDLER.wrap_sync::<flutter_rust_bridge::for_generated::SseCodec, _>(
         flutter_rust_bridge::for_generated::TaskInfo {
-            debug_name: "Operator_is_exist_sync",
+            debug_name: "Operator_exists_sync",
             port: None,
             mode: flutter_rust_bridge::for_generated::FfiCallMode::Sync,
         },
@@ -806,7 +806,7 @@ fn wire__crate__api__opendal_api__Operator_is_exist_sync_impl(
                 }
                 let api_that_guard = api_that_guard.unwrap();
                 let output_ok = Result::<_, ()>::Ok(
-                    crate::api::opendal_api::Operator::is_exist_sync(&*api_that_guard, api_path),
+                    crate::api::opendal_api::Operator::exists_sync(&*api_that_guard, api_path),
                 )?;
                 Ok(output_ok)
             })())
@@ -1258,7 +1258,7 @@ fn pde_ffi_dispatcher_primary_impl(
             wire__crate__api__opendal_api__Operator_delete_impl(port, ptr, rust_vec_len, data_len)
         }
         14 => {
-            wire__crate__api__opendal_api__Operator_is_exist_impl(port, ptr, rust_vec_len, data_len)
+            wire__crate__api__opendal_api__Operator_exists_impl(port, ptr, rust_vec_len, data_len)
         }
         17 => {
             wire__crate__api__opendal_api__Operator_rename_impl(port, ptr, rust_vec_len, data_len)
@@ -1298,9 +1298,7 @@ fn pde_ffi_dispatcher_sync_impl(
             data_len,
         ),
         13 => wire__crate__api__opendal_api__Operator_delete_sync_impl(ptr, rust_vec_len, data_len),
-        15 => {
-            wire__crate__api__opendal_api__Operator_is_exist_sync_impl(ptr, rust_vec_len, data_len)
-        }
+        15 => wire__crate__api__opendal_api__Operator_exists_sync_impl(ptr, rust_vec_len, data_len),
         16 => wire__crate__api__opendal_api__Operator_new_impl(ptr, rust_vec_len, data_len),
         18 => wire__crate__api__opendal_api__Operator_rename_sync_impl(ptr, rust_vec_len, data_len),
         20 => wire__crate__api__opendal_api__Operator_stat_sync_impl(ptr, rust_vec_len, data_len),