Issue 6265 - Create shared AdblockEngine instance in AdblockWebView in background

libadblockplus-android-settings/src/org/adblockplus/libadblockplus/android/settings/AdblockHelper.java

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-present 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
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with Adblock Plus.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package org.adblockplus.libadblockplus.android.settings;
 
 import android.content.Context;
 import android.content.SharedPreferences;
 import android.util.Log;
 
+import org.adblockplus.libadblockplus.android.AdblockEngine;
 import org.adblockplus.libadblockplus.android.AdblockEngineProvider;
-import org.adblockplus.libadblockplus.android.SingletonEngineProvider;
+import org.adblockplus.libadblockplus.android.SingleInstanceEngineProvider;
 import org.adblockplus.libadblockplus.android.Utils;
 
 /**
  * AdblockHelper shared resources
  * (singleton)
  */
 public class AdblockHelper
 {
   private static final String TAG = Utils.getTag(AdblockHelper.class);
 
   /**
    * Suggested preference name to store settings
    */
   public static final String PREFERENCE_NAME = "ADBLOCK";
 
   /**
    * Suggested preference name to store intercepted subscription requests
    */
   public static final String PRELOAD_PREFERENCE_NAME = "ADBLOCK_PRELOAD";
   private static AdblockHelper _instance;
 
-  private SingletonEngineProvider adblockEngineProvider;
+  private SingleInstanceEngineProvider provider;
   private AdblockSettingsStorage storage;
-  private Runnable engineCreatedCallback = new Runnable()
+
+  private final Runnable engineCreatedCallback = new Runnable()
   {
     @Override
     public void run()
     {
       AdblockSettings settings = storage.load();
       if (settings != null)
       {
         Log.d(TAG, "Applying saved adblock settings to adblock engine");
-        // apply last saved settings to adblock engine
-
+        // apply last saved settings to adblock engine.
         // all the settings except `enabled` and whitelisted domains list
         // are saved by adblock engine itself
-        adblockEngineProvider.getAdblockEngine().setEnabled(settings.isAdblockEnabled());
-        adblockEngineProvider.getAdblockEngine().setWhitelistedDomains(settings.getWhitelistedDomains());
+        provider.getEngine().setEnabled(settings.isAdblockEnabled());
+        provider.getEngine().setWhitelistedDomains(settings.getWhitelistedDomains());
 
         // allowed connection type is saved by filter engine but we need to override it
         // as filter engine can be not created when changing
         String connectionType = (settings.getAllowedConnectionType() != null
           ? settings.getAllowedConnectionType().getValue()
           : null);
-        adblockEngineProvider.getAdblockEngine().getFilterEngine().setAllowedConnectionType(connectionType);
+        provider.getEngine().getFilterEngine().setAllowedConnectionType(connectionType);
       }
       else
       {
         Log.w(TAG, "No saved adblock settings");
       }
     }
   };
 
-  private Runnable engineDisposedCallback = new Runnable()
+  private final Runnable engineDisposedCallback = new Runnable()
   {
     @Override
     public void run()
     {
-      Log.d(TAG, "Releasing adblock settings");
+      Log.d(TAG, "Releasing adblock settings storage");
       storage = null;
     }
   };
 
   // singleton
   protected AdblockHelper()
   {
     // prevents instantiation
   }
 
   /**
    * Use to get AdblockHelper instance
    * @return adblock instance
    */
   public static synchronized AdblockHelper get()
   {
     if (_instance == null)
     {
       _instance = new AdblockHelper();
     }
 
     return _instance;
   }
 
-  public AdblockEngineProvider getAdblockEngineProvider()
+  public AdblockEngineProvider getProvider()
   {
-    return adblockEngineProvider;
+    if (provider == null)
+    {
+      throw new IllegalStateException("Usage exception: call init(...) first");
+    }
+    return provider;
   }
 
   public AdblockSettingsStorage getStorage()
   {
+    if (storage == null)
+    {
+      throw new IllegalStateException("Usage exception: call init(...) first");
+    }
     return storage;
   }
 
   /**
    * Init with context
    * @param context application context
    * @param basePath file system root to store files
    *
    *                 Adblock Plus library will download subscription files and store them on
    *                 the path passed. The path should exist and the directory content should not be
    *                 cleared out occasionally. Using `context.getCacheDir().getAbsolutePath()` is not
    *                 recommended because it can be cleared by the system.
    * @param developmentBuild debug or release?
    * @param preferenceName Shared Preferences name to store adblock settings
    */
-  public SingletonEngineProvider init(Context context, String basePath,
-                                      boolean developmentBuild, String preferenceName)
+  public SingleInstanceEngineProvider init(Context context, String basePath,
+                                           boolean developmentBuild, String preferenceName)
   {
     initProvider(context, basePath, developmentBuild);
     initStorage(context, preferenceName);
-    return adblockEngineProvider;
+    return provider;
   }
 
   private void initProvider(Context context, String basePath, boolean developmentBuild)
   {
-    this.adblockEngineProvider = new SingletonEngineProvider(context, basePath, developmentBuild);
-    this.adblockEngineProvider.setEngineCreatedCallback(engineCreatedCallback);
-    this.adblockEngineProvider.setEngineDisposedCallback(engineDisposedCallback);
+    provider = new SingleInstanceEngineProvider(context, basePath, developmentBuild);
+    provider.setEngineCreatedCallback(engineCreatedCallback);
+    provider.setEngineDisposedCallback(engineDisposedCallback);
   }
 
   private void initStorage(Context context, String settingsPreferenceName)
   {
     // read and apply current settings
     SharedPreferences settingsPrefs = context.getSharedPreferences(
       settingsPreferenceName,
       Context.MODE_PRIVATE);
 
-    this.storage = new SharedPrefsStorage(settingsPrefs);
+    storage = new SharedPrefsStorage(settingsPrefs);
+  }
+
+  /**
+   * The method is deprecated: use .getProvider().retain() instead

[diegocarloslima, 2018/01/19 12:59:19]

It would be also good to add @deprecated in the javadoc:
* @deprecated The method is deprecated: use .getProvider().retain() instead

+   */
+  @Deprecated public boolean retain(boolean asynchronous)

[diegocarloslima, 2018/01/19 12:59:19]

I would prefer this annotation as it was before, above the method declaration (I
don't think we have a specific code style for that, so we should stick with the
one used by Google):
@Deprecated
public boolean retain(boolean asynchronous)

+  {
+    return provider.retain(asynchronous);
+  }
+
+  /**
+   * The method is deprecated: use .getProvider().waitForReady() instead
+   */
+  @Deprecated public void waitForReady()
+  {
+    provider.waitForReady();
+  }
+
+  /**
+   * The method is deprecated: use .getProvider().getEngine() instead
+   */
+  @Deprecated public AdblockEngine getEngine()
+  {
+    return provider.getEngine();
+  }
+
+  /**
+   * The method is deprecated: use .getProvider().release() instead
+   */
+  @Deprecated public boolean release()
+  {
+    return provider.release();
+  }
+
+  /**
+   * The method is deprecated: use .getProvider().getCounter() instead
+   */
+  @Deprecated public int getCounter()
+  {
+    return provider.getCounter();
   }
 }