[Role Logic Move] Add migration logic for isRoleFallbackEnabled

Migrate the isRoleFallbackEnabled preference to system server as a part
of the role logic move project. We only do the migration if it's V+. On
the system server side it will check the existing preference in
SharedPreference and migrate for all roles for the user.

API-Coverage-Bug: 314281553
Bug: 302563864
Test: RolePersistenceTest and RoleManagerTest
Change-Id: Ib24ebb8211359a652e52007fecf79a2390575e9c

3 files changed, 67 insertions, 2 deletions

diff --git a/framework-s/java/android/app/role/IRoleController.aidl b/framework-s/java/android/app/role/IRoleController.aidl
index 8a43d7fa9..948915f8d 100644
--- a/framework-s/java/android/app/role/IRoleController.aidl
+++ b/framework-s/java/android/app/role/IRoleController.aidl
@@ -40,4 +40,6 @@ oneway interface IRoleController {
             in RemoteCallback callback);
 
     void isRoleVisible(in String roleName, in RemoteCallback callback);
+
+    void getLegacyFallbackDisabledRoles(in RemoteCallback callback);
 }
diff --git a/framework-s/java/android/app/role/RoleControllerManager.java b/framework-s/java/android/app/role/RoleControllerManager.java
index 3b990b315..57da2ccd0 100644
--- a/framework-s/java/android/app/role/RoleControllerManager.java
+++ b/framework-s/java/android/app/role/RoleControllerManager.java
@@ -37,6 +37,7 @@ import com.android.internal.annotations.GuardedBy;
 import com.android.internal.infra.AndroidFuture;
 import com.android.internal.infra.ServiceConnector;
 
+import java.util.List;
 import java.util.concurrent.Executor;
 import java.util.concurrent.TimeUnit;
 import java.util.function.Consumer;
@@ -48,6 +49,12 @@ import java.util.function.Consumer;
  */
 public class RoleControllerManager {
 
+    /**
+     * Bundle key for getting legacy fallback disabled roles
+     */
+    public static final String KEY_LEGACY_FALLBACK_DISABLED_ROLES =
+            "LEGACY_FALLBACK_DISABLED_ROLES";
+
     private static final String LOG_TAG = RoleControllerManager.class.getSimpleName();
 
     private static final long REQUEST_TIMEOUT_MILLIS = 15 * 1000;
@@ -187,8 +194,7 @@ public class RoleControllerManager {
             @RoleManager.ManageHoldersFlags int flags, @NonNull RemoteCallback callback) {
         AndroidFuture<Bundle> operation = mRemoteService.postAsync(service -> {
             AndroidFuture<Bundle> future = new AndroidFuture<>();
-            service.onClearRoleHolders(roleName, flags,
-                    new RemoteCallback(future::complete));
+            service.onClearRoleHolders(roleName, flags, new RemoteCallback(future::complete));
             return future;
         });
         propagateCallback(operation, "onClearRoleHolders", callback);
@@ -227,6 +233,35 @@ public class RoleControllerManager {
         propagateCallback(operation, "isRoleVisible", executor, callback);
     }
 
+    /**
+     * @see RoleControllerService#onGrantDefaultRoles()
+     *
+     * @hide
+     */
+    public void getLegacyFallbackDisabledRoles(@NonNull @CallbackExecutor Executor executor,
+            @NonNull Consumer<List<String>> callback) {
+        mRemoteService.postAsync(service -> {
+            AndroidFuture<Bundle> future = new AndroidFuture<>();
+            service.getLegacyFallbackDisabledRoles(new RemoteCallback(future::complete));
+            return future;
+        }).orTimeout(REQUEST_TIMEOUT_MILLIS, TimeUnit.MILLISECONDS)
+                .whenComplete((res, err) -> executor.execute(() -> {
+                    final long token = Binder.clearCallingIdentity();
+                    try {
+                        if (err != null) {
+                            Log.e(LOG_TAG, "Error calling getLegacyFallbackDisabledRoles()",
+                                    err);
+                            callback.accept(null);
+                        } else {
+                            callback.accept(res.getStringArrayList(
+                                    KEY_LEGACY_FALLBACK_DISABLED_ROLES));
+                        }
+                    } finally {
+                        Binder.restoreCallingIdentity(token);
+                    }
+                }));
+    }
+
     private void propagateCallback(AndroidFuture<Bundle> operation, String opName,
             @CallbackExecutor @NonNull Executor executor,
             Consumer<Boolean> destination) {
diff --git a/framework-s/java/android/app/role/RoleControllerService.java b/framework-s/java/android/app/role/RoleControllerService.java
index cf7872913..60a13f7ba 100644
--- a/framework-s/java/android/app/role/RoleControllerService.java
+++ b/framework-s/java/android/app/role/RoleControllerService.java
@@ -17,6 +17,7 @@
 package android.app.role;
 
 import android.Manifest;
+import android.annotation.FlaggedApi;
 import android.annotation.NonNull;
 import android.annotation.Nullable;
 import android.annotation.SystemApi;
@@ -31,9 +32,12 @@ import android.os.IBinder;
 import android.os.Process;
 import android.os.RemoteCallback;
 import android.os.UserHandle;
+import android.permission.flags.Flags;
 
 import com.android.internal.util.Preconditions;
 
+import java.util.ArrayList;
+import java.util.List;
 import java.util.Objects;
 import java.util.concurrent.Executor;
 
@@ -175,6 +179,19 @@ public abstract class RoleControllerService extends Service {
                 boolean visible = onIsRoleVisible(roleName);
                 callback.sendResult(visible ? Bundle.EMPTY : null);
             }
+
+            @Override
+            public void getLegacyFallbackDisabledRoles(RemoteCallback callback) {
+                enforceCallerSystemUid("getLegacyFallbackDisabledRoles");
+
+                Objects.requireNonNull(callback, "callback cannot be null");
+
+                List<String> legacyFallbackDisabledRoles = onGetLegacyFallbackDisabledRoles();
+                Bundle result = new Bundle();
+                result.putStringArrayList(RoleControllerManager.KEY_LEGACY_FALLBACK_DISABLED_ROLES,
+                        new ArrayList<>(legacyFallbackDisabledRoles));
+                callback.sendResult(result);
+            }
         };
     }
 
@@ -301,4 +318,15 @@ public abstract class RoleControllerService extends Service {
      * @return whether the role should be visible to user
      */
     public abstract boolean onIsRoleVisible(@NonNull String roleName);
+
+    /**
+     * Get the legacy fallback disabled state.
+     *
+     * @return A list of role names with disabled fallback state.
+     */
+    @FlaggedApi(Flags.FLAG_SYSTEM_SERVER_ROLE_CONTROLLER_ENABLED)
+    @NonNull
+    public List<String> onGetLegacyFallbackDisabledRoles() {
+        throw new UnsupportedOperationException();
+    }
 }