com.taptap.sdk.cloudsave 4.8.0-beta.1 → 4.8.1

package/Mobile/Editor/NativeDependencies.xml

@@ -1,9 +1,15 @@
-<?xml version="1.0" ?>
+<?xml version="1.0" encoding="UTF-8" standalone="no"?>
 <dependencies>
   <androidPackages>
     <repositories>
       <repository>https://repo.maven.apache.org/maven2</repository>
     </repositories>
-    <androidPackage spec="com.taptap.sdk:tap-cloudsave-unity:4.8.0-beta.1"/>
+    <androidPackage spec="com.taptap.sdk:tap-cloudsave-unity:4.8.1-beta.7"/>
   </androidPackages>
+  <iosPods>
+    <sources>
+      <source>https://github.com/CocoaPods/Specs.git</source>
+    </sources>
+    <iosPod addToAllTargets="false" bitcodeEnabled="false" name="TapTapCloudSaveSDK" version="4.8.1-beta.7"/>
+  </iosPods>
 </dependencies>

package/Mobile/Editor/TapCloudSaveMobileProcessBuild.cs

@@ -9,6 +9,7 @@ namespace TapSDK.CloudSave.Mobile.Editor {
         public override string LinkPath => "TapSDK/CloudSave/link.xml";
 
         public override LinkedAssembly[] LinkedAssemblies => new LinkedAssembly[] {
+                    new LinkedAssembly { Fullname = "TapSDK.CloudSave.Runtime" },
                     new LinkedAssembly { Fullname = "TapSDK.CloudSave.Mobile.Runtime" }
                 };
 

package/Mobile/Runtime/TapCloudSaveBridge.cs

@@ -1,11 +1,19 @@
 using System.Collections.Generic;
 using TapSDK.Core;
 using System;
+using System.Threading.Tasks;
 using Newtonsoft.Json;
 using TapSDK.CloudSave.Internal;
+using TapSDK.Core.Internal.Log;
 
 namespace TapSDK.CloudSave.Mobile
 {
+    public class ErrorResponse
+    {
+        [JsonProperty("errorCode")] public int ErrorCode { get; set; }
+        [JsonProperty("errorMessage")] public string ErrorMessage { get; set; }
+    }
+
     public class TapCloudSaveBridge : ITapCloudSaveBridge
     {
         public static string TAP_CLOUDSAVE_SERVICE = "BridgeCloudSaveService";
@@ -19,8 +27,14 @@ namespace TapSDK.CloudSave.Mobile
             EngineBridge.GetInstance().Register(TDS_CLOUDSAVE_SERVICE_CLZ, TDS_CLOUDSAVE_SERVICE_IMPL);
         }
 
+        public void Init(TapTapSdkOptions options)
+        {
+            // 原生由原生内部实现
+        }
+
         public void RegisterCloudSaveCallback(ITapCloudSaveCallback callback)
         {
+            TapLog.Log("[TapCloudSaveBridge] RegisterCloudSaveCallback called (UNCHANGED callback pattern)");
             EngineBridge.GetInstance().CallHandler(new Command.Builder()
                 .Service(TAP_CLOUDSAVE_SERVICE)
                 .Method("registerCloudSaveCallback")
@@ -37,7 +51,7 @@ namespace TapSDK.CloudSave.Mobile
                         callback.OnResult(-1);
                         return;
                     }
-                    
+
                     var result = JsonConvert.DeserializeObject<TapEngineBridgeResult>(response.content);
                     if (result != null && result.code == TapEngineBridgeResult.RESULT_SUCCESS)
                     {
@@ -63,25 +77,26 @@ namespace TapSDK.CloudSave.Mobile
             });
         }
 
-        public void CreateArchive(string metadata, string archiveFilePath, string archiveCoverPath, ITapCloudSaveRequestCallback callback)
+        public Task<ArchiveData> CreateArchive(ArchiveMetadata metadata, string archiveFilePath, string archiveCoverPath)
         {
+            TapLog.Log("[TapCloudSaveBridge] CreateArchive called with Task<ArchiveData> return type (NEW API)");
+            var taskSource = new TaskCompletionSource<ArchiveData>();
             EngineBridge.GetInstance().CallHandler(new Command.Builder()
                 .Service(TAP_CLOUDSAVE_SERVICE)
                 .Method("createArchive")
-                .Args("archiveMetadata",  metadata)
+                .Args("archiveMetadata",  JsonConvert.SerializeObject(metadata))
                 .Args("archiveFilePath",  archiveFilePath)
                 .Args("archiveCoverPath",  archiveCoverPath)
                 .Callback(true)
                 .OnceTime(true)
-                .CommandBuilder(), (response) =>
+                .CommandBuilder(), 
+                response =>
             {
-                if (callback == null) return;
-
                 try
                 {
                     if (response.code != Result.RESULT_SUCCESS || string.IsNullOrEmpty(response.content))
                     {
-                        callback.OnRequestError(-1, "Failed to create archive: code="+response.code + "content="+response.content);
+                        taskSource.TrySetException(new TapException(-1, "Failed to create archive: code="+response.code + " content="+response.content));
                         return;
                     }
                     
@@ -91,45 +106,61 @@ namespace TapSDK.CloudSave.Mobile
                         var archive = JsonConvert.DeserializeObject<ArchiveData>(result.content);
                         if (archive != null)
                         {
-                            callback.OnArchiveCreated(archive);
+                            taskSource.TrySetResult(archive);
                         }
                         else
                         {
-                            callback.OnRequestError(-1, "json convert failed: content="+result.content);
+                            taskSource.TrySetException(new TapException(-1, "json convert failed: content="+result.content));
                         }
                     }
                     else
                     {
-                        callback.OnRequestError(-1, "Failed to create archive: content="+response.content);
+                        try
+                        {
+                            var errorResponse = JsonConvert.DeserializeObject<ErrorResponse>(result.content);
+                            if (errorResponse != null)
+                            {
+                                taskSource.TrySetException(new TapException(errorResponse.ErrorCode, errorResponse.ErrorMessage));
+                            }
+                            else
+                            {
+                                taskSource.TrySetException(new TapException(-1, "Failed to create archive: content="+response.content));
+                            }
+                        }
+                        catch (Exception e)
+                        {
+                            taskSource.TrySetException(new TapException(-1, "Failed to create archive: content="+response.content));
+                        }
                     }
                 }
                 catch (Exception e)
                 {
-                    callback.OnRequestError(-1, "Failed to create archive: error=" + e.Message + ", content=" + response.content);
+                    taskSource.TrySetException(new TapException(-1, "Failed to create archive: error=" + e.Message + ", content=" + response.content));
                 }
             });
+            return taskSource.Task;
         }
         
