@onekeyfe/react-native-cloud-fs 3.0.14 → 3.0.16

package/android/build.gradle

@@ -74,4 +74,14 @@ def kotlin_version = getExtOrDefault("kotlinVersion")
 dependencies {
   implementation "com.facebook.react:react-android"
   implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+
+  // Google Drive / Sign-In
+  implementation "com.google.android.gms:play-services-auth:21.3.0"
+  implementation "com.google.http-client:google-http-client-gson:1.44.1"
+  implementation("com.google.api-client:google-api-client-android:2.7.0") {
+    exclude group: "org.apache.httpcomponents"
+  }
+  implementation("com.google.apis:google-api-services-drive:v3-rev20241027-2.0.0") {
+    exclude group: "org.apache.httpcomponents"
+  }
 }

package/android/src/main/java/com/rncloudfs/DriveServiceHelper.kt

@@ -0,0 +1,108 @@
+package com.rncloudfs
+
+import android.util.Log
+import com.google.android.gms.tasks.Task
+import com.google.android.gms.tasks.Tasks
+import com.google.api.client.http.FileContent
+import com.google.api.services.drive.Drive
+import com.google.api.services.drive.model.FileList
+import java.io.BufferedReader
+import java.io.InputStreamReader
+import java.util.concurrent.Executors
+
+class DriveServiceHelper(private val driveService: Drive) {
+
+    private val executor = Executors.newSingleThreadExecutor()
+
+    fun saveFile(
+        sourcePath: String,
+        destinationPath: String,
+        mimeType: String?,
+        useDocumentsFolder: Boolean
+    ): Task<String> {
+        var existingFileId: String? = null
+        val fileList = Tasks.await(queryFiles(useDocumentsFolder))
+        for (file in fileList.files) {
+            if (file.name.equals(destinationPath, ignoreCase = true)) {
+                existingFileId = file.id
+            }
+        }
+        return createFile(sourcePath, destinationPath, mimeType, useDocumentsFolder, existingFileId)
+    }
+
+    fun createFile(
+        sourcePath: String,
+        destinationPath: String,
+        mimeType: String?,
+        useDocumentsFolder: Boolean,
+        fileId: String?
+    ): Task<String> {
+        return Tasks.call(executor) {
+            try {
+                val sourceFile = java.io.File(sourcePath)
+                val mediaContent = FileContent(mimeType, sourceFile)
+                val parentFolder = listOf(if (useDocumentsFolder) "root" else "appDataFolder")
+                val metadata = com.google.api.services.drive.model.File()
+                    .setMimeType(mimeType)
+                    .setName(destinationPath)
+                if (fileId == null) {
+                    metadata.parents = parentFolder
+                }
+
+                val googleFile = if (fileId != null) {
+                    driveService.files().update(fileId, metadata, mediaContent).execute()
+                } else {
+                    driveService.files().create(metadata, mediaContent).execute()
+                }
+
+                googleFile?.id ?: throw java.io.IOException("Null result when requesting file creation.")
+            } catch (e: Exception) {
+                Log.e(TAG, e.toString())
+                throw e
+            }
+        }
+    }
+
+    fun checkIfFileExists(fileId: String): Task<Boolean> {
+        return Tasks.call(executor) {
+            val metadata = driveService.files().get(fileId).execute()
+            metadata != null
+        }
+    }
+
+    fun deleteFile(fileId: String): Task<Boolean> {
+        return Tasks.call(executor) {
+            driveService.files().delete(fileId).execute()
+            true
+        }
+    }
+
+    fun readFile(fileId: String): Task<String> {
+        return Tasks.call(executor) {
+            driveService.files().get(fileId).executeMediaAsInputStream().use { inputStream ->
+                BufferedReader(InputStreamReader(inputStream)).use { reader ->
+                    val sb = StringBuilder()
+                    var line: String?
+                    while (reader.readLine().also { line = it } != null) {
+                        sb.append(line)
+                    }
+                    sb.toString()
+                }
+            }
+        }
+    }
+
+    fun queryFiles(useDocumentsFolder: Boolean): Task<FileList> {
+        return Tasks.call(executor) {
+            driveService.files().list()
+                .setSpaces(if (useDocumentsFolder) "drive" else "appDataFolder")
+                .setFields("nextPageToken, files(id, name, modifiedTime)")
+                .setPageSize(100)
+                .execute()
+        }
+    }
+
+    companion object {
+        private const val TAG = "DriveServiceHelper"
+    }
+}

