wifidirectplugin 1.3.0 → 1.3.1

package/android/src/main/java/com/ht/plugins/wifidirect/WifiDirectPlugin.java

@@ -8,6 +8,8 @@ import android.net.wifi.WpsInfo;
 import android.net.wifi.p2p.*;
 import android.net.NetworkInfo;
 import android.os.Build;
+import android.os.Handler;
+import android.os.Looper;
 import android.util.Log;
 
 import com.getcapacitor.*;
@@ -29,6 +31,13 @@ public class WifiDirectPlugin extends Plugin {
 
     private PluginCall pendingConnectCall = null;
 
+    // Group 형성 broadcast가 안 올 경우 대비한 timeout과 메인 핸들러
+    private final Handler mainHandler = new Handler(Looper.getMainLooper());
+    private Runnable pendingConnectTimeout = null;
+    private static final long CONNECT_TIMEOUT_MS = 20000L;
+    // removeGroup 직후 framework가 안정될 때까지 대기 시간
+    private static final long REMOVE_GROUP_SETTLE_MS = 500L;
+
     private final BroadcastReceiver wifiP2pReceiver = new BroadcastReceiver() {
         @Override
         public void onReceive(Context context, Intent intent) {
@@ -39,6 +48,7 @@ public class WifiDirectPlugin extends Plugin {
                 if (networkInfo != null && networkInfo.isConnected()) {
                     Log.d(TAG, "Wi-Fi Direct connected");
                     if (pendingConnectCall != null) {
+                        cancelConnectTimeout();
                         manager.requestConnectionInfo(channel, info -> {
                             if (info != null && info.groupFormed) {
                                 Log.d(TAG, "Group formed, resolving connectToDevice");
@@ -50,6 +60,7 @@ public class WifiDirectPlugin extends Plugin {
                 } else {
                     Log.d(TAG, "Wi-Fi Direct disconnected");
                     if (pendingConnectCall != null) {
+                        cancelConnectTimeout();
                         pendingConnectCall.reject("Wi-Fi Direct connection lost before group formed");
                         pendingConnectCall = null;
                     }
@@ -155,21 +166,31 @@ public class WifiDirectPlugin extends Plugin {
 
         manager.requestConnectionInfo(channel, info -> {
             if(info != null && info.groupFormed) {
-                // 기존 그룹 해제
-                Log.d(TAG, "Existing Wi-Fi Direct group found. Removing group.");
-                manager.removeGroup(channel, new WifiP2pManager.ActionListener() {
-                    @Override
-                    public void onSuccess() {
-                        Log.d(TAG, "removeGroup success, proceed to connect.");
-                        // 그룹 해제 성공 시 연결 계속 진행
-                        initiateConnect(deviceAddress, pin, call);
-                    }
-                    @Override
-                    public void onFailure(int reason) {
-                        Log.w(TAG, "removeGroup failed: " + reason + ". Proceed anyway.");
-                        // 그룹 해제 실패 시에도 연결 시도(혹은 call.reject로 실패 처리 가능)
-                        initiateConnect(deviceAddress, pin, call);
+                // 이미 그룹이 형성된 경우, 대상 기기와의 그룹이면 그대로 사용
+                manager.requestGroupInfo(channel, group -> {
+                    if (group != null && isTargetInGroup(group, deviceAddress)) {
+                        Log.d(TAG, "Already in group with target device, resolving immediately");
+                        call.resolve();
+                        return;
                     }
+                    Log.d(TAG, "Existing Wi-Fi Direct group is not the target. Removing group.");
+                    manager.removeGroup(channel, new WifiP2pManager.ActionListener() {
+                        @Override
+                        public void onSuccess() {
+                            Log.d(TAG, "removeGroup success, settle " + REMOVE_GROUP_SETTLE_MS + "ms before connect.");
+                            // P2P framework가 BUSY 상태에서 빠져나올 시간 확보
+                            mainHandler.postDelayed(
+                                () -> initiateConnect(deviceAddress, pin, call),
+                                REMOVE_GROUP_SETTLE_MS);
+                        }
+                        @Override
+                        public void onFailure(int reason) {
+                            Log.w(TAG, "removeGroup failed: " + reasonName(reason) + ". Proceed anyway after settle.");
+                            mainHandler.postDelayed(
+                                () -> initiateConnect(deviceAddress, pin, call),
+                                REMOVE_GROUP_SETTLE_MS);
+                        }
+                    });
                 });
             } else {
                 Log.d(TAG, "No existing group, proceed to connect directly.");
@@ -177,6 +198,23 @@ public class WifiDirectPlugin extends Plugin {
             }
         });
     }
+
+    private boolean isTargetInGroup(WifiP2pGroup group, String deviceAddress) {
+        if (deviceAddress == null) return false;
+        WifiP2pDevice owner = group.getOwner();
+        if (owner != null && deviceAddress.equalsIgnoreCase(owner.deviceAddress)) {
+            return true;
+        }
+        if (group.getClientList() != null) {
+            for (WifiP2pDevice client : group.getClientList()) {
+                if (deviceAddress.equalsIgnoreCase(client.deviceAddress)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
     private void initiateConnect(String deviceAddress, String pin, PluginCall call) {
         WifiP2pConfig config = new WifiP2pConfig();
         config.deviceAddress = deviceAddress;
@@ -190,30 +228,86 @@ public class WifiDirectPlugin extends Plugin {
                 Log.w(TAG, "Invalid Pin");
             }
         }
+
+        // 직전 시도에서 남았을 수 있는 pending negotiation을 명시적으로 정리.
+        // 실패해도 (보통 NO_SERVICE_REQUESTS 등) 그냥 무시하고 connect 진행.
+        try {
+            manager.cancelConnect(channel, new WifiP2pManager.ActionListener() {
+                @Override
+                public void onSuccess() {
+                    Log.d(TAG, "cancelConnect success, performing connect");
+                    performConnect(config, call);
+                }
+                @Override
+                public void onFailure(int reason) {
+                    Log.d(TAG, "cancelConnect failed (ignored): " + reasonName(reason));
+                    performConnect(config, call);
+                }
+            });
+        } catch (Exception e) {
+            Log.w(TAG, "cancelConnect exception (ignored)", e);
+            performConnect(config, call);
+        }
+    }
+
+    private void performConnect(WifiP2pConfig config, PluginCall call) {
         try {
             manager.connect(channel, config, new WifiP2pManager.ActionListener() {
                 @Override
                 public void onSuccess() {
                     // connect request accepted — group formation is async
                     // resolve will be called from BroadcastReceiver once group is formed
-                    Log.d(TAG, "connect onSuccess Called, waiting for group formation");
+                    Log.d(TAG, "connect onSuccess Called, waiting for group formation (timeout " + CONNECT_TIMEOUT_MS + "ms)");
                     pendingConnectCall = call;
+                    scheduleConnectTimeout();
                 }
 
                 @Override
                 public void onFailure(int reason) {
-                    Log.e(TAG, "connect onFailure Called");
+                    Log.e(TAG, "connect onFailure: " + reasonName(reason));
                     pendingConnectCall = null;
-                    call.reject("Connection failed: " + reason);
+                    cancelConnectTimeout();
+                    call.reject("Connection failed: " + reasonName(reason));
                 }
             });
         } catch (Exception e) {
             Log.e(TAG, "connect exception", e);
             pendingConnectCall = null;
+            cancelConnectTimeout();
             call.reject("Connection exception: " + e.getMessage());
         }
     }
 
+    private void scheduleConnectTimeout() {
+        cancelConnectTimeout();
+        pendingConnectTimeout = () -> {
+            if (pendingConnectCall != null) {
+                Log.w(TAG, "Group formation timed out after " + CONNECT_TIMEOUT_MS + "ms");
+                pendingConnectCall.reject("Group formation timed out");
+                pendingConnectCall = null;
+            }
+            pendingConnectTimeout = null;
+        };
+        mainHandler.postDelayed(pendingConnectTimeout, CONNECT_TIMEOUT_MS);
+    }
+
+    private void cancelConnectTimeout() {
+        if (pendingConnectTimeout != null) {
+            mainHandler.removeCallbacks(pendingConnectTimeout);
+            pendingConnectTimeout = null;
+        }
+    }
+
+    private String reasonName(int reason) {
+        switch (reason) {
+            case WifiP2pManager.ERROR: return "ERROR(0)";
+            case WifiP2pManager.P2P_UNSUPPORTED: return "P2P_UNSUPPORTED(1)";
+            case WifiP2pManager.BUSY: return "BUSY(2)";
+            case WifiP2pManager.NO_SERVICE_REQUESTS: return "NO_SERVICE_REQUESTS(3)";
+            default: return String.valueOf(reason);
+        }
+    }
+
     @PluginMethod
     public void getGroupOwnerAddress(PluginCall call) {
         manager.requestConnectionInfo(channel, wifiP2pInfo -> {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wifidirectplugin",
-  "version": "1.3.0",
+  "version": "1.3.1",
   "description": "HT-Installer Wifi Direct Plugin",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",