-        public void UpdateArchive(string archiveUuid, string metadata, string archiveFilePath, string archiveCoverPath, ITapCloudSaveRequestCallback callback)
+        public Task<ArchiveData> UpdateArchive(string archiveUuid, ArchiveMetadata metadata, string archiveFilePath, string archiveCoverPath)
         {
+            TapLog.Log("[TapCloudSaveBridge] UpdateArchive called with Task<ArchiveData> return type (NEW API)");
+            var taskSource = new TaskCompletionSource<ArchiveData>();
             EngineBridge.GetInstance().CallHandler(new Command.Builder()
                 .Service(TAP_CLOUDSAVE_SERVICE)
                 .Method("updateArchive")
-                .Args("archiveUUID",  archiveUuid)
-                .Args("archiveMetadata",  metadata)
-                .Args("archiveFilePath",  archiveFilePath)
-                .Args("archiveCoverPath",  archiveCoverPath)
+                .Args("archiveUUIDForUpdate",  archiveUuid)
+                .Args("archiveMetadataForUpdate",  JsonConvert.SerializeObject(metadata))
+                .Args("archiveFilePathForUpdate",  archiveFilePath)
+                .Args("archiveCoverPathForUpdate",  archiveCoverPath)
                 .Callback(true)
                 .OnceTime(true)
                 .CommandBuilder(), (response) =>
             {
-                if (callback == null) return;
-
                 try
                 {
                     if (response.code != Result.RESULT_SUCCESS || string.IsNullOrEmpty(response.content))
                     {
-                        callback.OnRequestError(-1, "Failed to update archive: code="+response.code + "content="+response.content);
+                        taskSource.TrySetException(new TapException(-1, "Failed to update archive: code="+response.code + " content="+response.content));
                         return;
                     }
                     
@@ -139,27 +170,45 @@ namespace TapSDK.CloudSave.Mobile
                         var archive = JsonConvert.DeserializeObject<ArchiveData>(result.content);
                         if (archive != null)
                         {
-                            callback.OnArchiveUpdated(archive);
+                            taskSource.TrySetResult(archive);
                         }
                         else
                         {
-                            callback.OnRequestError(-1, "json convert failed: content="+result.content);
+                            taskSource.TrySetException(new TapException(-1, "json convert failed: content="+result.content));
                         }
                     }
                     else
                     {
-                        callback.OnRequestError(-1, "Failed to update archive: content="+response.content);
+                        try
+                        {
+                            var errorResponse = JsonConvert.DeserializeObject<ErrorResponse>(result.content);
+                            if (errorResponse != null)
+                            {
+                                taskSource.TrySetException(new TapException(errorResponse.ErrorCode, errorResponse.ErrorMessage));
+                            }
+                            else
+                            {
+                                taskSource.TrySetException(new TapException(-1, "Failed to update archive: content="+response.content));
+                            }
+                        }
+                        catch (Exception e)
+                        {
+                            taskSource.TrySetException(new TapException(-1, "Failed to update archive: content="+response.content));
+                        }
                     }
                 }
                 catch (Exception e)
                 {
-                    callback.OnRequestError(-1, "Failed to update archive: error=" + e.Message + ", content=" + response.content);
+                    taskSource.TrySetException(new TapException(-1, "Failed to update archive: error=" + e.Message + ", content=" + response.content));
                 }
             });
