Merge pull request #9 from kwan3854/v1.0.0

Adds async/await support to WebView RPC framework

Author: kwan3854

CHANGELOG.md

@@ -0,0 +1,97 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [1.0.0] - 2025-06-23
+
+### Added
+- Full async/await support for both server and client implementations
+- `asyncMethodHandlers` dictionary in `ServiceDefinition` for async method registration
+- Async method handling in `WebViewRpcServer` with automatic fallback to sync handlers
+- Virtual-Virtual pattern in code generation templates for backward compatibility
+
+### Changed
+- **BREAKING**: Generated server methods now use async pattern by default
+  - C# servers must implement `UniTask<Response> MethodNameAsync(Request request)`
+  - JavaScript servers must implement `async MethodNameAsync(request)`
+- **BREAKING**: Generated client methods now have `Async` suffix
+  - C# clients call `await client.MethodNameAsync(request)`
+  - JavaScript clients call `await client.MethodNameAsync(request)`
+- WebViewRpcServer now processes async handlers first, then falls back to sync handlers
+
+### Migration Guide
+
+#### For C# Server Implementations
+
+**Before (v0.x):**
+```csharp
+public class MyService : MyServiceBase
+{
+    public override Response MyMethod(Request request)
+    {
+        // Synchronous implementation
+        return new Response { ... };
+    }
+}
+```
+
+**After (v1.0):**
+```csharp
+public class MyService : MyServiceBase
+{
+    public override async UniTask<Response> MyMethodAsync(Request request)
+    {
+        // Asynchronous implementation
+        await UniTask.Delay(100);
+        return new Response { ... };
+    }
+}
+```
+
+#### For JavaScript Server Implementations
+
+**Before (v0.x):**
+```javascript
+class MyService extends MyServiceBase {
+    MyMethod(request) {
+        // Synchronous implementation
+        return { ... };
+    }
+}
+```
+
+**After (v1.0):**
+```javascript
+class MyService extends MyServiceBase {
+    async MyMethodAsync(request) {
+        // Asynchronous implementation
+        await someAsyncOperation();
+        return { ... };
+    }
+}
+```
+
+#### For Client Code
+
+**Before (v0.x):**
+```csharp
+var response = await client.MyMethod(request);
+```
+
+**After (v1.0):**
+```csharp
+var response = await client.MyMethodAsync(request);
+```
+
+### Backward Compatibility
+
+The library maintains backward compatibility through the Virtual-Virtual pattern:
+- Existing synchronous implementations will continue to work
+- You can gradually migrate methods to async as needed
+- The server automatically handles both sync and async methods
+
+## [0.1.1] - Previous version
+- Initial release with basic RPC functionality 

Packages/WebviewRpc/Runtime/ServiceDefinition.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using Cysharp.Threading.Tasks;
 using Google.Protobuf;
 
 namespace WebViewRPC
@@ -11,5 +12,8 @@ public class ServiceDefinition
     {
         public Dictionary<string, Func<ByteString, ByteString>> MethodHandlers
             = new Dictionary<string, Func<ByteString, ByteString>>();
+            
+        public Dictionary<string, Func<ByteString, UniTask<ByteString>>> AsyncMethodHandlers
+            = new Dictionary<string, Func<ByteString, UniTask<ByteString>>>();
     }
 }

Packages/WebviewRpc/Runtime/WebViewRpcClient.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
-using System.Threading.Tasks;
+using System.Threading;
+using Cysharp.Threading.Tasks;
 using Google.Protobuf;
 
 namespace WebViewRPC
