Issue 4769 - Supporting adding whitelisted websites on ABP for Samsung Internet

src/org/adblockplus/sbrowser/contentblocker/engine/Engine.java

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-2016 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.sbrowser.contentblocker.engine;
 
 import java.io.BufferedReader;
 import java.io.BufferedWriter;
 import java.io.File;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.OutputStreamWriter;
 import java.io.Writer;
+import java.net.URI;
+import java.net.URISyntaxException;
 import java.net.URL;
 import java.net.URLEncoder;
+import java.nio.charset.StandardCharsets;
 import java.util.ArrayList;
+import java.util.Collections;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.Set;
+import java.util.TreeSet;
 import java.util.concurrent.LinkedBlockingQueue;
 import java.util.concurrent.TimeUnit;
 import java.util.concurrent.locks.ReentrantLock;
 import java.util.regex.Pattern;
 
 import org.adblockplus.adblockplussbrowser.R;
 
 import android.content.Context;
 import android.content.Intent;
 import android.content.SharedPreferences;
@@ skipping 101 matching lines @@
     {
       return activityContext.getPackageManager()
           .queryIntentActivities(new Intent(ACTION_OPEN_SETTINGS), 0).size() > 0;
     }
     catch (final Throwable t)
     {
       return false;
     }
   }
 
-  void requestUpdateBroadcast()
+  public void requestUpdateBroadcast()
   {
     this.lock();
     try
     {
       this.nextUpdateBroadcast = System.currentTimeMillis() + BROADCAST_COMBINATION_DELAY_MILLIS;
     }
     finally
     {
       this.unlock();
     }
   }
 
-  private void sendUpdateBroadcast()
+  private void writeFileAndSendUpdateBroadcast()
   {
     createAndWriteFile();
 
     runOnUiThread(new Runnable()
     {
       @Override
       public void run()
       {
         final Intent intent = new Intent();
         intent.setAction(ACTION_UPDATE);
@@ skipping 55 matching lines @@
   {
     this.engineEvents.add(new ChangeEnabledStateEvent(id, enabled));
   }
 
   void downloadFinished(final String id, final int responseCode, final String response,
       final Map<String, String> headers)
   {
     this.engineEvents.add(new DownloadFinishedEvent(id, responseCode, response, headers));
   }
 
-  public void createAndWriteFile()
+  private void createAndWriteFile()
   {
     this.lock();
     try
     {
       Log.d(TAG, "Writing filters...");
       final File filterFile = this.subscriptions.createAndWriteFile();
+      writeWhitelistedWebsites(this.serviceContext, filterFile);
 
       final SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this.serviceContext);
       final String key = this.serviceContext.getString(R.string.key_cached_filter_path);
       prefs.edit().putString(key, filterFile.getAbsolutePath()).commit();
 
       Log.d(TAG, "Cleaning up cache...");
       final File dummyFile = getDummyFilterFile(this.serviceContext);
       final File[] cacheDirFiles = getFilterCacheDir(this.serviceContext).listFiles();
       if (cacheDirFiles != null)
       {
@@ skipping 156 matching lines @@
         }
       }
 
       Log.d(TAG, "Added " + additional + " additional default/built-in subscriptions");
       engine.subscriptions.persistSubscriptions();
     }
 
     final File cachedFilterFile = getCachedFilterFile(context);
     if (cachedFilterFile == null || !cachedFilterFile.exists())
     {
-      engine.sendUpdateBroadcast();
+      engine.writeFileAndSendUpdateBroadcast();
     }
 
     engine.handlerThread = new Thread(new EventHandler(engine));
     engine.handlerThread.setDaemon(true);
     engine.handlerThread.start();
 
     engine.downloader = Downloader.create(context, engine);
 
     return engine;
   }
@@ skipping 48 matching lines @@
     }
     return dummyFilterFile;
   }
 
   public static void writeFilterHeaders(Writer writer) throws IOException
   {
     writer.write("[Adblock Plus 2.0]\n");
     writer.write("! This file was automatically created.\n");
   }
 
+  private static void writeWhitelistedWebsites(Context context, File filterFile) throws IOException
+  {
+    Log.d(TAG, "Writing whitelisted websites...");
+    final SharedPreferences prefs =
+        PreferenceManager.getDefaultSharedPreferences(context.getApplicationContext());
+    final String key = context.getString(R.string.key_whitelisted_websites);
+
+    final Set<String> whitelistedWebsites = new TreeSet<>();
+    whitelistedWebsites.addAll(prefs.getStringSet(key, Collections.<String>emptySet()));
+
+    try (final BufferedWriter w = new BufferedWriter(
+        new OutputStreamWriter(new FileOutputStream(filterFile, true), StandardCharsets.UTF_8)))
+    {
+      for (final String url : whitelistedWebsites)
+      {
+        try
+        {
+          final URI uri = new URI(url);
+          final String host = uri.getHost() != null ? uri.getHost() : uri.getPath();
+          w.write("@@||" + host + "^$document");
+          w.write('\n');
+        }
+        catch (URISyntaxException e)
+        {
+          Log.w(TAG, "Failed to parse whitelisted website: " + url);
+          continue;
+        }
+      }
+    }
+  }
+
   private static File getCachedFilterFile(Context context)
   {
     final SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(context);
     final String cachedFilterPath = prefs.getString(context.getString(R.string.key_cached_filter_path), null);
     if (cachedFilterPath != null)
     {
       return new File(cachedFilterPath);
     }
 
     return null;
@@ skipping 112 matching lines @@
             {
               nextUpdateCheck = currentTime + UPDATE_CHECK_INTERVAL_MINUTES * MILLIS_PER_MINUTE;
 
               this.engine.subscriptions.checkForUpdates();
             }
 
             if (currentTime > this.engine.nextUpdateBroadcast)
             {
               this.engine.nextUpdateBroadcast = Long.MAX_VALUE;
               Log.d(TAG, "Sending update broadcast");
-              this.engine.sendUpdateBroadcast();
+              this.engine.writeFileAndSendUpdateBroadcast();
             }
           }
           finally
           {
             engine.unlock();
           }
         }
         catch (final InterruptedException e)
         {
           Log.d(TAG, "Handler interrupted", e);
@@ skipping 84 matching lines @@
       Log.d(TAG, headers.toString());
       this.downloader.enqueueDownload(this.createDownloadURL(sub), sub.getId(), headers);
     }
   }
 
   public void connectivityChanged()
   {
     this.downloader.connectivityChanged();
   }
 }