+            return taskSource.Task;
         }
         
-        public void DeleteArchive(string archiveUuid, ITapCloudSaveRequestCallback callback)
+        public Task<ArchiveData> DeleteArchive(string archiveUuid)
         {
+            TapLog.Log("[TapCloudSaveBridge] DeleteArchive called with Task<ArchiveData> return type (NEW API)");
+            var taskSource = new TaskCompletionSource<ArchiveData>();
             EngineBridge.GetInstance().CallHandler(new Command.Builder()
                 .Service(TAP_CLOUDSAVE_SERVICE)
                 .Method("deleteArchive")
@@ -168,13 +217,11 @@ namespace TapSDK.CloudSave.Mobile
                 .OnceTime(true)
                 .CommandBuilder(), (response) =>
             {
-                if (callback == null) return;
-
                 try
                 {
                     if (response.code != Result.RESULT_SUCCESS || string.IsNullOrEmpty(response.content))
                     {
-                        callback.OnRequestError(-1, "Failed to delete archive: code="+response.code + "content="+response.content);
+                        taskSource.TrySetException(new TapException(-1, "Failed to delete archive: code="+response.code + " content="+response.content));
                         return;
                     }
 
@@ -184,27 +231,45 @@ namespace TapSDK.CloudSave.Mobile
                         var archive = JsonConvert.DeserializeObject<ArchiveData>(result.content);
                         if (archive != null)
                         {
-                            callback.OnArchiveDeleted(archive);
+                            taskSource.TrySetResult(archive);
                         }
                         else
                         {
-                            callback.OnRequestError(-1, "json convert failed: content="+response.content);
+                            taskSource.TrySetException(new TapException(-1, "json convert failed: content="+result.content));
                         }
                     }
                     else
                     {
-                        callback.OnRequestError(-1, "Failed to delete archive: content="+response.content);
+                        try
+                        {
+                            var errorResponse = JsonConvert.DeserializeObject<ErrorResponse>(result.content);
+                            if (errorResponse != null)
+                            {
+                                taskSource.TrySetException(new TapException(errorResponse.ErrorCode, errorResponse.ErrorMessage));
+                            }
+                            else
+                            {
+                                taskSource.TrySetException(new TapException(-1, "Failed to delete archive: content="+response.content));
+                            }
+                        }
+                        catch (Exception e)
+                        {
+                            taskSource.TrySetException(new TapException(-1, "Failed to delete archive: content="+response.content));
+                        }
                     }
                 }
                 catch (Exception e)
                 {
-                    callback.OnRequestError(-1, "Failed to delete archive: error=" + e.Message + ", content=" + response.content);
+                    taskSource.TrySetException(new TapException(-1, "Failed to delete archive: error=" + e.Message + ", content=" + response.content));
                 }
             });