@@ -12,9 +13,9 @@ public class WebViewRpcClient : IDisposable
     {
         private readonly IWebViewBridge _bridge;
 
-        // Mapping RequestId -> TaskCompletionSource
-        private readonly Dictionary<string, TaskCompletionSource<RpcEnvelope>> _pendingRequests
-            = new Dictionary<string, TaskCompletionSource<RpcEnvelope>>();
+        // Mapping RequestId -> UniTaskCompletionSource
+        private readonly Dictionary<string, UniTaskCompletionSource<RpcEnvelope>> _pendingRequests
+            = new Dictionary<string, UniTaskCompletionSource<RpcEnvelope>>();
 
         private bool _disposed;
 
@@ -29,44 +30,57 @@ public WebViewRpcClient(IWebViewBridge bridge)
         /// User should not call this method directly.
         /// Instead, use generated method from .proto file.
         /// </summary>
-        public async Task<TResponse> CallMethodAsync<TResponse>(string methodName, IMessage request)
+        public async UniTask<TResponse> CallMethodAsync<TResponse>(string methodName, IMessage request, CancellationToken cancellationToken = default)
             where TResponse : IMessage<TResponse>, new()
         {
             if (_disposed) throw new ObjectDisposedException(nameof(WebViewRpcClient));
 
             var requestId = Guid.NewGuid().ToString("N");
 
-            var tcs = new TaskCompletionSource<RpcEnvelope>();
+            var utcs = new UniTaskCompletionSource<RpcEnvelope>();
             lock (_pendingRequests)
             {
-                _pendingRequests[requestId] = tcs;
+                _pendingRequests[requestId] = utcs;
             }
 
-            // (Protobuf -> byte[] -> Base64)
-            var requestBytes = request.ToByteArray();
-            var env = new RpcEnvelope
+            // Handle cancellation
+            using (cancellationToken.Register(() =>
             {
-                RequestId = requestId,
-                IsRequest = true,
-                Method = methodName,
-                Payload = ByteString.CopyFrom(requestBytes)
-            };
-            var envBytes = env.ToByteArray();
-            var envBase64 = Convert.ToBase64String(envBytes);
-
-            // Send to WebView
-            _bridge.SendMessageToWeb(envBase64);
-            
-            var responseEnv = await tcs.Task;
-            if (!string.IsNullOrEmpty(responseEnv.Error))
+                lock (_pendingRequests)
+                {
+                    if (_pendingRequests.Remove(requestId, out var cancelled))
+                    {
+                        cancelled.TrySetCanceled();
+                    }
+                }
+            }))
             {
-                throw new Exception($"RPC Error: {responseEnv.Error}");
-            }
+                // (Protobuf -> byte[] -> Base64)
+                var requestBytes = request.ToByteArray();
+                var env = new RpcEnvelope
+                {
+                    RequestId = requestId,
+                    IsRequest = true,
+                    Method = methodName,
+                    Payload = ByteString.CopyFrom(requestBytes)
+                };
+                var envBytes = env.ToByteArray();
+                var envBase64 = Convert.ToBase64String(envBytes);
 
-            // Payload -> TResponse
-            var resp = new TResponse();
-            resp.MergeFrom(responseEnv.Payload);
-            return resp;
+                // Send to WebView
+                _bridge.SendMessageToWeb(envBase64);
+                
+                var responseEnv = await utcs.Task;
+                if (!string.IsNullOrEmpty(responseEnv.Error))
+                {
+                    throw new Exception($"RPC Error: {responseEnv.Error}");
+                }
+
+                // Payload -> TResponse
+                var resp = new TResponse();
+                resp.MergeFrom(responseEnv.Payload);
+                return resp;
+            }
         }
 
         private void OnBridgeMessage(string base64)
@@ -91,14 +105,14 @@ private void OnBridgeMessage(string base64)
 
         private void HandleResponse(RpcEnvelope env)
         {
-            TaskCompletionSource<RpcEnvelope> tcs = null;
+            UniTaskCompletionSource<RpcEnvelope> utcs = null;
             lock (_pendingRequests)
             {
-                _pendingRequests.Remove(env.RequestId, out tcs);
+                _pendingRequests.Remove(env.RequestId, out utcs);
             }
-            if (tcs != null)
+            if (utcs != null)
             {
-                tcs.TrySetResult(env);
+                utcs.TrySetResult(env);
             }
         }
 

Packages/WebviewRpc/Runtime/WebViewRpcServer.cs

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using Cysharp.Threading.Tasks;
 using Google.Protobuf;
 using UnityEngine;
 
@@ -16,6 +17,7 @@ public class WebViewRpcServer : IDisposable
         public List<ServiceDefinition> Services { get; } = new();
 
         private readonly Dictionary<string, Func<ByteString, ByteString>> _methodHandlers = new();
+        private readonly Dictionary<string, Func<ByteString, UniTask<ByteString>>> _asyncMethodHandlers = new();
 
         public WebViewRpcServer(IWebViewBridge bridge)
         {
@@ -34,10 +36,15 @@ public void Start()
                 {
                     _methodHandlers[kv.Key] = kv.Value;
                 }
+                
+                foreach (var kv in sd.AsyncMethodHandlers)
+                {
+                    _asyncMethodHandlers[kv.Key] = kv.Value;
+                }
             }
         }
 
-        private void OnBridgeMessage(string base64)
+        private async void OnBridgeMessage(string base64)
         {
             if (_disposed) return;
 
@@ -48,7 +55,7 @@ private void OnBridgeMessage(string base64)
 
                 if (env.IsRequest)
                 {
-                    HandleRequest(env);
+                    await HandleRequestAsync(env);
                 }
             }
             catch (Exception ex)
