ABP/Android Proxy switch

src/org/adblockplus/android/AdblockPlus.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 32 matching lines @@
 import javax.xml.parsers.SAXParser;
 import javax.xml.parsers.SAXParserFactory;
 
 import org.adblockplus.android.updater.AlarmReceiver;
 import org.apache.commons.lang.StringEscapeUtils;
 import org.apache.commons.lang.StringUtils;
 import org.json.JSONException;
 import org.json.JSONObject;
 import org.xml.sax.SAXException;
 
+import android.app.ActivityManager;
 import android.app.AlarmManager;
 import android.app.Application;
 import android.app.PendingIntent;
+import android.app.ActivityManager.RunningServiceInfo;
 import android.content.Context;
 import android.content.Intent;
 import android.content.SharedPreferences;
 import android.content.pm.PackageInfo;
 import android.content.pm.PackageManager;
 import android.content.pm.PackageManager.NameNotFoundException;
 import android.content.res.AssetManager;
 import android.net.ConnectivityManager;
 import android.net.NetworkInfo;
 import android.net.Uri;
 import android.os.AsyncTask;
 import android.os.Build;
 import android.os.Bundle;
 import android.os.Handler;
 import android.os.Message;
 import android.os.SystemClock;
 import android.preference.PreferenceManager;
 import android.provider.Settings;
 import android.util.Log;
 import android.widget.Toast;
 
 public class AdblockPlus extends Application
 {
   private final static String TAG = "Application";
 
   private final static int MSG_TOAST = 1;
 
   /**
+   * Broadcasted when filtering is enabled or disabled.
+   */
+  public static final String BROADCAST_FILTERING_CHANGE = "org.adblockplus.android.filtering.status";
+  /**
    * Broadcasted when subscription status changes.
    */
   public final static String BROADCAST_SUBSCRIPTION_STATUS = "org.adblockplus.android.subscription.status";
   /**
    * Broadcasted when filter match check is performed.
    */
   public final static String BROADCAST_FILTER_MATCHES = "org.adblockplus.android.filter.matches";
 
   private List<Subscription> subscriptions;
 
   private JSThread js;
 
   /**
    * Indicates interactive mode (used to listen for subscription status
    * changes).
    */
   private boolean interactive = false;
 
+  /**
+   * Indicates whether filtering is enabled or not.
+   */
+  private boolean filteringEnabled = false;
+  
   private static AdblockPlus instance;
 
   /**
    * Returns pointer to itself (singleton pattern).
    */
   public static AdblockPlus getApplication()
   {
     return instance;
   }
 
@@ skipping 86 matching lines @@
   public static boolean isWiFiConnected(Context context)
   {
     ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
     NetworkInfo networkInfo = null;
     if (connectivityManager != null)
     {
       networkInfo = connectivityManager.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
     }
     return networkInfo == null ? false : networkInfo.isConnected();
   }
+  
+  /**
+   * Checks if ProxyService is running.
+   * 
+   * @return true if service is running
+   */
+  public boolean isServiceRunning()
+  {
+    ActivityManager manager = (ActivityManager) getSystemService(ACTIVITY_SERVICE);
+    // Actually it returns not only running services, so extra check is required
+    for (RunningServiceInfo service : manager.getRunningServices(Integer.MAX_VALUE))
+    {
+      if ("org.adblockplus.android.ProxyService".equals(service.service.getClassName()) && service.pid > 0)

[Felix Dahlke, 2013/03/11 06:57:38]

How about ProxyService.getClass().getCanonicalName() (should work IIRC) instead
of hard coding this?

[Andrey Novikov, 2013/03/11 07:32:55]

ProxyService.class.getCanonicalName(), done

+        return true;
+    }
+    return false;
+  }
 
   /**
    * Checks if application can write to external storage.
    */
   public boolean checkWriteExternalPermission()
   {
     String permission = "android.permission.WRITE_EXTERNAL_STORAGE";
     int res = checkCallingOrSelfPermission(permission);
     return res == PackageManager.PERMISSION_GRANTED;
   }
@@ skipping 178 matching lines @@
     return false;
   }
 
   /**
    * Returns ElemHide selectors for domain.
    * 
    * @return ready to use HTML element with CSS selectors
    */
   public String getSelectorsForDomain(final String domain)
   {
+    if (!filteringEnabled)
+      return null;
+
     Future<String> future = js.submit(new Callable<String>()
     {
       @Override
       public String call() throws Exception
       {
         String result = (String) js.evaluate("ElemHide.getSelectorsForDomain('" + domain + "')");
         return result;
       }
     });
     try
@@ skipping 49 matching lines @@
    *          Request host
    * @param refHost
    *          Request referrer header
    * @param accept
    *          Request accept header
    * @return true if matched filter was found
    * @throws Exception
    */
   public boolean matches(String url, String query, String reqHost, String refHost, String accept) throws Exception
   {
+    if (!filteringEnabled)
+      return false;
+
     Callable<Boolean> callable = new MatchesCallable(url, query, reqHost, refHost, accept);
     Future<Boolean> future = js.submit(callable);
     boolean matches = future.get().booleanValue();
     sendBroadcast(new Intent(BROADCAST_FILTER_MATCHES).putExtra("url", url).putExtra("matches", matches));
     return matches;
   }
 
   /**
+   * Checks if filtering is enabled.
+   */
+  public boolean isFilteringEnabled()
+  {
+    return filteringEnabled;
+  }
+
+  /**
+   * Enables or disables filtering.
+   */
+  public void setFilteringEnabled(boolean enable)
+  {
+    filteringEnabled = enable;
+    sendBroadcast(new Intent(BROADCAST_FILTERING_CHANGE).putExtra("enabled", filteringEnabled));
+  }
+  
+  /**
    * Notifies JS code that application entered interactive mode.
    */
   public void startInteractive()
   {
     js.execute(new Runnable()
     {
       @Override
       public void run()
       {
         js.evaluate("startInteractive()");
@@ skipping 66 matching lines @@
   /**
    * Stops JS engine.
    * 
    * @param implicitly
    *          stop even in interactive mode
    */
   public void stopEngine(boolean implicitly)
   {
     if ((implicitly || !interactive) && js != null)
     {
+      Log.i(TAG, "stopEngine");
       js.stopEngine();
       try
       {
         js.join();
       }
       catch (InterruptedException e)
       {
         Log.e(TAG, e.getMessage(), e);
       }
+      Log.i(TAG, "Engine stopped");
       js = null;
     }
   }
 
   /**
    * Sets Alarm to call updater after specified number of minutes or after one
    * day if
    * minutes are set to 0.
    * 
    * @param minutes
@@ skipping 269 matching lines @@
       jsEngine.callback(callback, params);
     }
 
     public final void stopEngine()
     {
       run = false;
       synchronized (queue)
       {
         queue.notify();
       }
+      System.gc();

[Felix Dahlke, 2013/03/11 06:57:38]

I think we shouldn't do this, won't help us work around the memory issue (will
explain that later).

[Andrey Novikov, 2013/03/11 07:32:55]

Done.

     }
 
     public void execute(Runnable r)
     {
       synchronized (queue)
       {
         queue.addLast(r);
         queue.notify();
       }
     }
@@ skipping 212 matching lines @@
       }
       return result;
     }
 
     protected void onProgressUpdate(Integer... progress)
     {
       Log.d("HTTP", "Progress: " + progress[0].intValue());
     }
   }
 }