+            return taskSource.Task;
         }
 
-        public void GetArchiveList(ITapCloudSaveRequestCallback callback)
+        public Task<List<ArchiveData>> GetArchiveList()
         {
+            TapLog.Log("[TapCloudSaveBridge] GetArchiveList called with Task<List<ArchiveData>> return type (NEW API)");
+            var taskSource = new TaskCompletionSource<List<ArchiveData>>();
             EngineBridge.GetInstance().CallHandler(new Command.Builder()
                 .Service(TAP_CLOUDSAVE_SERVICE)
                 .Method("getArchiveList")
@@ -212,13 +277,11 @@ namespace TapSDK.CloudSave.Mobile
                 .OnceTime(true)
                 .CommandBuilder(), (response) =>
             {
-                if (callback == null) return;
-
                 try
                 {
                     if (response.code != Result.RESULT_SUCCESS || string.IsNullOrEmpty(response.content))
                     {
-                        callback.OnRequestError(-1, "Failed to get archive list: code="+response.code + "content="+response.content);
+                        taskSource.TrySetException(new TapException(-1, "Failed to get archive list: code="+response.code + " content="+response.content));
                         return;
                     }
                     
@@ -228,27 +291,45 @@ namespace TapSDK.CloudSave.Mobile
                         var archiveList = JsonConvert.DeserializeObject<List<ArchiveData>>(result.content);
                         if (archiveList != null)
                         {
-                            callback.OnArchiveListResult(archiveList);
+                            taskSource.TrySetResult(archiveList);
                         }
                         else
                         {
-                            callback.OnRequestError(-1, "json convert failed: content="+response.content);
+                            taskSource.TrySetException(new TapException(-1, "json convert failed: content="+result.content));
                         }
                     }
                     else
                     {
-                        callback.OnRequestError(-1, "Failed to get archive list: content="+response.content);
+                        try
+                        {
+                            var errorResponse = JsonConvert.DeserializeObject<ErrorResponse>(result.content);
+                            if (errorResponse != null)
+                            {
+                                taskSource.TrySetException(new TapException(errorResponse.ErrorCode, errorResponse.ErrorMessage));
+                            }
+                            else
+                            {
+                                taskSource.TrySetException(new TapException(-1, "Failed to get archive list: content="+response.content));
+                            }
+                        }
+                        catch (Exception e)
+                        {
+                            taskSource.TrySetException(new TapException(-1, "Failed to get archive list: content="+response.content));
+                        }
                     }
                 }
                 catch (Exception e)
                 {
-                    callback.OnRequestError(-1, "Failed to get archive list: error=" + e.Message  + ", content=" + response.content);
+                    taskSource.TrySetException(new TapException(-1, "Failed to get archive list: error=" + e.Message + ", content=" + response.content));
                 }
             });
