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 39 matching lines @@
 import android.util.Log;
 
 public class ProxyService extends Service implements OnSharedPreferenceChangeListener
 {
   private static final String TAG = Utils.getTag(ProxyService.class);
 
   private static final String LOCALHOST = "127.0.0.1";
 
   private static final int[] PORT_VARIANTS = new int[] {-1, 2020, 3030, 4040, 5050, 6060, 7070, 9090, 1234, 12345, 4321, 0};
 
-  // FIXME remove me
   private static final boolean LOG_REQUESTS = false;
 
   static final int ONGOING_NOTIFICATION_ID = R.string.app_name;
 
   private static final long POSITION_RIGHT = Build.VERSION.SDK_INT >= Build.VERSION_CODES.GINGERBREAD ? Long.MIN_VALUE : Long.MAX_VALUE;
 
   /**
    * Broadcasted when service starts or stops.
    */
   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
     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()
   {
     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())
     {
@@ skipping 90 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.
-   * </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);
       }
     }
   }
 }