Proxy configurators

src/org/adblockplus/android/ProxyService.java

 /*
  * This file is part of Adblock Plus <http://adblockplus.org/>,
  * Copyright (C) 2006-2014 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 58 matching lines @@
   public static final String BROADCAST_STATE_CHANGED = "org.adblockplus.android.SERVICE_STATE_CHANGED";
 
   /**
    * Broadcasted if proxy fails to start.
    */
   public static final String BROADCAST_PROXY_FAILED = "org.adblockplus.android.PROXY_FAILURE";
 
   /**
    * Common command bridge
    */
-  public static final String COMMAND_BRIDGE_ACTION = "org.adblockplus.android.COMMAND_BRIDGE";
+  public static final String PROXY_STATE_CHANGED_ACTION = "org.adblockplus.android.PROXY_STATE_CHANGED";
 
   boolean hideIcon;
 
   protected ProxyServer proxy = null;
 
   protected int port;
 
   private final Properties proxyConfiguration = new Properties();
 
   private ProxyConfigurator proxyConfigurator = null;
 
   @SuppressLint("NewApi")
   @Override
   public void onCreate()
   {
     super.onCreate();
 
-    // FIXME 'StrictMode' is API9

[Felix Dahlke, 2014/08/19 16:14:46]

I still think this should be part of a larger "support API 7 again" issue - if
we do want that.

[René Jeschke, 2014/08/19 16:33:24]

We talked about this some weeks ago. I told you there are devices with ARMv7 and
API7, you said: "then we need to support this", so, yes, I thought we would need
to go back to API7 :-D

But, jep, will create and issue :-D

FIXME removed.

     StrictMode.setThreadPolicy(new StrictMode.ThreadPolicy.Builder()
         .permitAll()
         .penaltyLog()
         .build());
 
     final SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
 
     // Try to read user proxy settings
     String proxyHost = System.getProperty("http.proxyHost");;
     String proxyPort = System.getProperty("http.proxyPort");
     final String proxyExcl = System.getProperty("http.nonProxyHosts");
     String proxyUser = null;
     String proxyPass = null;
 
     if (proxyHost == null || proxyPort == null)
     {
       // 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);
     }
 
     registerReceiver(this.proxyReceiver, new IntentFilter(ProxyService.BROADCAST_PROXY_FAILED));
-    registerReceiver(this.commandBridge, new IntentFilter(ProxyService.COMMAND_BRIDGE_ACTION));
+    registerReceiver(this.proxyStateChangedReceiver, new IntentFilter(ProxyService.PROXY_STATE_CHANGED_ACTION));
 
     final InetAddress inetAddress;
     try
     {
       inetAddress = InetAddress.getByName(LOCALHOST);
     }
     catch (final UnknownHostException e)
     {
       sendBroadcast(new Intent(BROADCAST_PROXY_FAILED)
           .putExtra("msg", "Could not resolve 'localhost'"));
@@ skipping 94 matching lines @@
   {
     return START_STICKY;
   }
 
   @Override
   public void onDestroy()
   {
     super.onDestroy();
 
     unregisterReceiver(this.proxyReceiver);
-    unregisterReceiver(this.commandBridge);
+    unregisterReceiver(this.proxyStateChangedReceiver);
 
     if (this.proxyConfigurator != null)
     {
       this.proxyConfigurator.unregisterProxy();
       this.proxyConfigurator.shutdown();
     }
 
     sendBroadcast(new Intent(BROADCAST_STATE_CHANGED).putExtra("enabled", false));
 
     // Stop proxy server
@@ skipping 84 matching lines @@
       final String proxyAuth = "Basic " + new String(Base64.encode(proxyUser + ":" + proxyPass));
       config.put("adblock.auth", proxyAuth);
       if (regType.getProxyType() == ProxyServerType.HTTPS)
       {
         config.put("https.auth", proxyAuth);
       }
     }
   }
 
   /**
-   * Lean method to send a {@link BridgeCommand} without additional extras.
-   *
-   * @param context
-   *          the context to use for sending the broadcast
-   * @param command
-   *          the command
-   */
-  public static void sendBridgeCommand(final Context context, final BridgeCommand command)
-  {
-    context.sendBroadcast(
-        new Intent(COMMAND_BRIDGE_ACTION)
-            .putExtra("command", command.toString()));
-  }
-
-  /**
    * @return {@code true} if the given host string resolves to {@code localhost}
    */
   public static boolean isLocalhost(final String host)
   {
     try
     {
       if (StringUtils.isEmpty(host))
       {
         return false;
       }
@@ skipping 20 matching lines @@
     }
     catch (final ClassCastException e)
     {
       // ignore - default handler in use
     }
   }
 
   @Override
   public void onSharedPreferenceChanged(final SharedPreferences sharedPreferences, final String key)
   {
-    // TODO verify this
     if (this.getProxyRegistrationType() != ProxyRegistrationType.NATIVE)
     {
       final String keyHost = getString(R.string.pref_proxyhost);
       final String keyPort = getString(R.string.pref_proxyport);
       final String keyUser = getString(R.string.pref_proxyuser);
       final String keyPass = getString(R.string.pref_proxypass);
       if (key.equals(keyHost) || key.equals(keyPort) || key.equals(keyUser) || key.equals(keyPass))
       {
         final String proxyHost = sharedPreferences.getString(keyHost, null);
         final String proxyPort = sharedPreferences.getString(keyPort, null);
         final String proxyUser = sharedPreferences.getString(keyUser, null);
         final String proxyPass = sharedPreferences.getString(keyPass, null);
         if (proxy != null)
         {
           configureUserProxy(proxyConfiguration, proxyHost, proxyPort, null, proxyUser, proxyPass);
           proxy.restart(proxyConfiguration.getProperty("handler"));
         }
       }
     }
   }
 
   /**
    * @return the active proxy configuration's type or {@link ProxyRegistrationType#UNKNOWN} if none is configured
    */
-  public ProxyRegistrationType getProxyRegistrationType()
+  private ProxyRegistrationType getProxyRegistrationType()
   {
     return this.proxyConfigurator != null ? this.proxyConfigurator.getType() : ProxyRegistrationType.UNKNOWN;
   }
 
   /**
    * @return {@code true} if there is a valid proxy configurator and registration succeeded
    */
   public boolean isRegistered()
   {
     return this.proxyConfigurator != null && this.proxyConfigurator.isRegistered();
   }
 
   /**
    * @return {@code true} if registration type is {@link ProxyRegistrationType#NATIVE} and registration succeeded
    */
   public boolean isNativeProxyAutoConfigured()
   {
     return this.getProxyRegistrationType() == ProxyRegistrationType.NATIVE && this.isRegistered();
   }
 
   /**
    * @return {@code true} if registration type is {@link ProxyRegistrationType#MANUAL}
    */
   public boolean isManual()

[Felix Dahlke, 2014/08/19 16:14:46]

IMO it'd be neat to have isNative() and isIptables() in the same spirit, the
former would be used more often than isManual() from what I can tell.

I _think_ we might be able to make getProxyRegistrationType() private then.

[René Jeschke, 2014/08/19 16:33:24]

At least 'isIptables()'.

Done.

   {
     return this.getProxyRegistrationType() == ProxyRegistrationType.MANUAL;
+  }
+
+  /**
+   * @return {@code true} if registration type is {@link ProxyRegistrationType#IPTABLES}
+   */
+  public boolean isIptables()
+  {
+    return this.getProxyRegistrationType() == ProxyRegistrationType.IPTABLES;
   }
 
   @SuppressLint("NewApi")
   private Notification getNotification()
   {
     final boolean filtering = AdblockPlus.getApplication().isFilteringEnabled();
 
     final int msgId;
     switch(this.getProxyRegistrationType())
     {
     case MANUAL:
       if (this.isRegistered())
       {
         msgId = filtering ? R.string.notif_wifi : R.string.notif_wifi_nofiltering;
       }
       else
       {
         msgId = filtering ? R.string.notif_waiting : R.string.notif_wifi_nofiltering;
       }
       break;
     case NATIVE:
       msgId = filtering ? R.string.notif_wifi : R.string.notif_wifi_nofiltering;
       break;
     case IPTABLES:
     case CYANOGENMOD:

[Felix Dahlke, 2014/08/19 16:14:46]

Do we currently filter non-wifi traffic on CyanogenMod? I thought not.

Actually, I think it would be cleaner if this logic would move into the
individual configurators. enum ConnectionType { WIFI, DATA, ALL } or something.

[René Jeschke, 2014/08/19 16:33:24]

Of course we are filtering all connection traffic on CM, that's the point of it
all :-D (We're a global proxy there.)

Yes, could put this into a separate enum but we won't gain much as we still have
the special manual case.

[Felix Dahlke, 2014/08/19 16:47:05]

How about adding this to ProxyConfigurationType? Seems like the right place for
it.

[René Jeschke, 2014/08/23 11:33:31]

As discussed in RL, we leave it like it is.

       msgId = R.string.notif_all;
       break;
     default:
       msgId = R.string.notif_waiting;
       break;
     }
 
     final NotificationCompat.Builder builder = new NotificationCompat.Builder(this);
     if (hideIcon && msgId != R.string.notif_waiting)
     {
@@ skipping 65 matching lines @@
     {
       if (intent.getAction().equals(ProxyService.BROADCAST_PROXY_FAILED))
       {
         stopSelf();
       }
     }
   };
 
   /**
    * <p>
-   * A BR for simple message passing from various ProxyConfigurators.
+   * Proxy state change receiver.
    * </p>
-   * <p>
-   * The purpose of this BroadcastReceiver is to allow other components to send notifications to the service and to be prepared for upcoming service
-   * refactorings.

[Felix Dahlke, 2014/08/19 16:14:46]

As discussed on IRC before, I don't understand yet what else we will use this
for. Could you list a few things?

-   * </p>
-   */
-  private final BroadcastReceiver commandBridge = new BroadcastReceiver()
+   */
+  private final BroadcastReceiver proxyStateChangedReceiver = new BroadcastReceiver()
   {
     @Override
     public void onReceive(final Context context, final Intent intent)
     {
-      if (intent != null)
-      {
-        switch (BridgeCommand.fromString(intent.getStringExtra("command")))
-        {
-        case STATE_CHANGED:
-          final NotificationManager notificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
-          notificationManager.notify(ONGOING_NOTIFICATION_ID, getNotification());
-          ProxyService.this.sendStateChangedBroadcast();
-          break;
-        default:
-          // ignore
-          break;
-        }
+      if (intent != null && PROXY_STATE_CHANGED_ACTION.equals(intent.getAction()))
+      {
+        final NotificationManager notificationManager = (NotificationManager) getSystemService(NOTIFICATION_SERVICE);
+        notificationManager.notify(ONGOING_NOTIFICATION_ID, getNotification());
+        ProxyService.this.sendStateChangedBroadcast();
       }
     }
   };
 
   final class ProxyServer extends Server
   {
     @Override
     public void close()
     {
       try
@@ skipping 12 matching lines @@
     @Override
     public void log(final int level, final Object obj, final String message)
     {
       if (level <= logLevel)
       {
         Log.println(7 - level, obj != null ? obj.toString() : TAG, message);
       }
     }
   }
 }