+            return taskSource.Task;
         }
         
-        public void GetArchiveData(string archiveUuid, string archiveFileId, ITapCloudSaveRequestCallback callback)
+        public Task<byte[]> GetArchiveData(string archiveUuid, string archiveFileId)
         {
+            TapLog.Log("[TapCloudSaveBridge] GetArchiveData called with Task<byte[]> return type (NEW API)");
+            var taskSource = new TaskCompletionSource<byte[]>();
             EngineBridge.GetInstance().CallHandler(new Command.Builder()
                 .Service(TAP_CLOUDSAVE_SERVICE)
                 .Method("getArchiveData")
@@ -258,13 +339,11 @@ namespace TapSDK.CloudSave.Mobile
                 .OnceTime(true)
                 .CommandBuilder(), (response) =>
             {
-                if (callback == null) return;
-
                 try
                 {
                     if (response.code != Result.RESULT_SUCCESS || string.IsNullOrEmpty(response.content))
                     {
-                        callback.OnRequestError(-1, "Failed to get archive data: code=" + response.code + "content="+response.content);
+                        taskSource.TrySetException(new TapException(-1, "Failed to get archive data: code=" + response.code + " content="+response.content));
                         return;
                     }
 
@@ -274,43 +353,59 @@ namespace TapSDK.CloudSave.Mobile
                         var archiveData = Convert.FromBase64String(result.content);
                         if (archiveData != null)
                         {
-                            callback.OnArchiveDataResult(archiveData);
+                            taskSource.TrySetResult(archiveData);
                         }
                         else
                         {
-                            callback.OnRequestError(-1, "json convert failed: content="+response.content);
+                            taskSource.TrySetException(new TapException(-1, "json convert failed: content="+result.content));
                         }
                     }
                     else
                     {
-                        callback.OnRequestError(-1, "Failed to convert base64 data: content="+response.content);
+                        try
+                        {
+                            var errorResponse = JsonConvert.DeserializeObject<ErrorResponse>(result.content);
+                            if (errorResponse != null)
+                            {
+                                taskSource.TrySetException(new TapException(errorResponse.ErrorCode, errorResponse.ErrorMessage));
+                            }
+                            else
+                            {
+                                taskSource.TrySetException(new TapException(-1, "Failed to get archive data: content="+response.content));
+                            }
+                        }
+                        catch (Exception e)
+                        {
+                            taskSource.TrySetException(new TapException(-1, "Failed to get archive data: content="+response.content));
+                        }
                     }
                 }
                 catch (Exception e)
                 {
-                    callback.OnRequestError(-1, "Failed to get archive data: error=" + e.Message + ", content=" + response.content);
+                    taskSource.TrySetException(new TapException(-1, "Failed to get archive data: error=" + e.Message + ", content=" + response.content));
                 }
             });
+            return taskSource.Task;
         }
         