package/android/src/main/java/com/rncloudfs/RNCloudFsModule.kt

@@ -1,50 +1,425 @@
 package com.rncloudfs
 
+import android.app.Activity
+import android.content.Intent
+import android.net.Uri
+import android.util.Log
+import android.webkit.MimeTypeMap
+import com.facebook.react.bridge.ActivityEventListener
+import com.facebook.react.bridge.LifecycleEventListener
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableNativeArray
+import com.facebook.react.bridge.WritableNativeMap
 import com.facebook.react.module.annotations.ReactModule
+import com.google.android.gms.auth.api.signin.GoogleSignIn
+import com.google.android.gms.auth.api.signin.GoogleSignInClient
+import com.google.android.gms.auth.api.signin.GoogleSignInOptions
+import com.google.android.gms.common.api.ApiException
+import com.google.android.gms.common.api.Scope
+import com.google.api.client.extensions.android.http.AndroidHttp
+import com.google.api.client.googleapis.extensions.android.gms.auth.GoogleAccountCredential
+import com.google.api.client.googleapis.extensions.android.gms.auth.UserRecoverableAuthIOException
+import com.google.api.client.json.gson.GsonFactory
+import com.google.api.services.drive.Drive
+import com.google.api.services.drive.DriveScopes
+import java.util.Collections
 
 @ReactModule(name = RNCloudFsModule.NAME)