@@ -57,7 +64,7 @@ private void OnBridgeMessage(string base64)
             }
         }
 
-        private void HandleRequest(RpcEnvelope reqEnv)
+        private async UniTask HandleRequestAsync(RpcEnvelope reqEnv)
         {
             var respEnv = new RpcEnvelope
             {
@@ -68,7 +75,14 @@ private void HandleRequest(RpcEnvelope reqEnv)
 
             try
             {
-                if (_methodHandlers.TryGetValue(reqEnv.Method, out var handler))
+                // Check async handlers first
+                if (_asyncMethodHandlers.TryGetValue(reqEnv.Method, out var asyncHandler))
+                {
+                    var responsePayload = await asyncHandler(reqEnv.Payload);
+                    respEnv.Payload = ByteString.CopyFrom(responsePayload.ToByteArray());
+                }
+                // Fallback to sync handlers
+                else if (_methodHandlers.TryGetValue(reqEnv.Method, out var handler))
                 {
                     var responsePayload = handler(reqEnv.Payload);
                     respEnv.Payload = ByteString.CopyFrom(responsePayload.ToByteArray());

Packages/WebviewRpc/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.kwanjoong.webviewrpc",
-  "version": "0.2.0",
+  "version": "1.0.0",
   "displayName": "Webview RPC",
   "description": "The webview Remote Procedure Call bridge.",
   "unity": "2022.3",

README.md

@@ -73,6 +73,21 @@ npm install
 npm run build
 ```
 
+## What's New in v1.0.0
+
+### Full Async/Await Support
+WebView RPC now supports full async/await patterns for both server and client implementations:
+
+- **C# Integration**: Uses `UniTask` for better Unity performance
+- **JavaScript Integration**: Native `async/await` support
+- **Backward Compatibility**: Existing synchronous code continues to work through the Virtual-Virtual pattern
+
+### Breaking Changes
+- Generated methods now have `Async` suffix (e.g., `SayHelloAsync`)
+- Server implementations must use async patterns
+
+For detailed migration guide, see [CHANGELOG.md](CHANGELOG.md).
+
 ## Installation
 
 ### Adding WebView RPC to a Unity Project
@@ -373,18 +388,23 @@ public class WebViewRpcTester : MonoBehaviour
 ```
 
 ```csharp
+using Cysharp.Threading.Tasks;
 using HelloWorld;
 using UnityEngine;
 
 namespace SampleRpc
 {
-    // Inherit HelloWorldService and implement the SayHello method.
-    // HelloWorldService is generated from HelloWorld.proto.
+    // Inherit HelloServiceBase and implement the SayHelloAsync method.
+    // HelloServiceBase is generated from HelloWorld.proto.
     public class HelloWorldService : HelloServiceBase
     {
-        public override HelloResponse SayHello(HelloRequest request)
+        public override async UniTask<HelloResponse> SayHelloAsync(HelloRequest request)
         {
             Debug.Log($"Received request: {request.Name}");
+            
+            // Example async operation
+            await UniTask.Delay(100);
+            
             return new HelloResponse()
             {
                 // Process the request and return a response
@@ -408,7 +428,8 @@ document.getElementById('btnSayHello').addEventListener('click', async () => {
         const reqObj = { name: "Hello World! From WebView" };
         console.log("Request to Unity: ", reqObj);
 
-        const resp = await helloClient.SayHello(reqObj);
+        // Note: Method now has Async suffix
+        const resp = await helloClient.SayHelloAsync(reqObj);
         console.log("Response from Unity: ", resp.greeting);
     } catch (err) {
         console.error("Error: ", err);
@@ -467,8 +488,8 @@ public class WebViewRpcTester : MonoBehaviour
         // Create a HelloServiceClient
         var client = new HelloServiceClient(rpcClient);
 
-        // Send a request
-        var response = await client.SayHello(new HelloRequest()
+        // Send a request (note the Async suffix)
+        var response = await client.SayHelloAsync(new HelloRequest()
         {
             Name = "World"
         });
@@ -508,9 +529,12 @@ import { HelloServiceBase } from "./HelloWorld_HelloServiceBase.js";
 
 // Inherit HelloServiceBase from the auto-generated HelloWorld_HelloServiceBase.js
 export class MyHelloServiceImpl extends HelloServiceBase {
-    SayHello(requestObj) {
+    async SayHelloAsync(requestObj) {
         // Check the incoming request
         console.log("JS Server received: ", requestObj);
+        
+        // Example async operation
+        await new Promise(resolve => setTimeout(resolve, 100));
 
         // Process the request and return a response
         return {