-        public void GetArchiveCover(string archiveUuid, string archiveFileId, ITapCloudSaveRequestCallback callback)
+        public Task<byte[]> GetArchiveCover(string archiveUuid, string archiveFileId)
         {
+            TapLog.Log("[TapCloudSaveBridge] GetArchiveCover called with Task<byte[]> return type (NEW API)");
+            var taskSource = new TaskCompletionSource<byte[]>();
             EngineBridge.GetInstance().CallHandler(new Command.Builder()
                 .Service(TAP_CLOUDSAVE_SERVICE)
                 .Method("getArchiveCover")
-                .Args("archiveUUID",  archiveUuid)
-                .Args("archiveFileID",  archiveFileId)
+                .Args("archiveUUIDForCover",  archiveUuid)
+                .Args("archiveFileIDForCover",  archiveFileId)
                 .Callback(true)
                 .OnceTime(true)
                 .CommandBuilder(), (response) =>
             {
-                if (callback == null) return;
-
                 try
                 {
                     if (response.code != Result.RESULT_SUCCESS || string.IsNullOrEmpty(response.content))
                     {
-                        callback.OnRequestError(-1, "Failed to get archive cover: code="+response.code + "content="+response.content);
+                        taskSource.TrySetException(new TapException(-1, "Failed to get archive cover: code="+response.code + " content="+response.content));
                         return;
                     }
                     
@@ -320,23 +415,39 @@ namespace TapSDK.CloudSave.Mobile
                         var coverData = Convert.FromBase64String(result.content);
                         if (coverData != null)
                         {
-                            callback.OnArchiveCoverResult(coverData);
+                            taskSource.TrySetResult(coverData);
                         }
                         else
                         {
-                            callback.OnRequestError(-1, "json convert failed: content="+response.content);
+                            taskSource.TrySetException(new TapException(-1, "json convert failed: content="+result.content));
                         }
                     }
                     else
                     {
-                        callback.OnRequestError(-1, "Failed to convert base64 data: content="+response.content);
+                        try
+                        {
+                            var errorResponse = JsonConvert.DeserializeObject<ErrorResponse>(result.content);
+                            if (errorResponse != null)
+                            {
+                                taskSource.TrySetException(new TapException(errorResponse.ErrorCode, errorResponse.ErrorMessage));
+                            }
+                            else
+                            {
+                                taskSource.TrySetException(new TapException(-1, "Failed to get archive cover: content="+response.content));
+                            }
+                        }
+                        catch (Exception e)
+                        {
+                            taskSource.TrySetException(new TapException(-1, "Failed to get archive cover: content="+response.content));
+                        }
                     }
                 }
                 catch (Exception e)
                 {
-                    callback.OnRequestError(-1, "Failed to get archive cover: error=" + e.Message + ", content=" + response.content);
+                    taskSource.TrySetException(new TapException(-1, "Failed to get archive cover: error=" + e.Message + ", content=" + response.content));
                 }
             });
+            return taskSource.Task;
         }
     }
 }

package/Runtime/Internal/ITapCloudSaveBridge.cs

@@ -1,18 +1,23 @@
-namespace TapSDK.CloudSave.Internal
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using TapSDK.Core;
+
+namespace TapSDK.CloudSave.Internal
 {
     public interface ITapCloudSaveBridge
     {
+        void Init(TapTapSdkOptions options);
+
         void RegisterCloudSaveCallback(ITapCloudSaveCallback callback);
 
-        void CreateArchive(string metadata, string archiveFilePath, string archiveCoverPath,
-            ITapCloudSaveRequestCallback callback);
+        Task<ArchiveData> CreateArchive(ArchiveMetadata metadata, string archiveFilePath, string archiveCoverPath);
 
-        void UpdateArchive(string archiveUuid, string metadata, string archiveFilePath, string archiveCoverPath,
-            ITapCloudSaveRequestCallback callback);
+        Task<ArchiveData> UpdateArchive(string archiveUuid, ArchiveMetadata metadata, string archiveFilePath, string archiveCoverPath);
 
-        void DeleteArchive(string archiveUuid, ITapCloudSaveRequestCallback callback);
-        void GetArchiveList(ITapCloudSaveRequestCallback callback);
-        void GetArchiveData(string archiveUuid, string archiveFileId, ITapCloudSaveRequestCallback callback);
-        void GetArchiveCover(string archiveUuid, string archiveFileId, ITapCloudSaveRequestCallback callback);
+        Task<ArchiveData> DeleteArchive(string archiveUuid);
+        Task<List<ArchiveData>> GetArchiveList();
+        Task<byte[]> GetArchiveData(string archiveUuid, string archiveFileId);
+        Task<byte[]> GetArchiveCover(string archiveUuid, string archiveFileId);
     }
 }

package/Runtime/Internal/TapCloudSaveInitTask.cs