-class RNCloudFsModule(reactContext: ReactApplicationContext) :
-    NativeRNCloudFsSpec(reactContext) {
+class RNCloudFsModule(private val reactContext: ReactApplicationContext) :
+    NativeRNCloudFsSpec(reactContext), LifecycleEventListener, ActivityEventListener {
+
+    private var mDriveServiceHelper: DriveServiceHelper? = null
+    private var signInPromise: Promise? = null
+    private var mPendingPromise: Promise? = null
+    private var mPendingOptions: ReadableMap? = null
+    private var mPendingOperation: String? = null
+
+    init {
+        reactContext.addLifecycleEventListener(this)
+        reactContext.addActivityEventListener(this)
+    }
 
     companion object {
         const val NAME = "RNCloudFs"
-        private const val NOT_AVAILABLE_ERROR = "iCloud is not available on Android"
+        private const val TAG = "RNCloudFs"
+        private const val REQUEST_CODE_SIGN_IN = 1
+        private const val REQUEST_AUTHORIZATION = 11
+        private const val COPY_TO_CLOUD = "CopyToCloud"
+        private const val LIST_FILES = "ListFiles"
     }
 
     override fun getName(): String = NAME
 
+    // region iOS-only stubs
+
     override fun isAvailable(promise: Promise) {
         promise.resolve(false)
     }
 
     override fun createFile(options: ReadableMap, promise: Promise) {
-        promise.reject("NOT_AVAILABLE", NOT_AVAILABLE_ERROR)
+        promise.reject("NOT_AVAILABLE", "iCloud is not available on Android")
     }
 
-    override fun fileExists(options: ReadableMap, promise: Promise) {
-        promise.reject("NOT_AVAILABLE", NOT_AVAILABLE_ERROR)
+    override fun getIcloudDocument(filename: String, promise: Promise) {
+        promise.reject("NOT_AVAILABLE", "iCloud is not available on Android")
     }
 
-    override fun listFiles(options: ReadableMap, promise: Promise) {
-        promise.reject("NOT_AVAILABLE", NOT_AVAILABLE_ERROR)
+    override fun syncCloud(promise: Promise) {
+        promise.reject("NOT_AVAILABLE", "iCloud is not available on Android")
     }
 
-    override fun getIcloudDocument(filename: String, promise: Promise) {
-        promise.reject("NOT_AVAILABLE", NOT_AVAILABLE_ERROR)
+    // endregion
+
+    // region Google Sign-In
+
+    override fun loginIfNeeded(promise: Promise) {
+        if (mDriveServiceHelper == null) {
+            val account = GoogleSignIn.getLastSignedInAccount(reactContext)
+            if (account == null) {
+                signInPromise = promise
+                requestSignIn()
+            } else {
+                val credential = GoogleAccountCredential.usingOAuth2(
+                    reactContext, Collections.singleton(DriveScopes.DRIVE_APPDATA)
+                )
+                credential.selectedAccount = account.account
+                val googleDriveService = Drive.Builder(
+                    AndroidHttp.newCompatibleTransport(),
+                    GsonFactory(),
+                    credential
+                ).build()
+                mDriveServiceHelper = DriveServiceHelper(googleDriveService)
+                promise.resolve(true)
+            }
+        } else {
+            promise.resolve(true)
+        }
+    }
+
+    override fun logout(promise: Promise) {
+        val signInOptions = GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN)
+            .requestEmail()
+            .requestScopes(Scope(DriveScopes.DRIVE_FILE))
+            .build()
+        val client: GoogleSignInClient = GoogleSignIn.getClient(reactContext, signInOptions)
+        mDriveServiceHelper = null
+        client.signOut()
+            .addOnSuccessListener { promise.resolve(true) }
+            .addOnFailureListener { exception ->
+                Log.e(TAG, "Couldn't log out.", exception)
+                promise.reject(exception)
+            }
+    }
+
+    override fun getCurrentlySignedInUserData(promise: Promise) {
+        val account = GoogleSignIn.getLastSignedInAccount(reactContext)
+        if (account == null) {
+            promise.resolve(null)
+        } else {
+            val photoUrl: Uri? = account.photoUrl
+            val resultData = WritableNativeMap()
+            resultData.putString("email", account.email)
+            resultData.putString("name", account.displayName)
+            resultData.putString("avatarUrl", photoUrl?.toString())
+            promise.resolve(resultData)
+        }
+    }
+
+    private fun requestSignIn() {
+        Log.d(TAG, "Requesting sign-in")
+        val signInOptions = GoogleSignInOptions.Builder(GoogleSignInOptions.DEFAULT_SIGN_IN)
+            .requestEmail()
+            .requestScopes(Scope(DriveScopes.DRIVE_FILE))
+            .build()
+        val client: GoogleSignInClient = GoogleSignIn.getClient(reactContext, signInOptions)
+        reactContext.startActivityForResult(client.signInIntent, REQUEST_CODE_SIGN_IN, null)
+    }
+
+    // endregion
+
+    // region Google Drive operations
+
+    override fun fileExists(options: ReadableMap, promise: Promise) {
+        val helper = mDriveServiceHelper
+        if (helper != null) {
+            val fileId = options.getString("fileId") ?: ""
+            Log.d(TAG, "Checking file $fileId")
+            helper.checkIfFileExists(fileId)
+                .addOnSuccessListener { exists -> promise.resolve(exists) }
+                .addOnFailureListener { exception ->
+                    try {
+                        val e = exception as UserRecoverableAuthIOException
+                        reactContext.startActivityForResult(e.intent, REQUEST_AUTHORIZATION, null)
+                    } catch (e: Exception) {
+                        Log.e(TAG, "Couldn't check file.", exception)
+                        promise.reject(exception)
+                    }
+                }
+        } else {
+            promise.reject("NOT_LOGGED_IN", "Google Drive not initialized. Call loginIfNeeded first.")
+        }
     }
 
     override fun deleteFromCloud(item: ReadableMap, promise: Promise) {
-        promise.reject("NOT_AVAILABLE", NOT_AVAILABLE_ERROR)
+        val helper = mDriveServiceHelper
+        if (helper != null) {
+            val fileId = item.getString("id") ?: ""
+            Log.d(TAG, "Deleting file $fileId")
+            helper.deleteFile(fileId)
+                .addOnSuccessListener { deleted -> promise.resolve(deleted) }
+                .addOnFailureListener { exception ->
+                    try {
+                        val e = exception as UserRecoverableAuthIOException
+                        reactContext.startActivityForResult(e.intent, REQUEST_AUTHORIZATION, null)
+                    } catch (e: Exception) {
+                        Log.e(TAG, "Couldn't delete file.", exception)
+                        promise.reject(exception)
+                    }
+                }
+        } else {
+            promise.reject("NOT_LOGGED_IN", "Google Drive not initialized. Call loginIfNeeded first.")
+        }
+    }
+
+    override fun listFiles(options: ReadableMap, promise: Promise) {
+        val helper = mDriveServiceHelper
+        if (helper != null) {
+            Log.d(TAG, "Querying for files.")
+            val useDocumentsFolder = if (options.hasKey("scope")) {
+                options.getString("scope")?.lowercase() == "visible"
+            } else {
+                true
+            }
+            try {
+                helper.queryFiles(useDocumentsFolder)
+                    .addOnSuccessListener { fileList ->
+                        val files = WritableNativeArray()
+                        for (file in fileList.files) {
+                            val fileInfo = WritableNativeMap()
+                            fileInfo.putString("name", file.name)
+                            fileInfo.putString("id", file.id)
+                            fileInfo.putString("lastModified", file.modifiedTime.toString())
+                            files.pushMap(fileInfo)
+                        }
+                        val result = WritableNativeMap()
+                        result.putArray("files", files)
+                        promise.resolve(result)
+                        clearPendingOperations()
+                    }
+                    .addOnFailureListener { exception ->
+                        clearPendingOperations()
+                        try {
+                            Log.e(TAG, "Unable to query files: ${exception.cause?.message}")
+                            val e = exception as UserRecoverableAuthIOException
+                            mPendingPromise = promise
+                            mPendingOptions = options
+                            mPendingOperation = LIST_FILES
+                            reactContext.startActivityForResult(e.intent, REQUEST_AUTHORIZATION, null)
+                        } catch (e: Exception) {
+                            promise.reject(e)
+                        }
+                    }
+            } catch (exception: Exception) {
+                try {
+                    val e = exception as java.util.concurrent.ExecutionException
+                    mPendingPromise = promise
+                    mPendingOptions = options
+                    mPendingOperation = LIST_FILES
+                    val intent = (e.cause as UserRecoverableAuthIOException).intent
+                    reactContext.startActivityForResult(intent, REQUEST_AUTHORIZATION, null)
+                } catch (e: Exception) {
+                    promise.reject(exception)
+                    Log.e(TAG, "Unable to query files: ${exception.cause?.message}")
+                }
+            }
+        } else {
+            promise.reject("NOT_LOGGED_IN", "Google Drive not initialized. Call loginIfNeeded first.")
+        }
     }
 
     override fun copyToCloud(options: ReadableMap, promise: Promise) {
-        promise.reject("NOT_AVAILABLE", NOT_AVAILABLE_ERROR)
+        val helper = mDriveServiceHelper
+        if (helper != null) {
+            if (!options.hasKey("sourcePath")) {
+                promise.reject("error", "sourcePath not specified")
+                return
+            }
+            val source = options.getMap("sourcePath")
+            var uriOrPath = source?.getString("uri")
+            if (uriOrPath == null) {
+                uriOrPath = source?.getString("path")
+            }
+            if (uriOrPath == null) {
+                promise.reject("no path", "no source uri or path was specified")
+                return
+            }
+            if (!options.hasKey("targetPath")) {
+                promise.reject("error", "targetPath not specified")
+                return
+            }
+            val destinationPath = options.getString("targetPath") ?: ""
+            val mimeType = if (options.hasKey("mimetype")) options.getString("mimetype") else null
+            val useDocumentsFolder = if (options.hasKey("scope")) {
+                options.getString("scope")?.lowercase() == "visible"
+            } else {
+                true
+            }
+            val actualMimeType = if (mimeType == null) guessMimeType(uriOrPath) else null
+
+            try {
+                helper.saveFile(uriOrPath, destinationPath, actualMimeType, useDocumentsFolder)
+                    .addOnSuccessListener { fileId ->
+                        Log.d(TAG, "Saving $fileId")
+                        promise.resolve(fileId)
+                        clearPendingOperations()
+                    }
+                    .addOnFailureListener { exception ->
+                        clearPendingOperations()
+                        try {
+                            val e = exception as UserRecoverableAuthIOException
+                            reactContext.startActivityForResult(e.intent, REQUEST_AUTHORIZATION, null)
+                        } catch (e: Exception) {
+                            Log.e(TAG, "Couldn't create file.", exception)
+                        }
+                        promise.reject(exception)
+                    }
+            } catch (exception: Exception) {
+                try {
+                    val e = exception as java.util.concurrent.ExecutionException
+                    mPendingPromise = promise
+                    mPendingOptions = options
+                    mPendingOperation = COPY_TO_CLOUD
+                    val intent = (e.cause as UserRecoverableAuthIOException).intent
+                    reactContext.startActivityForResult(intent, REQUEST_AUTHORIZATION, null)
+                } catch (e: Exception) {
+                    promise.reject(exception)
+                    Log.e(TAG, "Couldn't create file.", exception)
+                }
+            }
+        } else {
+            promise.reject("NOT_LOGGED_IN", "Google Drive not initialized. Call loginIfNeeded first.")
+        }
     }
 
-    override fun syncCloud(promise: Promise) {
-        promise.reject("NOT_AVAILABLE", NOT_AVAILABLE_ERROR)
+    override fun getGoogleDriveDocument(fileId: String, promise: Promise) {
+        val helper = mDriveServiceHelper
+        if (helper != null) {
+            Log.d(TAG, "Reading file $fileId")
+            helper.readFile(fileId)
+                .addOnSuccessListener { content -> promise.resolve(content) }
+                .addOnFailureListener { exception ->
+                    try {
+                        val e = exception as UserRecoverableAuthIOException
+                        reactContext.startActivityForResult(e.intent, REQUEST_AUTHORIZATION, null)
+                    } catch (e: Exception) {
+                        Log.e(TAG, "Couldn't read file.", exception)
+                        promise.reject(exception)
+                    }
+                }
+        } else {
+            promise.reject("NOT_LOGGED_IN", "Google Drive not initialized. Call loginIfNeeded first.")
+        }
+    }
+
+    // endregion
+
+    // region Activity result handling
+
+    private fun clearPendingOperations() {
+        mPendingOperation = null
+        mPendingPromise = null
+        mPendingOptions = null
+    }
+
+    override fun onActivityResult(activity: Activity?, requestCode: Int, resultCode: Int, data: Intent?) {
+        when (requestCode) {
+            REQUEST_CODE_SIGN_IN -> {
+                val task = GoogleSignIn.getSignedInAccountFromIntent(data)
+                handleSignInResult(task)
+            }
+            REQUEST_AUTHORIZATION -> {
+                if (resultCode == Activity.RESULT_OK && data != null) {
+                    val copiedPendingOperation = mPendingOperation
+                    if (copiedPendingOperation != null) {
+                        reactContext.runOnNativeModulesQueueThread {
+                            mPendingOperation = null
+                            when (copiedPendingOperation) {
+                                COPY_TO_CLOUD -> {
+                                    try {
+                                        mPendingOptions?.let { copyToCloud(it, mPendingPromise!!) }
+                                    } catch (e: Exception) {
+                                        mPendingPromise?.reject(e)
+                                        clearPendingOperations()
+                                    }
+                                }
+                                LIST_FILES -> {
+                                    try {
+                                        mPendingOptions?.let { listFiles(it, mPendingPromise!!) }
+                                    } catch (e: Exception) {
+                                        mPendingPromise?.reject(e)
+                                        clearPendingOperations()
+                                    }
+                                }
+                            }
+                        }
+                    }
+                } else if (resultCode == Activity.RESULT_CANCELED && mPendingPromise != null) {
+                    mPendingPromise?.reject("canceled", "User canceled")
+                } else if (mPendingPromise != null) {
+                    mPendingPromise?.reject(
+                        "unknown error",
+                        "Operation failed: $mPendingOperation result code $resultCode"
+                    )
+                }
+            }
+        }
+    }
+
+    private fun handleSignInResult(completedTask: com.google.android.gms.tasks.Task<com.google.android.gms.auth.api.signin.GoogleSignInAccount>) {
+        try {
+            val googleAccount = completedTask.getResult(ApiException::class.java)
+            Log.d(TAG, "Signed in as ${googleAccount.email}")
+
+            val credential = GoogleAccountCredential.usingOAuth2(
+                reactContext, Collections.singleton(DriveScopes.DRIVE_APPDATA)
+            )
+            credential.selectedAccount = googleAccount.account
+            val googleDriveService = Drive.Builder(
+                AndroidHttp.newCompatibleTransport(),
+                GsonFactory(),
+                credential
+            ).build()
+
+            mDriveServiceHelper = DriveServiceHelper(googleDriveService)
+
+            signInPromise?.resolve(true)
+            signInPromise = null
+        } catch (e: ApiException) {
+            Log.w(TAG, "signInResult:failed code=${e.statusCode}")
+            signInPromise?.reject("signInResult:${e.statusCode}", e.message)
+            signInPromise = null
+        }
+    }
+
+    // endregion
+
+    // region Lifecycle
+
+    override fun onHostResume() {}
+    override fun onHostPause() {}
+    override fun onHostDestroy() {}
+    override fun onNewIntent(intent: Intent?) {}
+
+    // endregion
+
+    private fun guessMimeType(url: String): String? {
+        val extension = MimeTypeMap.getFileExtensionFromUrl(url)
+        return if (extension != null) {
+            MimeTypeMap.getSingleton().getMimeTypeFromExtension(extension)
+        } else {
+            null
+        }
     }
 }

package/ios/CloudFs.mm

@@ -302,10 +302,37 @@
         for (NSMetadataItem *item in query.results) {
             [self downloadFileIfNotAvailable:item];
         }
-        return resolve(nil);
+        return resolve(@YES);
     }];
 }
 
+// MARK: - Android-only stubs
+
+- (void)loginIfNeeded:(RCTPromiseResolveBlock)resolve
+               reject:(RCTPromiseRejectBlock)reject
+{
+    resolve(@NO);
+}
+
+- (void)logout:(RCTPromiseResolveBlock)resolve
+        reject:(RCTPromiseRejectBlock)reject
+{
+    resolve(@NO);
+}
+
+- (void)getGoogleDriveDocument:(NSString *)fileId
+                       resolve:(RCTPromiseResolveBlock)resolve
+                        reject:(RCTPromiseRejectBlock)reject
+{
+    reject(@"NOT_AVAILABLE", @"Google Drive is not available on iOS", nil);
+}
+
+- (void)getCurrentlySignedInUserData:(RCTPromiseResolveBlock)resolve
+                              reject:(RCTPromiseRejectBlock)reject
+{
+    resolve([NSNull null]);
+}
+
 // MARK: - Private helpers
 
 - (void)moveToICloudDirectory:(bool)documentsFolder

package/lib/module/index.js

@@ -2,4 +2,5 @@
 
 import NativeCloudFs from "./NativeCloudFs.js";
 export const CloudFs = NativeCloudFs;
+export default NativeCloudFs;
 //# sourceMappingURL=index.js.map

package/lib/typescript/src/NativeCloudFs.d.ts

@@ -1,13 +1,50 @@
 import type { TurboModule } from 'react-native';
 export interface Spec extends TurboModule {
     isAvailable(): Promise<boolean>;
-    createFile(options: Object): Promise<Object>;
-    fileExists(options: Object): Promise<boolean>;
-    listFiles(options: Object): Promise<Object>;
+    syncCloud(): Promise<boolean>;
+    listFiles(options: {
+        scope: string;
+        targetPath?: string;
+    }): Promise<{
+        files: Array<{
+            id: string;
+            name: string;
+            lastModified: string;
+            isFile?: boolean;
+        }>;
+    }>;
+    deleteFromCloud(item: {
+        id: string;
+        path?: string;
+    }): Promise<boolean>;
+    fileExists(options: {
+        fileId?: string;
+        targetPath?: string;
+        scope?: string;
+    }): Promise<boolean>;
+    copyToCloud(options: {
+        mimetype?: string | null;
+        scope: string;
+        sourcePath: {
+            path?: string;
+            uri?: string;
+        };
+        targetPath: string;
+    }): Promise<string>;
+    createFile(options: {
+        targetPath: string;
+        content: string;
+        scope?: string;
+    }): Promise<string>;
     getIcloudDocument(filename: string): Promise<string>;
-    deleteFromCloud(item: Object): Promise<Object>;
-    copyToCloud(options: Object): Promise<Object>;
-    syncCloud(): Promise<void>;
+    loginIfNeeded(): Promise<boolean>;
+    logout(): Promise<boolean>;
+    getGoogleDriveDocument(fileId: string): Promise<string>;
+    getCurrentlySignedInUserData(): Promise<{
+        email: string;
+        name: string;
+        avatarUrl: string | null;
+    } | null>;
 }
 declare const _default: Spec;
 export default _default;

package/lib/typescript/src/index.d.ts

@@ -1,3 +1,5 @@
+import NativeCloudFs from './NativeCloudFs';
 export declare const CloudFs: import("./NativeCloudFs").Spec;
+export default NativeCloudFs;
 export type { Spec as CloudFsSpec } from './NativeCloudFs';
 //# sourceMappingURL=index.d.ts.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onekeyfe/react-native-cloud-fs",
-  "version": "3.0.14",
+  "version": "3.0.16",
   "description": "react-native-cloud-fs TurboModule for OneKey",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",

package/src/NativeCloudFs.ts

@@ -2,14 +2,50 @@ import { TurboModuleRegistry } from 'react-native';
 import type { TurboModule } from 'react-native';
 
 export interface Spec extends TurboModule {
+  // Shared
   isAvailable(): Promise<boolean>;
-  createFile(options: Object): Promise<Object>;
-  fileExists(options: Object): Promise<boolean>;
-  listFiles(options: Object): Promise<Object>;
+  syncCloud(): Promise<boolean>;
+  listFiles(options: {
+    scope: string;
+    targetPath?: string;
+  }): Promise<{
+    files: Array<{
+      id: string;
+      name: string;
+      lastModified: string;
+      isFile?: boolean;
+    }>;
+  }>;
+  deleteFromCloud(item: { id: string; path?: string }): Promise<boolean>;
+  fileExists(options: {
+    fileId?: string;
+    targetPath?: string;
+    scope?: string;
+  }): Promise<boolean>;
+  copyToCloud(options: {
+    mimetype?: string | null;
+    scope: string;
+    sourcePath: { path?: string; uri?: string };
+    targetPath: string;
+  }): Promise<string>;
+  createFile(options: {
+    targetPath: string;
+    content: string;
+    scope?: string;
+  }): Promise<string>;
+
+  // iOS only
   getIcloudDocument(filename: string): Promise<string>;
-  deleteFromCloud(item: Object): Promise<Object>;
-  copyToCloud(options: Object): Promise<Object>;
-  syncCloud(): Promise<void>;
+
+  // Android only
+  loginIfNeeded(): Promise<boolean>;
+  logout(): Promise<boolean>;
+  getGoogleDriveDocument(fileId: string): Promise<string>;
+  getCurrentlySignedInUserData(): Promise<{
+    email: string;
+    name: string;
+    avatarUrl: string | null;
+  } | null>;
 }
 
 export default TurboModuleRegistry.getEnforcing<Spec>('RNCloudFs');

package/src/index.tsx

@@ -1,4 +1,5 @@
 import NativeCloudFs from './NativeCloudFs';
 
 export const CloudFs = NativeCloudFs;
+export default NativeCloudFs;
 export type { Spec as CloudFsSpec } from './NativeCloudFs';