wifidirectplugin 1.3.0 → 1.3.2

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

@@ -4,10 +4,16 @@ import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
+import android.net.ConnectivityManager;
+import android.net.Network;
+import android.net.NetworkCapabilities;
+import android.net.NetworkRequest;
 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 +35,18 @@ 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;
+
+    // P2P 네트워크에 앱 프로세스를 바인딩해 HTTP 요청을 P2P 인터페이스로 강제하기 위한 상태
+    private ConnectivityManager connectivityManager;
+    private ConnectivityManager.NetworkCallback p2pNetworkCallback = null;
+    private Network boundP2pNetwork = null;
+
     private final BroadcastReceiver wifiP2pReceiver = new BroadcastReceiver() {
         @Override
         public void onReceive(Context context, Intent intent) {
@@ -39,6 +57,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 +69,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;
                     }
@@ -68,7 +88,7 @@ public class WifiDirectPlugin extends Plugin {
                 Log.e(TAG, "P2P Channel disconnected");
             }
         });
-        
+
         IntentFilter intentFilter = new IntentFilter();
         intentFilter.addAction(WifiP2pManager.WIFI_P2P_CONNECTION_CHANGED_ACTION);
         intentFilter.addAction(WifiP2pManager.WIFI_P2P_STATE_CHANGED_ACTION);
@@ -76,6 +96,10 @@ public class WifiDirectPlugin extends Plugin {
         intentFilter.addAction(WifiP2pManager.WIFI_P2P_THIS_DEVICE_CHANGED_ACTION);
 
         context.registerReceiver(wifiP2pReceiver, intentFilter);
+
+        // P2P 네트워크 가용성을 감시해 onAvailable 시점에 자동으로 프로세스를 바인딩
+        connectivityManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
+        registerP2pNetworkCallback();
     }
 
     public void unload() {
@@ -84,6 +108,7 @@ public class WifiDirectPlugin extends Plugin {
         } catch (IllegalArgumentException e) {
             Log.w(TAG, "Receiver not registered or already registered");
         }
+        unregisterP2pNetworkCallback();
     }
     @PluginMethod
     public void scanWifiPeers(PluginCall call) {
@@ -155,21 +180,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 +212,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 +242,205 @@ 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);
+        }
+    }
+
+    // ── P2P 네트워크 프로세스 바인딩 ──────────────────────────────────────────
+    // ECU 서버(192.168.X.1)는 P2P 인터페이스에서만 도달 가능하지만, Android의
+    // default network는 인터넷이 가능한 일반 Wi-Fi/셀룰러로 잡히기 때문에
+    // 앱의 HTTP 요청이 P2P가 아닌 곳으로 빠져 IOException이 발생한다.
+    // P2P 트랜스포트 네트워크 가용 시점에 명시적으로 프로세스를 바인딩한다.
+    private void registerP2pNetworkCallback() {
+        if (connectivityManager == null) return;
+        if (p2pNetworkCallback != null) return;
+
+        NetworkRequest req = new NetworkRequest.Builder()
+            .addTransportType(NetworkCapabilities.TRANSPORT_WIFI_P2P)
+            // P2P는 인터넷 capability가 없으므로 매칭을 위해 제거
+            .removeCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET)
+            .build();
+
+        p2pNetworkCallback = new ConnectivityManager.NetworkCallback() {
+            @Override
+            public void onAvailable(Network network) {
+                Log.d(TAG, "P2P network available, binding process to it");
+                boundP2pNetwork = network;
+                try {
+                    connectivityManager.bindProcessToNetwork(network);
+                } catch (Exception e) {
+                    Log.e(TAG, "bindProcessToNetwork failed", e);
+                }
+            }
+
+            @Override
+            public void onLost(Network network) {
+                Log.d(TAG, "P2P network lost: " + network);
+                if (network.equals(boundP2pNetwork)) {
+                    try {
+                        connectivityManager.bindProcessToNetwork(null);
+                    } catch (Exception e) {
+                        Log.w(TAG, "bindProcessToNetwork(null) failed", e);
+                    }
+                    boundP2pNetwork = null;
+                }
+            }
+        };
+
+        try {
+            connectivityManager.registerNetworkCallback(req, p2pNetworkCallback);
+            Log.d(TAG, "P2P NetworkCallback registered");
+        } catch (Exception e) {
+            Log.e(TAG, "registerNetworkCallback failed", e);
+            p2pNetworkCallback = null;
+        }
+    }
+
+    private void unregisterP2pNetworkCallback() {
+        if (connectivityManager == null) return;
+        if (p2pNetworkCallback != null) {
+            try {
+                connectivityManager.unregisterNetworkCallback(p2pNetworkCallback);
+            } catch (IllegalArgumentException e) {
+                Log.w(TAG, "P2P NetworkCallback already unregistered");
+            }
+            p2pNetworkCallback = null;
+        }
+        if (boundP2pNetwork != null) {
+            try {
+                connectivityManager.bindProcessToNetwork(null);
+            } catch (Exception ignored) {}
+            boundP2pNetwork = null;
+        }
+    }
+
+    // JS에서 강제로 인터넷 사용이 필요한 페이지로 갈 때 호출
+    // (예: 백엔드 API 호출 직전). 호출 후 P2P 그룹이 다시 형성되거나
+    // bindToP2p() 가 호출되면 다시 바인딩된다.
+    @PluginMethod
+    public void unbindFromP2p(PluginCall call) {
+        if (connectivityManager == null) {
+            call.reject("ConnectivityManager not initialized");
+            return;
+        }
+        try {
+            connectivityManager.bindProcessToNetwork(null);
+            boundP2pNetwork = null;
+            Log.d(TAG, "Process unbound from P2P network");
+            JSObject ret = new JSObject();
+            ret.put("unbound", true);
+            call.resolve(ret);
+        } catch (Exception e) {
+            call.reject("unbindFromP2p failed: " + e.getMessage());
+        }
+    }
+
+    // JS에서 명시적으로 다시 P2P에 바인딩해야 할 때 호출.
+    // 일반적으로는 NetworkCallback이 자동 처리하므로 필요 없지만, 콜백이
+    // 늦거나 누락된 환경을 위해 제공.
+    @PluginMethod
+    public void bindToP2p(PluginCall call) {
+        if (connectivityManager == null) {
+            call.reject("ConnectivityManager not initialized");
+            return;
+        }
+        Network[] networks = connectivityManager.getAllNetworks();
+        for (Network n : networks) {
+            NetworkCapabilities caps = connectivityManager.getNetworkCapabilities(n);
+            if (caps != null && caps.hasTransport(NetworkCapabilities.TRANSPORT_WIFI_P2P)) {
+                try {
+                    connectivityManager.bindProcessToNetwork(n);
+                    boundP2pNetwork = n;
+                    Log.d(TAG, "Process bound to P2P network (manual)");
+                    JSObject ret = new JSObject();
+                    ret.put("bound", true);
+                    call.resolve(ret);
+                    return;
+                } catch (Exception e) {
+                    call.reject("bindProcessToNetwork failed: " + e.getMessage());
+                    return;
+                }
+            }
+        }
+        call.reject("No P2P network available to bind");
+    }
+
     @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.2",
   "description": "HT-Installer Wifi Direct Plugin",
   "main": "dist/plugin.cjs.js",
   "module": "dist/esm/index.js",