ABP/Android Manual proxy user notifications

src/org/adblockplus/android/ProxyService.java

 /*
  * This file is part of the Adblock Plus,
  * Copyright (C) 2006-2012 Eyeo GmbH
  *
  * Adblock Plus is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License version 3 as
  * published by the Free Software Foundation.
  *
  * Adblock Plus is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ skipping 25 matching lines @@
 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
 import android.content.SharedPreferences;
 import android.content.SharedPreferences.OnSharedPreferenceChangeListener;
 import android.content.pm.PackageManager.NameNotFoundException;
 import android.content.res.Resources;
 import android.net.ConnectivityManager;
 import android.net.NetworkInfo;
+import android.net.Proxy;
 import android.os.Binder;
 import android.os.Build;
 import android.os.Handler;
 import android.os.IBinder;
 import android.preference.PreferenceManager;
 import android.util.Log;
 import android.widget.Toast;
 
 import com.stericson.RootTools.RootTools;
 import com.stericson.RootTools.RootToolsException;
@@ skipping 39 matching lines @@
 
   protected ProxyServer proxy = null;
   protected int port;
   private Properties proxyConfiguration = new Properties();
 
   /**
    * Indicates that service is working with root privileges.
    */
   private boolean transparent = false;
   /**
-   * Indicates that service has autoconfigured Android proxy settings (version
-   * 3.1+).
+   * Indicates that service has autoconfigured Android proxy settings (version 3.1+).
    */
   private boolean nativeProxy = false;
+  /**
+   * Indicates that Android proxy settings are correctly configured (version 4.1.2+ 4.2.2+).
+   */
+  private boolean proxyManualyConfigured = false;
 
   private String iptables = null;
 
   @Override
   public void onCreate()
   {
     super.onCreate();
 
     // Get port for local proxy
     SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
     Resources resources = getResources();
-    
+
     String p = prefs.getString(getString(R.string.pref_port), null);
     try
     {
       port = p != null ? Integer.valueOf(p) : resources.getInteger(R.integer.def_port);
     }
     catch (NumberFormatException e)
     {
       Toast.makeText(this, getString(R.string.msg_badport) + ": " + p, Toast.LENGTH_LONG).show();
       port = resources.getInteger(R.integer.def_port);
     }
 
     // Try to read user proxy settings
     String proxyHost = null;
     String proxyPort = null;
     String proxyExcl = null;
     String proxyUser = null;
     String proxyPass = null;
 
     if (hasNativeProxy)
     {
       // Read system settings
       proxyHost = System.getProperty("http.proxyHost");
       proxyPort = System.getProperty("http.proxyPort");
       proxyExcl = System.getProperty("http.nonProxyHosts");
 
       Log.d(TAG, "PRX: " + proxyHost + ":" + proxyPort + "(" + proxyExcl + ")");
-      String[] px = ProxySettings.getUserProxy(getApplicationContext()); // not used but left for future reference
+      // not used but left for future reference

[Felix Dahlke, 2013/02/22 09:11:14]

Why would we need that in the future? Even if, we could still get it from source
control.

[Andrey Novikov, 2013/02/22 09:25:05]

You asked me this already in previous reviews. :) There are two methods to read
current proxy settings, unused on looks more convenient but I am afraid to
switch to it because everything works now with the first method.

+      String[] px = ProxySettings.getUserProxy(getApplicationContext());
       if (px != null)
         Log.d(TAG, "PRX: " + px[0] + ":" + px[1] + "(" + px[2] + ")");
     }
     else
     {
       // Read application settings
       proxyHost = prefs.getString(getString(R.string.pref_proxyhost), null);
       proxyPort = prefs.getString(getString(R.string.pref_proxyport), null);
       proxyUser = prefs.getString(getString(R.string.pref_proxyuser), null);
       proxyPass = prefs.getString(getString(R.string.pref_proxypass), null);
@@ skipping 36 matching lines @@
       {
         Log.e(TAG, "Failed to initialize iptables", e);
       }
     }
 
     if (!transparent)
     {
       // Try to set native proxy
       nativeProxy = ProxySettings.setConnectionProxy(getApplicationContext(), LOCALHOST, port, "");
 
-      if (nativeProxy)
+      if (hasNativeProxy)
       {
         registerReceiver(connectionReceiver, new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION));
-        registerReceiver(connectionReceiver, new IntentFilter("android.net.wifi.LINK_CONFIGURATION_CHANGED"));
+        registerReceiver(connectionReceiver, new IntentFilter(Proxy.PROXY_CHANGE_ACTION));
       }
     }
 
     // Start engine
     AdblockPlus.getApplication().startEngine();
 
     registerReceiver(proxyReceiver, new IntentFilter(ProxyService.BROADCAST_PROXY_FAILED));
     registerReceiver(matchesReceiver, new IntentFilter(AdblockPlus.BROADCAST_FILTER_MATCHES));
 
     // Start proxy