@@ -9,10 +9,12 @@ namespace TapSDK.CloudSave.Internal.Init
 
         public void Init(TapTapSdkOptions coreOption)
         {
+            TapTapCloudSaveInternal.Init(coreOption);
         }
 
         public void Init(TapTapSdkOptions coreOption, TapTapSdkBaseOptions[] otherOptions)
         {
+            TapTapCloudSaveInternal.Init(coreOption);
         }
     }
 }

package/Runtime/Internal/TapTapCloudSaveInternal.cs

@@ -1,3 +1,7 @@
+using System;
+using System.Collections.Generic;
+using System.Threading.Tasks;
+using TapSDK.Core;
 using TapSDK.Core.Internal.Utils;
 
 namespace TapSDK.CloudSave.Internal
@@ -11,44 +15,33 @@ namespace TapSDK.CloudSave.Internal
             Bridge = BridgeUtils.CreateBridgeImplementation(typeof(ITapCloudSaveBridge), "TapSDK.CloudSave")
                 as ITapCloudSaveBridge;
         }
-        
-        internal static void RegisterCloudSaveCallback(ITapCloudSaveCallback callback)
-        {
-            Bridge?.RegisterCloudSaveCallback(callback);
-        }
 
-        internal static void CreateArchive(string metadata, string archiveFilePath, string archiveCoverPath,
-            ITapCloudSaveRequestCallback callback)
+        internal static void Init(TapTapSdkOptions options)
         {
-            Bridge?.CreateArchive(metadata, archiveFilePath, archiveCoverPath, callback);
+            Bridge?.Init(options);
         }
 
-        internal static void UpdateArchive(string archiveUuid, string metadata, string archiveFilePath,
-            string archiveCoverPath, ITapCloudSaveRequestCallback callback)
+        internal static void RegisterCloudSaveCallback(ITapCloudSaveCallback callback)
         {
-            Bridge?.UpdateArchive(archiveUuid, metadata, archiveFilePath, archiveCoverPath, callback);
+            Bridge?.RegisterCloudSaveCallback(callback);
         }
 
-        internal static void DeleteArchive(string archiveUuid, ITapCloudSaveRequestCallback callback)
-        {
-            Bridge?.DeleteArchive(archiveUuid, callback);
-        }
+        internal static Task<ArchiveData> CreateArchive(ArchiveMetadata metadata, string archiveFilePath, string archiveCoverPath) =>
+            Bridge?.CreateArchive(metadata, archiveFilePath, archiveCoverPath);
 
-        internal static void GetArchiveList(ITapCloudSaveRequestCallback callback)
-        {
-            Bridge?.GetArchiveList(callback);
-        }
+        internal static Task<ArchiveData> UpdateArchive(string archiveUuid, ArchiveMetadata metadata, string archiveFilePath, string archiveCoverPath) =>
+            Bridge?.UpdateArchive(archiveUuid, metadata, archiveFilePath, archiveCoverPath);
 
-        internal static void GetArchiveData(string archiveUuid, string archiveFileId,
-            ITapCloudSaveRequestCallback callback)
-        {
-            Bridge?.GetArchiveData(archiveUuid, archiveFileId, callback);
-        }
+        internal static Task<ArchiveData> DeleteArchive(string archiveUuid) =>
+            Bridge?.DeleteArchive(archiveUuid);
 
-        internal static void GetArchiveCover(string archiveUuid, string archiveFileId,
-            ITapCloudSaveRequestCallback callback)
-        {
-            Bridge?.GetArchiveCover(archiveUuid, archiveFileId, callback);
-        }
+        internal static Task<List<ArchiveData>> GetArchiveList() =>
+            Bridge?.GetArchiveList();
+
+        internal static Task<byte[]> GetArchiveData(string archiveUuid, string archiveFileId) =>
+            Bridge?.GetArchiveData(archiveUuid, archiveFileId);
+
+        internal static Task<byte[]> GetArchiveCover(string archiveUuid, string archiveFileId) =>
+            Bridge?.GetArchiveCover(archiveUuid, archiveFileId);
     }
 }