Issue 1108 - Support notifications

src/org/adblockplus/android/ProxyService.java

 /*
  * This file is part of Adblock Plus <https://adblockplus.org/>,
  * Copyright (C) 2006-2015 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.android;
 
 import java.io.IOException;
 import java.net.InetAddress;
 import java.net.ServerSocket;
 import java.net.UnknownHostException;
 import java.util.Properties;
 
 import org.adblockplus.android.configurators.ProxyConfigurator;
 import org.adblockplus.android.configurators.ProxyConfigurators;
 import org.adblockplus.android.configurators.ProxyRegistrationType;
+import org.adblockplus.libadblockplus.Notification.Type;
 import org.apache.commons.lang.StringUtils;
 
 import sunlabs.brazil.server.Server;
 import sunlabs.brazil.util.Base64;
 import android.annotation.SuppressLint;
 import android.app.Notification;
 import android.app.NotificationManager;
 import android.app.PendingIntent;
 import android.app.Service;
 import android.content.BroadcastReceiver;
@@ skipping 578 matching lines @@
   {
     if (this.notificationWatcher != null)
     {
       this.notificationWatcher.stop();
       this.notificationWatcher = null;
     }
   }
 
   private static class NotificationWatcher implements Runnable
   {
-    public static final int DEFAULT_FIRST_POLL_INTERVAL = 3 * 60; /* seconds */
-    public static final int DEFAULT_NEXT_POLL_INTERVALS = 0; /* seconds */
+    public static final int DEFAULT_POLL_DELAY = 3 * 60; /* seconds */
+    public static final int DEFAULT_POLL_INTERVAL = 0; /* seconds */
 
     private final ProxyService proxyService;
-    private final int firstPollInterval;
-    private final int nextPollIntervals;
+    private final int pollDelay;
+    private final int pollInterval;
 
     volatile boolean running = true;
 
-    public NotificationWatcher(final ProxyService proxyService, final int firstPollInterval,
-        final int nextPollIntervals)
+    public NotificationWatcher(final ProxyService proxyService, final int pollDelay,
+        final int pollInterval)
     {
       this.proxyService = proxyService;
-      this.firstPollInterval = Math.max(0, firstPollInterval);
-      this.nextPollIntervals = Math.max(0, nextPollIntervals);
+      this.pollDelay = Math.max(0, pollDelay);
+      this.pollInterval = Math.max(0, pollInterval);
     }
 
     public NotificationWatcher(final ProxyService proxyService)
     {
-      this(proxyService, DEFAULT_FIRST_POLL_INTERVAL, DEFAULT_NEXT_POLL_INTERVALS);
+      this(proxyService, DEFAULT_POLL_DELAY, DEFAULT_POLL_INTERVAL);
     }
 
     protected void stop()
     {
       this.running = false;
     }
 
     @Override
     public void run()
     {
-      if (this.firstPollInterval == 0)
+      if (this.pollDelay == 0)
       {
         this.running = false;
         return;
       }
 
-      long nextPoll = System.currentTimeMillis() + 1000L * this.firstPollInterval;
+      long nextPoll = System.currentTimeMillis() + 1000L * this.pollDelay;
 
       while (this.running)
       {
         try
         {
           Thread.sleep(250);
         }
         catch (InterruptedException ex)
         {
           break;
         }
 
         if (System.currentTimeMillis() >= nextPoll && this.running)
         {
           try
           {
             Log.d(TAG, "Polling for notifications");
-            org.adblockplus.libadblockplus.Notification notification = AdblockPlus.getApplication()
-                .getNextNotificationToShow();
-
-            int idx = 0;
-            while (notification != null)
+            org.adblockplus.libadblockplus.Notification notification =
+                AdblockPlus.getApplication().getNextNotificationToShow();
+
+            while (notification != null
+                && (notification.getType() == Type.INVALID || notification.getType() == Type.QUESTION))
             {
-              Notification notif = new NotificationCompat.Builder(
-                  this.proxyService.getApplicationContext())
-                  .setSmallIcon(R.drawable.ic_stat_blocking)
-                  .setContentTitle(notification.getTitle())
-                  .setContentText(notification.getMessageString())
-                  .getNotification();
-
+              notification = AdblockPlus.getApplication().getNextNotificationToShow();
+            }
+
+            if (notification != null)
+            {
               final NotificationManager notificationManager = (NotificationManager) this.proxyService
                   .getSystemService(NOTIFICATION_SERVICE);
-              notificationManager.notify(AdblockPlus.GROUPED_NOTIFICATION_ID + idx, notif);
-
-              notification.markAsShown();
-
-              idx++;
-              notification = AdblockPlus.getApplication().getNextNotificationToShow();
+
+              notificationManager.notify(AdblockPlus.SERVER_NOTIFICATION_ID,
+                  new NotificationCompat.Builder(this.proxyService.getApplicationContext())
+                      .setSmallIcon(R.drawable.ic_stat_blocking)
+                      .setContentTitle(notification.getTitle())
+                      .setContentText(notification.getMessageString())
+                      .getNotification());
             }
-
-            Log.d(TAG, "Received " + idx + " new notifications");
           }
           catch (Exception ex)
           {
             Log.e(TAG, "Polling for notifications failed: " + ex.getMessage(), ex);
           }
 
-          if (this.nextPollIntervals == 0)
+          if (this.pollInterval == 0)
           {
             this.running = false;
           }
           else
           {
-            nextPoll = System.currentTimeMillis() + 1000L * this.nextPollIntervals;
+            nextPoll = System.currentTimeMillis() + 1000L * this.pollInterval;
           }
         }
       }
     }
   }
 }