@@ skipping 32 matching lines @@
       configureUserProxy(proxyConfiguration, proxyHost, proxyPort, proxyExcl, proxyUser, proxyPass);
 
       proxy = new ProxyServer();
       proxy.logLevel = Server.LOG_DIAGNOSTIC;
       proxy.setup(listen, proxyConfiguration.getProperty("handler"), proxyConfiguration);
       proxy.start();
     }
 
     prefs.registerOnSharedPreferenceChangeListener(this);
 
-    String msg = getString(transparent ? R.string.notif_all : nativeProxy ? R.string.notif_wifi : R.string.notif_waiting);
-    if (!transparent && !nativeProxy)
-    {
-      // Initiate no traffic check
-      notrafficHandler = new Handler();
-      notrafficHandler.postDelayed(noTraffic, NO_TRAFFIC_TIMEOUT);
-    }
     // Lock service
     boolean hideIcon = prefs.getBoolean(getString(R.string.pref_hideicon), resources.getBoolean(R.bool.def_hideicon));
+    String msg = getString(transparent ? R.string.notif_all : nativeProxy ? R.string.notif_wifi : R.string.notif_waiting);
     ongoingNotification = new Notification();
     ongoingNotification.when = 0;
     contentIntent = PendingIntent.getActivity(this, 0, new Intent(this, Preferences.class).addFlags(Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_NEW_TASK), 0);
     ongoingNotification.icon = hideIcon ? R.drawable.transparent : R.drawable.ic_stat_blocking;
     ongoingNotification.setLatestEventInfo(getApplicationContext(), getText(R.string.app_name), msg, contentIntent);
     startForeground(ONGOING_NOTIFICATION_ID, ongoingNotification);
 
