Invoke start callback accurately (#10)

Author: alberto lalama

src/android/org/uproxy/tun2socks/Tun2Socks.java

@@ -30,6 +30,7 @@ public class Tun2Socks extends CordovaPlugin {
   public static final int RESULT_OK = -1;
 
   private String m_socksServerAddress;
+  private CallbackContext m_onStartCallback = null;
   private CallbackContext m_onDisconnectCallback = null;
 
   @Override
@@ -48,7 +49,8 @@ public boolean execute(String action, JSONArray args, CallbackContext callbackCo
         // from onActivityResult.
         m_socksServerAddress = args.getString(0);
         Log.i(LOG_TAG, "Got socks server address: " + m_socksServerAddress);
-        prepareAndStartTunnelService(callbackContext);
+        m_onStartCallback = callbackContext;
+        prepareAndStartTunnelService();
       }
       return true;
     } else if (action.equals(STOP_ACTION)) {
@@ -76,10 +78,12 @@ protected void pluginInitialize() {
       return;
     }
 
+    IntentFilter broadcastFilter =
+        new IntentFilter(TunnelVpnService.TUNNEL_VPN_DISCONNECT_BROADCAST);
+    broadcastFilter.addAction(TunnelVpnService.TUNNEL_VPN_START_BROADCAST);
+
     LocalBroadcastManager.getInstance(getBaseContext())
-        .registerReceiver(
-            m_disconnectBroadcastReceiver,
-            new IntentFilter(TunnelVpnService.TUNNEL_VPN_DISCONNECT_BROADCAST));
+        .registerReceiver(m_vpnTunnelBroadcastReceiver, broadcastFilter);
   }
 
   @Override
@@ -89,16 +93,15 @@ public void onDestroy() {
     stopTunnelService();
   }
 
-  protected void prepareAndStartTunnelService(CallbackContext callbackContext) {
+  protected void prepareAndStartTunnelService() {
     Log.d(LOG_TAG, "Starting tun2socks...");
     if (hasVpnService()) {
       if (prepareVpnService()) {
         startTunnelService(getBaseContext());
       }
-      callbackContext.success("Started tun2socks");
     } else {
       Log.e(LOG_TAG, "Device does not support whole device VPN mode.");
-      callbackContext.error("Failed to start tun2socks");
+      m_onStartCallback.error("Failed to start tun2socks");
     }
   }
 
@@ -127,13 +130,16 @@ protected boolean prepareVpnService() throws ActivityNotFoundException {
   public void onActivityResult(int request, int result, Intent data) {
     if (request == REQUEST_CODE_PREPARE_VPN && result == RESULT_OK) {
       startTunnelService(getBaseContext());
+    } else {
+      Log.e(LOG_TAG, "failed to prepare VPN");
+      m_onStartCallback.error("Failed to start tun2socks");
     }
   }
 
   protected void startTunnelService(Context context) {
     Log.i(LOG_TAG, "starting tunnel service");
     if (isServiceRunning()) {
-      Log.w(LOG_TAG, "already running service");
+      Log.d(LOG_TAG, "already running service");
       TunnelManager tunnelManager = TunnelState.getTunnelState().getTunnelManager();
       if (tunnelManager != null) {
         tunnelManager.restartTunnel(m_socksServerAddress);
@@ -172,6 +178,19 @@ private Context getBaseContext() {
     return this.cordova.getActivity().getApplicationContext();
   }
 
+  public void onStartVpn(boolean success) {
+    if (m_onStartCallback == null || m_onStartCallback.isFinished()) {
+      Log.e(LOG_TAG, "failed to call on start callback");
+      return;
+    }
+
+    if (success) {
+      m_onStartCallback.success("Started tun2socks");
+    } else {
+      m_onStartCallback.error("Failed to start tun2socks");
+    }
+  }
+
   public void onDisconnect() {
     if (m_onDisconnectCallback != null) {
       PluginResult result = new PluginResult(PluginResult.Status.OK);
@@ -180,20 +199,27 @@ public void onDisconnect() {
     }
   }
 
-  private DisconnectBroadcastReceiver m_disconnectBroadcastReceiver =
-      new DisconnectBroadcastReceiver(Tun2Socks.this);
+  private VpnTunnelBroadcastReceiver m_vpnTunnelBroadcastReceiver =
+      new VpnTunnelBroadcastReceiver(Tun2Socks.this);
 
-  private class DisconnectBroadcastReceiver extends BroadcastReceiver {
+  private class VpnTunnelBroadcastReceiver extends BroadcastReceiver {
     private Tun2Socks m_handler;
 
-    public DisconnectBroadcastReceiver(Tun2Socks handler) {
+    public VpnTunnelBroadcastReceiver(Tun2Socks handler) {
       m_handler = handler;
     }
 
     @Override
     public void onReceive(Context context, Intent intent) {
-      // Callback into handler so we can communicate the disconnect event to js.
-      m_handler.onDisconnect();
+      final String action = intent.getAction();
+      if (TunnelVpnService.TUNNEL_VPN_START_BROADCAST.equals(action)) {
+        boolean startSuccess = intent.getBooleanExtra(
+            TunnelVpnService.TUNNEL_VPN_START_SUCCESS_EXTRA, true);
+        m_handler.onStartVpn(startSuccess);
+
+      } else if (TunnelVpnService.TUNNEL_VPN_DISCONNECT_BROADCAST.equals(action)) {
+        m_handler.onDisconnect();
+      }
     }
   };
 }

src/android/org/uproxy/tun2socks/TunnelManager.java

@@ -40,15 +40,15 @@ public class TunnelManager implements Tunnel.HostService {
   private static final String LOG_TAG = "TunnelManager";
   public static final String SOCKS_SERVER_ADDRESS_EXTRA = "socksServerAddress";
 
-  private Service m_parentService = null;
+  private TunnelVpnService m_parentService = null;
   private CountDownLatch m_tunnelThreadStopSignal;
   private Thread m_tunnelThread;
   private AtomicBoolean m_isStopping;
   private Tunnel m_tunnel = null;
   private String m_socksServerAddress;
   private AtomicBoolean m_isReconnecting;
 
-  public TunnelManager(Service parentService) {
+  public TunnelManager(TunnelVpnService parentService) {
     m_parentService = parentService;
     m_isStopping = new AtomicBoolean(false);
     m_isReconnecting = new AtomicBoolean(false);
@@ -65,15 +65,18 @@ public int onStartCommand(Intent intent, int flags, int startId) {
     m_socksServerAddress = intent.getStringExtra(SOCKS_SERVER_ADDRESS_EXTRA);
     if (m_socksServerAddress == null) {
       Log.e(LOG_TAG, "Failed to receive the socks server address.");
+      m_parentService.broadcastVpnStart(false /* success */);
       return 0;
     }
 
     try {
       if (!m_tunnel.startRouting()) {
         Log.e(LOG_TAG, "Failed to establish VPN");
+        m_parentService.broadcastVpnStart(false /* success */);
       }
     } catch (Tunnel.Exception e) {
       Log.e(LOG_TAG, String.format("Failed to establish VPN: %s", e.getMessage()));
+      m_parentService.broadcastVpnStart(false /* success */);
     }
     return android.app.Service.START_NOT_STICKY;
   }
@@ -119,6 +122,7 @@ public void restartTunnel(final String socksServerAddress) {
     if (socksServerAddress == null ||
         socksServerAddress.equals(m_socksServerAddress)) {
       // Don't reconnect if the socks server address hasn't changed.
+      m_parentService.broadcastVpnStart(true /* success */);
       return;
     }
     m_socksServerAddress = socksServerAddress;
@@ -152,6 +156,7 @@ private void runTunnel(String socksServerAddress, String dnsResolverAddress) {
         throw new Tunnel.Exception("application is not prepared or revoked");
       }
       Log.i(LOG_TAG, "VPN service running");
+      m_parentService.broadcastVpnStart(true /* success */);
 
       try {
         m_tunnelThreadStopSignal.await();
@@ -163,6 +168,7 @@ private void runTunnel(String socksServerAddress, String dnsResolverAddress) {
 
     } catch (Tunnel.Exception e) {
       Log.e(LOG_TAG, String.format("Start tunnel failed: %s", e.getMessage()));
+      m_parentService.broadcastVpnStart(false /* success */);
     } finally {
       if (m_isReconnecting.get()) {
         // Stop tunneling only, not VPN, if reconnecting.

src/android/org/uproxy/tun2socks/TunnelVpnService.java

@@ -34,6 +34,10 @@ public class TunnelVpnService extends VpnService {
   private static final String LOG_TAG = "TunnelVpnService";
   public static final String TUNNEL_VPN_DISCONNECT_BROADCAST =
       "tunnelVpnDisconnectBroadcast";
+  public static final String TUNNEL_VPN_START_BROADCAST =
+      "tunnelVpnStartBroadcast";
+  public static final String TUNNEL_VPN_START_SUCCESS_EXTRA =
+      "tunnelVpnStartSuccessExtra";
 
   private TunnelManager m_tunnelManager = new TunnelManager(this);
 
@@ -85,9 +89,21 @@ public VpnService.Builder newBuilder() {
     return new VpnService.Builder();
   }
 
-  private void broadcastVpnDisconnect() {
-    Intent disconnectBroadcast = new Intent(TUNNEL_VPN_DISCONNECT_BROADCAST);
+  // Broadcast non-user-initiated VPN disconnect.
+  public void broadcastVpnDisconnect() {
+    dispatchBroadcast(new Intent(TUNNEL_VPN_DISCONNECT_BROADCAST));
+  }
+
+  // Broadcast VPN start. |success| is true if the VPN and tunnel were started
+  // successfully, and false otherwise.
+  public void broadcastVpnStart(boolean success) {
+    Intent vpnStart = new Intent(TUNNEL_VPN_START_BROADCAST);
+    vpnStart.putExtra(TUNNEL_VPN_START_SUCCESS_EXTRA, success);
+    dispatchBroadcast(vpnStart);
+  }
+
+  private void dispatchBroadcast(final Intent broadcast) {
     LocalBroadcastManager.getInstance(TunnelVpnService.this)
-        .sendBroadcast(disconnectBroadcast);
+        .sendBroadcast(broadcast);
   }
 }