1 files changed, 140 insertions, 0 deletions
diff --git a/java/com/android/dialer/blocking/BlockedNumbersAutoMigrator.java b/java/com/android/dialer/blocking/BlockedNumbersAutoMigrator.java
new file mode 100644
index 000000000..6e9fe1315
--- /dev/null
+++ b/java/com/android/dialer/blocking/BlockedNumbersAutoMigrator.java
@@ -0,0 +1,140 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.android.dialer.blocking;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+import android.preference.PreferenceManager;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.support.v4.os.UserManagerCompat;
+import com.android.dialer.blocking.FilteredNumberAsyncQueryHandler.OnHasBlockedNumbersListener;
+import com.android.dialer.common.Assert;
+import com.android.dialer.common.LogUtil;
+import com.android.dialer.common.concurrent.DialerExecutor.Worker;
+import com.android.dialer.common.concurrent.DialerExecutorFactory;
+
+/**
+ * Class responsible for checking if the user can be auto-migrated to {@link
+ * android.provider.BlockedNumberContract} blocking. In order for this to happen, the user cannot
+ * have any numbers that are blocked in the Dialer solution.
+ */
+public class BlockedNumbersAutoMigrator {
+
+  static final String HAS_CHECKED_AUTO_MIGRATE_KEY = "checkedAutoMigrate";
+
+  @NonNull private final Context appContext;
+  @NonNull private final FilteredNumberAsyncQueryHandler queryHandler;
+  @NonNull private final DialerExecutorFactory dialerExecutorFactory;
+
+  /**
+   * Constructs the BlockedNumbersAutoMigrator with the given {@link
+   * FilteredNumberAsyncQueryHandler}.
+   *
+   * @param queryHandler The FilteredNumberAsyncQueryHandler used to determine if there are blocked
+   *     numbers.
+   * @throws NullPointerException if sharedPreferences or queryHandler are null.
+   */
+  public BlockedNumbersAutoMigrator(
+      @NonNull Context appContext,
+      @NonNull FilteredNumberAsyncQueryHandler queryHandler,
+      @NonNull DialerExecutorFactory dialerExecutorFactory) {
+    this.appContext = Assert.isNotNull(appContext);
+    this.queryHandler = Assert.isNotNull(queryHandler);
+    this.dialerExecutorFactory = Assert.isNotNull(dialerExecutorFactory);
+  }
+
+  public void asyncAutoMigrate() {
+    dialerExecutorFactory
+        .createNonUiTaskBuilder(new ShouldAttemptAutoMigrate(appContext))
+        .onSuccess(this::autoMigrate)
+        .build()
+        .executeParallel(null);
+  }
+
+  /**
+   * Attempts to perform the auto-migration. Auto-migration will only be attempted once and can be
+   * performed only when the user has no blocked numbers. As a result of this method, the user will
+   * be migrated to the framework blocking solution if blocked numbers don't exist.
+   */
+  private void autoMigrate(boolean shouldAttemptAutoMigrate) {
+    if (!shouldAttemptAutoMigrate) {
+      return;
+    }
+
+    LogUtil.i("BlockedNumbersAutoMigrator", "attempting to auto-migrate.");
+    queryHandler.hasBlockedNumbers(
+        new OnHasBlockedNumbersListener() {
+          @Override
+          public void onHasBlockedNumbers(boolean hasBlockedNumbers) {
+            if (hasBlockedNumbers) {
+              LogUtil.i("BlockedNumbersAutoMigrator", "not auto-migrating: blocked numbers exist.");
+              return;
+            }
+            LogUtil.i("BlockedNumbersAutoMigrator", "auto-migrating: no blocked numbers.");
+            FilteredNumberCompat.setHasMigratedToNewBlocking(appContext, true);
+          }
+        });
+  }
+
+  private static class ShouldAttemptAutoMigrate implements Worker<Void, Boolean> {
+    private final Context appContext;
+
+    ShouldAttemptAutoMigrate(Context appContext) {
+      this.appContext = appContext;
+    }
+
+    @Nullable
+    @Override
+    public Boolean doInBackground(@Nullable Void input) {
+      if (!UserManagerCompat.isUserUnlocked(appContext)) {
+        LogUtil.i("BlockedNumbersAutoMigrator", "not attempting auto-migrate: device is locked");
+        return false;
+      }
+      SharedPreferences sharedPreferences =
+          PreferenceManager.getDefaultSharedPreferences(appContext);
+
+      if (sharedPreferences.contains(HAS_CHECKED_AUTO_MIGRATE_KEY)) {
+        LogUtil.v(
+            "BlockedNumbersAutoMigrator", "not attempting auto-migrate: already checked once.");
+        return false;
+      }
+
+      if (!FilteredNumberCompat.canAttemptBlockOperations(appContext)) {
+        // This may be the case where the user is on the lock screen, so we shouldn't record that
+        // the migration status was checked.
+        LogUtil.i(
+            "BlockedNumbersAutoMigrator", "not attempting auto-migrate: current user can't block");
+        return false;
+      }
+      LogUtil.i(
+          "BlockedNumbersAutoMigrator", "updating state as already checked for auto-migrate.");
+      sharedPreferences.edit().putBoolean(HAS_CHECKED_AUTO_MIGRATE_KEY, true).apply();
+
+      if (!FilteredNumberCompat.canUseNewFiltering()) {
+        LogUtil.i("BlockedNumbersAutoMigrator", "not attempting auto-migrate: not available.");
+        return false;
+      }
+
+      if (FilteredNumberCompat.hasMigratedToNewBlocking(appContext)) {
+        LogUtil.i("BlockedNumbersAutoMigrator", "not attempting auto-migrate: already migrated.");
+        return false;
+      }
+      return true;
+    }
+  }
+}