-    sendBroadcast(new Intent(BROADCAST_STATE_CHANGED).putExtra("enabled", true).putExtra("port", port).putExtra("manual", isManual()));
+    // If automatic setting of proxy was blocked, check if user has set it manually
+    boolean manual = isManual();
+    if (manual && hasNativeProxy)
+    {
+      ConnectivityManager connectivityManager = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
+      updateNoTrafficCheck(connectivityManager);
+    }
+
+    sendStateChangedBroadcast();
     Log.i(TAG, "Service started");
   }
 
   @Override
   public int onStartCommand(Intent intent, int flags, int startId)
   {
     return START_STICKY;
   }
 
   @Override
   public void onDestroy()
   {
     super.onDestroy();
 
-    stopNoTrafficCheck(false);
+    stopNoTrafficCheck(false, false);
 
     unregisterReceiver(matchesReceiver);
     unregisterReceiver(proxyReceiver);
 
     // Stop IP redirecting
     if (transparent)
     {
-      new Thread() {
+      new Thread()
+      {
         @Override
         public void run()
         {
           try
           {
             RootTools.sendShell(iptables + " -t nat -F OUTPUT", DEFAULT_TIMEOUT);
           }
           catch (Exception e)
           {
             Log.e(TAG, "Failed to clear iptables", e);
           }
         }
       }.start();
     }
 
+    if (hasNativeProxy)
+      unregisterReceiver(connectionReceiver);
+
     // Clear native proxy
     if (nativeProxy)
     {
-      unregisterReceiver(connectionReceiver);
       clearConnectionProxy();
     }
 
     sendBroadcast(new Intent(BROADCAST_STATE_CHANGED).putExtra("enabled", false));
 
     // Stop proxy server
     if (proxy != null)
       proxy.close();
 
     // Stop engine if not in interactive mode
     AdblockPlus.getApplication().stopEngine(false);
 
     // Release service lock
     stopForeground(true);
 
     Log.i(TAG, "Service stopped");
   }
 
   /**
-   * Restores system proxy settings via native call on Android 3.1+ devices using
-   * Java reflection.
+   * Restores system proxy settings via native call on Android 3.1+ devices
+   * using Java reflection.
    */
   private void clearConnectionProxy()
   {
     String proxyHost = (String) proxyConfiguration.getProperty("adblock.proxyHost");
     String proxyPort = (String) proxyConfiguration.getProperty("adblock.proxyPort");
     String proxyExcl = (String) proxyConfiguration.getProperty("adblock.proxyExcl");
     int port = 0;
     try
     {
       if (proxyHost != null)
@@ skipping 121 matching lines @@
     return nativeProxy;
   }
 
   /**
    * Checks if user has to set proxy settings manually
    */
   public boolean isManual()
   {
     return !transparent && !nativeProxy;
   }
+  
+  /**
+   * Checks whether traffic check is pending
+   */
+  public boolean noTraffic()
+  {
+    return notrafficHandler != null;
+  }
 
   /**
    * Checks if specified host is local.
    */
   private static final boolean isLocalHost(String host)
   {
     if (host == null)
       return false;
 
     try
@@ skipping 14 matching lines @@
     }
     catch (Exception e)
     {
       Log.w(TAG, null, e);
     }
     return false;
   }
 
   /**
    * Initializes iptables executable.
-   *
-   * @throws FileNotFoundException If iptables initialization failed due to provided reasons.
+   * 
+   * @throws FileNotFoundException
+   *           If iptables initialization failed due to provided reasons.
    */
   private void initIptables() throws IOException, RootToolsException, TimeoutException, FileNotFoundException
   {
     if (!RootTools.isAccessGiven())
       throw new FileNotFoundException("No root access");
 
     File ipt = getFileStreamPath("iptables");
 
     if (!ipt.exists())
     {
@@ skipping 39 matching lines @@
       return RootTools.sendShell(command, DEFAULT_TIMEOUT);
     }
     catch (Exception e)
     {
       Log.e(TAG, "Failed to get iptables configuration", e);
       return null;
     }
   }
 
   /**
+   * Raises or removes no traffic notification based on current link proxy
+   * settings
+   */
+  private void updateNoTrafficCheck(ConnectivityManager connectivityManager)
+  {
+    try
+    {
+      Object pp = ProxySettings.getActiveLinkProxy(connectivityManager);
+      String[] userProxy = ProxySettings.getUserProxy(pp);
+      if (userProxy != null)
+        Log.i(TAG, "Proxy settings: " + userProxy[0] + ":" + userProxy[1] + "(" + userProxy[2] + ")");
+      updateNoTrafficCheck(userProxy);
+    }
+    catch (Exception e)
+    {
+      // This should not happen
+      Log.e(TAG, null, e);
+    }
+  }
+
+  /**
+   * Raises or removes no traffic notification based on the user proxy settings
+   */
+  private void updateNoTrafficCheck(String[] userProxy)
+  {
+    boolean ourProxy = userProxy != null && isLocalHost(userProxy[0]) && Integer.valueOf(userProxy[1]) == port;
+    if (ourProxy)
+    {
+      stopNoTrafficCheck(true, true);
+    }
+    else
+    {
+      // Initiate no traffic check
+      notrafficHandler = new Handler();
+      notrafficHandler.postDelayed(noTraffic, NO_TRAFFIC_TIMEOUT);
+      NotificationManager notificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
+      ongoingNotification.setLatestEventInfo(ProxyService.this, getText(R.string.app_name), getText(R.string.notif_waiting), contentIntent);
+      notificationManager.notify(ONGOING_NOTIFICATION_ID, ongoingNotification);
+    }
+    if (ourProxy != proxyManualyConfigured)
+    {
+      proxyManualyConfigured = ourProxy;
+      sendStateChangedBroadcast();
+    }
+  }
+
+  /**
    * Stops no traffic check, optionally resetting notification message.
-   *
+   * 
    * @param changeStatus
    *          true if notification message should be set to normal operating
    *          mode
+   * @param forceMessageReset
+   *          if true unconditionally reset main notification message
    */
-  private void stopNoTrafficCheck(boolean changeStatus)
+  private void stopNoTrafficCheck(boolean changeStatus, boolean forceMessageReset)
   {
     if (notrafficHandler != null)
     {
       notrafficHandler.removeCallbacks(noTraffic);
-      if (changeStatus)
-      {
-        NotificationManager notificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
-        ongoingNotification.setLatestEventInfo(ProxyService.this, getText(R.string.app_name), getText(R.string.notif_wifi), contentIntent);
-        notificationManager.notify(ONGOING_NOTIFICATION_ID, ongoingNotification);
-      }
+      proxyManualyConfigured = true;
+      sendStateChangedBroadcast();
+    }
+    if (changeStatus && (notrafficHandler != null || forceMessageReset))
+    {
+      NotificationManager notificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
+      ongoingNotification.setLatestEventInfo(ProxyService.this, getText(R.string.app_name), getText(R.string.notif_wifi), contentIntent);
+      notificationManager.notify(ONGOING_NOTIFICATION_ID, ongoingNotification);
     }
     notrafficHandler = null;
   }
-  
+
   public void setEmptyIcon(boolean empty)
   {
     ongoingNotification.icon = empty ? R.drawable.transparent : R.drawable.ic_stat_blocking;
-    NotificationManager notificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);    
+    NotificationManager notificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
     notificationManager.notify(ONGOING_NOTIFICATION_ID, ongoingNotification);
   }
 
