Add directory refreshing at 24hr intervals.

src/org/thoughtcrime/securesms/service/DirectoryRefreshListener.java

@@ -0,0 +1,60 @@
+package org.thoughtcrime.securesms.service;
+
+
+import android.app.AlarmManager;
+import android.app.PendingIntent;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.util.Log;
+
+import org.thoughtcrime.securesms.util.TextSecurePreferences;
+
+public class DirectoryRefreshListener extends BroadcastReceiver {
+
+  private static final String REFRESH_EVENT = "org.whispersystems.whisperpush.DIRECTORY_REFRESH";
+  private static final String BOOT_EVENT    = "android.intent.action.BOOT_COMPLETED";
+
+  private static final long   INTERVAL      = 24 * 60 * 60 * 1000; // 24 hours.
+
+  @Override
+  public void onReceive(Context context, Intent intent) {
+    if      (REFRESH_EVENT.equals(intent.getAction())) handleRefreshAction(context);
+    else if (BOOT_EVENT.equals(intent.getAction()))    handleBootEvent(context);
+  }
+
+  private void handleBootEvent(Context context) {
+    schedule(context);
+  }
+
+  private void handleRefreshAction(Context context) {
+    schedule(context);
+  }
+
+  public static void schedule(Context context) {
+    if (!TextSecurePreferences.isPushRegistered(context)) return;
+
+    AlarmManager      alarmManager  = (AlarmManager)context.getSystemService(Context.ALARM_SERVICE);
+    Intent            intent        = new Intent(DirectoryRefreshListener.REFRESH_EVENT);
+    PendingIntent     pendingIntent = PendingIntent.getBroadcast(context, 0, intent, 0);
+    long              time          = TextSecurePreferences.getDirectoryRefreshTime(context);
+
+    if (time <= System.currentTimeMillis()) {
+      if (time != 0) {
+        Intent serviceIntent = new Intent(context, DirectoryRefreshService.class);
+        serviceIntent.setAction(DirectoryRefreshService.REFRESH_ACTION);
+        context.startService(serviceIntent);
+      }
+
+      time = System.currentTimeMillis() + INTERVAL;
+    }
+
+    Log.w("DirectoryRefreshListener", "Scheduling for: " + time);
+
+    alarmManager.cancel(pendingIntent);
+    alarmManager.set(AlarmManager.RTC_WAKEUP, time, pendingIntent);
+
+    TextSecurePreferences.setDirectoryRefreshTime(context, time);
+  }
+
+}

src/org/thoughtcrime/securesms/service/DirectoryRefreshService.java

@@ -0,0 +1,79 @@
+package org.thoughtcrime.securesms.service;
+
+
+import android.app.Service;
+import android.content.Context;
+import android.content.Intent;
+import android.os.IBinder;
+import android.os.PowerManager;
+import android.util.Log;
+
+import org.thoughtcrime.securesms.util.TextSecurePreferences;
+import org.whispersystems.textsecure.directory.Directory;
+import org.whispersystems.textsecure.push.PushServiceSocket;
+
+import java.util.List;
+import java.util.Set;
+import java.util.concurrent.Executor;
+import java.util.concurrent.Executors;
+
+public class DirectoryRefreshService extends Service {
+
+  public  static final String REFRESH_ACTION = "org.whispersystems.whisperpush.REFRESH_ACTION";
+
+  private static final Executor executor = Executors.newSingleThreadExecutor();
+
+  @Override
+  public int onStartCommand (Intent intent, int flags, int startId) {
+    if (REFRESH_ACTION.equals(intent.getAction())) {
+      handleRefreshAction();
+    }
+    return START_NOT_STICKY;
+  }
+
+  @Override
+  public IBinder onBind(Intent intent) {
+    return null;
+  }
+
+  private void handleRefreshAction() {
+    PowerManager pm = (PowerManager) getSystemService(Context.POWER_SERVICE);
+    PowerManager.WakeLock wakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "Directory Refresh");
+    wakeLock.acquire();
+
+    executor.execute(new RefreshRunnable(wakeLock));
+  }
+
+  private class RefreshRunnable implements Runnable {
+    private final PowerManager.WakeLock wakeLock;
+    private final Context context;
+
+    public RefreshRunnable(PowerManager.WakeLock wakeLock) {
+      this.wakeLock = wakeLock;
+      this.context  = DirectoryRefreshService.this.getApplicationContext();
+    }
+
+    public void run() {
+      try {
+        Log.w("DirectoryRefreshService", "Refreshing directory...");
+        Directory         directory   = Directory.getInstance(context);
+        String            localNumber = TextSecurePreferences.getLocalNumber(context);
+        String            password    = TextSecurePreferences.getPushServerPassword(context);
+        PushServiceSocket socket      = new PushServiceSocket(context, localNumber, password);
+
+        Set<String>  eligibleContactTokens = directory.getPushEligibleContactTokens(localNumber);
+        List<String> activeTokens          = socket.retrieveDirectory(eligibleContactTokens);
+
+        if (activeTokens != null) {
+          eligibleContactTokens.removeAll(activeTokens);
+          directory.setTokens(activeTokens, eligibleContactTokens);
+        }
+
+        Log.w("DirectoryRefreshService", "Directory refresh complete...");
+      } finally {
+        if (wakeLock != null && wakeLock.isHeld())
+          wakeLock.release();
+      }
+    }
+  }
+}

src/org/thoughtcrime/securesms/service/RegistrationService.java

@@ -289,6 +289,8 @@ public class RegistrationService extends Service {
       contactTokens.removeAll(activeTokens);
       Directory.getInstance(this).setTokens(activeTokens, contactTokens);
     }
+
+    DirectoryRefreshListener.schedule(this);
   }
 
   private synchronized String waitForChallenge() throws AccountVerificationTimeoutException {