+  public void sendStateChangedBroadcast()
+  {
+    Log.i(TAG, "Broadcasting " + BROADCAST_STATE_CHANGED);
+    boolean manual = isManual();
+    Intent stateIntent = new Intent(BROADCAST_STATE_CHANGED).putExtra("enabled", true).putExtra("port", port).putExtra("manual", manual);
+    if (manual)
+      stateIntent.putExtra("configured", proxyManualyConfigured);
+    sendBroadcast(stateIntent);
+  }
+
   private final IBinder binder = new LocalBinder();
 
   public final class LocalBinder extends Binder
   {
     public ProxyService getService()
     {
       return ProxyService.this;
     }
   }
 
   @Override
   public IBinder onBind(Intent intent)
   {
     return binder;
   }
 
   /**
    * Executed if no traffic is detected after a period of time. Notifies user
    * about possible configuration problems.
    */
-  private Runnable noTraffic = new Runnable() {
+  private Runnable noTraffic = new Runnable()
+  {
     public void run()
     {
       // Show warning notification
       Notification notification = new Notification();
       notification.icon = R.drawable.ic_stat_warning;
       notification.when = System.currentTimeMillis();
       notification.flags |= Notification.FLAG_AUTO_CANCEL;
       notification.defaults |= Notification.DEFAULT_SOUND;
       Intent intent = new Intent(ProxyService.this, ConfigurationActivity.class).addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
       intent.putExtra("port", port);
       PendingIntent contentIntent = PendingIntent.getActivity(ProxyService.this, 0, intent, PendingIntent.FLAG_UPDATE_CURRENT);
       notification.setLatestEventInfo(ProxyService.this, getText(R.string.app_name), getString(R.string.notif_notraffic), contentIntent);
       NotificationManager notificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
       notificationManager.notify(NOTRAFFIC_NOTIFICATION_ID, notification);
     }
   };
 
   /**
    * Stops no traffic check if traffic is detected by proxy service.
    */
-  private BroadcastReceiver matchesReceiver = new BroadcastReceiver() {
+  private BroadcastReceiver matchesReceiver = new BroadcastReceiver()
+  {
     @Override
     public void onReceive(final Context context, Intent intent)
     {
       if (intent.getAction().equals(AdblockPlus.BROADCAST_FILTER_MATCHES))
-        stopNoTrafficCheck(true);
+        stopNoTrafficCheck(true, false);
     }
   };
 
   /**
    * Stops service if proxy fails.
    */
-  private BroadcastReceiver proxyReceiver = new BroadcastReceiver() {
+  private BroadcastReceiver proxyReceiver = new BroadcastReceiver()
+  {
     @Override
     public void onReceive(final Context context, Intent intent)
     {
       if (intent.getAction().equals(ProxyService.BROADCAST_PROXY_FAILED))
       {
         stopSelf();
       }
     }
   };
 
   /**
    * Monitors system network connection settings changes and updates proxy
    * settings accordingly.
    */
-  private BroadcastReceiver connectionReceiver = new BroadcastReceiver() {
+  private BroadcastReceiver connectionReceiver = new BroadcastReceiver()
+  {
     @Override
     public void onReceive(Context ctx, Intent intent)
     {
       String action = intent.getAction();
       Log.i(TAG, "Action: " + action);
+      // Connectivity change
       if (ConnectivityManager.CONNECTIVITY_ACTION.equals(action))
       {
         ConnectivityManager connectivityManager = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
         NetworkInfo info = connectivityManager.getActiveNetworkInfo();
         if (info == null)
           return;
         String typeName = info.getTypeName();
         String subtypeName = info.getSubtypeName();
         boolean available = info.isAvailable();
+
         Log.i(TAG, "Network Type: " + typeName + ", subtype: " + subtypeName + ", available: " + available);
         if (info.getType() == ConnectivityManager.TYPE_WIFI)
-          ProxySettings.setConnectionProxy(getApplicationContext(), LOCALHOST, port, "");
+        {
+          if (nativeProxy)
+          {
+            ProxySettings.setConnectionProxy(getApplicationContext(), LOCALHOST, port, "");
+          }
+          else
+          {
+            updateNoTrafficCheck(connectivityManager);
+          }
+        }
       }
-      else if ("android.net.wifi.LINK_CONFIGURATION_CHANGED".equals(action))
+      // Proxy change
+      else if (Proxy.PROXY_CHANGE_ACTION.equals(action))
       {
-        Object lp = intent.getParcelableExtra("linkProperties");
-        Method method;
+        Object pp = intent.getParcelableExtra("proxy");
         try
         {
-          /*
-           * lp.getHttpProxy();
-           */
-          method = lp.getClass().getMethod("getHttpProxy");
-          Object pp = method.invoke(lp);
-
           String[] userProxy = ProxySettings.getUserProxy(pp);
-          if (userProxy != null && Integer.valueOf(userProxy[1]) != port)
+          if (nativeProxy)
           {
-            Log.i(TAG, "User has set new proxy: " + userProxy[0] + ":" + userProxy[1] + "(" + userProxy[2] + ")");
-            if (proxy != null)
+            if (userProxy != null && Integer.valueOf(userProxy[1]) != port)
             {
-              configureUserProxy(proxyConfiguration, userProxy[0], userProxy[1], userProxy[2], null, null);
-              proxy.restart(proxyConfiguration.getProperty("handler"));
+              Log.i(TAG, "User has set new proxy: " + userProxy[0] + ":" + userProxy[1] + "(" + userProxy[2] + ")");
+              if (proxy != null)
+              {
+                configureUserProxy(proxyConfiguration, userProxy[0], userProxy[1], userProxy[2], null, null);
+                proxy.restart(proxyConfiguration.getProperty("handler"));
+              }
             }
           }
+          else
+          {
+            Log.i(TAG, "User has set proxy: " + userProxy[0] + ":" + userProxy[1] + "(" + userProxy[2] + ")");
+            updateNoTrafficCheck(userProxy);
+          }
         }
         catch (Exception e)
         {
           // This should not happen
           Log.e(TAG, null, e);
         }
-
       }
     }
   };
 
   final class ProxyServer extends Server
   {
     @Override
     public void close()
     {
       try
@@ skipping 12 matching lines @@
     @Override
     public void log(int level, Object obj, String message)
     {
       if (level <= logLevel)
       {
         Log.println(7 - level, obj != null ? obj.toString() : TAG, message);
       }
     }
   }
 }