car/occupantconnection/CarRemoteDeviceService.java

/*
 * Copyright (C) 2023 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.car.occupantconnection;

import static android.app.ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND;
import static android.car.CarOccupantZoneManager.INVALID_USER_ID;
import static android.car.CarRemoteDeviceManager.FLAG_CLIENT_INSTALLED;
import static android.car.CarRemoteDeviceManager.FLAG_CLIENT_IN_FOREGROUND;
import static android.car.CarRemoteDeviceManager.FLAG_CLIENT_RUNNING;
import static android.car.CarRemoteDeviceManager.FLAG_CLIENT_SAME_LONG_VERSION;
import static android.car.CarRemoteDeviceManager.FLAG_CLIENT_SAME_SIGNATURE;
import static android.car.CarRemoteDeviceManager.FLAG_OCCUPANT_ZONE_CONNECTION_READY;
import static android.car.CarRemoteDeviceManager.FLAG_OCCUPANT_ZONE_POWER_ON;
import static android.car.CarRemoteDeviceManager.FLAG_OCCUPANT_ZONE_SCREEN_UNLOCKED;
import static android.car.builtin.display.DisplayManagerHelper.EVENT_FLAG_DISPLAY_CHANGED;
import static android.car.user.CarUserManager.USER_LIFECYCLE_EVENT_TYPE_INVISIBLE;
import static android.car.user.CarUserManager.USER_LIFECYCLE_EVENT_TYPE_UNLOCKED;
import static android.content.pm.PackageManager.GET_SIGNING_CERTIFICATES;

import static com.android.car.CarServiceUtils.assertPermission;
import static com.android.car.CarServiceUtils.checkCalledByPackage;
import static com.android.car.internal.ExcludeFromCodeCoverageGeneratedReport.DEBUGGING_CODE;
import static com.android.car.internal.ExcludeFromCodeCoverageGeneratedReport.DUMP_INFO;
import static com.android.car.internal.util.VersionUtils.isPlatformVersionAtLeastU;

import android.annotation.IntDef;
import android.annotation.Nullable;
import android.annotation.RequiresApi;
import android.app.ActivityManager;
import android.app.ActivityManager.RunningAppProcessInfo;
import android.car.Car;
import android.car.CarOccupantZoneManager.OccupantZoneInfo;
import android.car.CarRemoteDeviceManager.AppState;
import android.car.CarRemoteDeviceManager.OccupantZoneState;
import android.car.builtin.app.ActivityManagerHelper.ProcessObserverCallback;
import android.car.builtin.display.DisplayManagerHelper;
import android.car.builtin.util.Slogf;
import android.car.occupantconnection.ICarRemoteDevice;
import android.car.occupantconnection.IStateCallback;
import android.car.user.CarUserManager;
import android.car.user.UserLifecycleEventFilter;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.hardware.display.DisplayManager.DisplayListener;
import android.os.Binder;
import android.os.Build;
import android.os.RemoteException;
import android.os.UserHandle;
import android.os.UserManager;
import android.util.ArrayMap;
import android.util.ArraySet;
import android.util.Log;
import android.util.SparseArray;

import com.android.car.CarLocalServices;
import com.android.car.CarOccupantZoneService;
import com.android.car.CarServiceBase;
import com.android.car.SystemActivityMonitoringService;
import com.android.car.internal.ExcludeFromCodeCoverageGeneratedReport;
import com.android.car.internal.util.BinderKeyValueContainer;
import com.android.car.internal.util.IndentingPrintWriter;
import com.android.car.power.CarPowerManagementService;
import com.android.car.user.CarUserService;
import com.android.internal.annotations.GuardedBy;
import com.android.internal.annotations.VisibleForTesting;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.util.Arrays;
import java.util.List;
import java.util.Set;

/**
 * Service to implement APIs defined in {@link android.car.CarRemoteDeviceManager}.
 * <p>
 * In this class, a discovering client refers to a client that has registered an {@link
 * IStateCallback}, and discovered apps refer to the peer apps of the discovering client.
 * <p>
 * This class can monitor the states of occupant zones in the car and the peer clients in
 * those occupant zones. There are 3 {@link OccupantZoneState}s:
 * <ul>
 *   <li> {@link android.car.CarRemoteDeviceManager#FLAG_OCCUPANT_ZONE_POWER_ON} is updated by the
 *        DisplayListener.
 *   <li> TODO(b/257117236): implement FLAG_OCCUPANT_ZONE_SCREEN_UNLOCKED.
 *   <li> {@link android.car.CarRemoteDeviceManager#FLAG_OCCUPANT_ZONE_CONNECTION_READY} is updated
 *        by the ICarOccupantZoneCallback.
 * </ul>
 * There are 5 {@link AppState}s:
 * <ul>
 *   <li> App install states ({@link android.car.CarRemoteDeviceManager#FLAG_CLIENT_INSTALLED},
 *        {@link android.car.CarRemoteDeviceManager#FLAG_CLIENT_SAME_LONG_VERSION},
 *        {@link android.car.CarRemoteDeviceManager#FLAG_CLIENT_SAME_SIGNATURE}) are updated by the
 *        PackageChangeReceiver.
 *   <li> App running states ({@link android.car.CarRemoteDeviceManager#FLAG_CLIENT_RUNNING},
 *        {@link android.car.CarRemoteDeviceManager#FLAG_CLIENT_IN_FOREGROUND}) are updated by the
 *        ProcessRunningStateCallback. Note: these states won't be updated for apps that share the
 *        same user ID through the "sharedUserId" mechanism.
 * </ul>
 */
public class CarRemoteDeviceService extends ICarRemoteDevice.Stub implements
        CarServiceBase {

    private static final String TAG = CarRemoteDeviceService.class.getSimpleName();
    private static final boolean DBG = Slogf.isLoggable(TAG, Log.DEBUG);
    private static final String INDENTATION_2 = "  ";
    private static final String INDENTATION_4 = "    ";

    private static final int PROCESS_NOT_RUNNING = 0;
    private static final int PROCESS_RUNNING_IN_BACKGROUND = 1;
    private static final int PROCESS_RUNNING_IN_FOREGROUND = 2;

    @IntDef(flag = false, prefix = {"PROCESS_"}, value = {
            PROCESS_NOT_RUNNING,
            PROCESS_RUNNING_IN_BACKGROUND,
            PROCESS_RUNNING_IN_FOREGROUND
    })
    @Retention(RetentionPolicy.SOURCE)
    @interface ProcessRunningState {
    }

    @VisibleForTesting
    @AppState
    static final int INITIAL_APP_STATE = 0;
    @VisibleForTesting
    @OccupantZoneState
    static final int INITIAL_OCCUPANT_ZONE_STATE = 0;

    private final Object mLock = new Object();
    private final Context mContext;
    private final CarOccupantZoneService mOccupantZoneService;
    private final CarPowerManagementService mPowerManagementService;
    private final SystemActivityMonitoringService mSystemActivityMonitoringService;
    private final ActivityManager mActivityManager;
    private final UserManager mUserManager;

    /** A map of discovering client to its callback. */
    @GuardedBy("mLock")
    private final BinderKeyValueContainer<ClientId, IStateCallback> mCallbackMap;

    /** A map of client app to its {@link AppState}. */
    @GuardedBy("mLock")
    private final ArrayMap<ClientId, Integer> mAppStateMap;

    /**
     * A map of occupant zone to its {@link OccupantZoneState}. Its keys are all the occupant
     * zones on this SoC and will never change after initialization.
     */
    @GuardedBy("mLock")
    private final ArrayMap<OccupantZoneInfo, Integer> mOccupantZoneStateMap;

    /** A map of secondary user (non-system user) ID to PerUserInfo. */
    @GuardedBy("mLock")
    private final SparseArray<PerUserInfo> mPerUserInfoMap;

    private final ProcessObserverCallback mProcessObserver = new ProcessObserver();

    private final CarUserManager.UserLifecycleListener mUserLifecycleListener = event -> {
        Slogf.v(TAG, "onEvent(%s)", event);
        handleUserChange();
    };

    private final class PackageChangeReceiver extends BroadcastReceiver {

        /** The user ID that this receiver registered as. */
        private final int mUserId;
        /** The occupant zone that the user runs in. */
        private final OccupantZoneInfo mOccupantZone;

        @VisibleForTesting
        PackageChangeReceiver(int userId, OccupantZoneInfo occupantZone) {
            super();
            this.mUserId = userId;
            this.mOccupantZone = occupantZone;
        }

        @Override
        public void onReceive(Context context, Intent intent) {
            String packageName = intent.getData().getSchemeSpecificPart();
            synchronized (mLock) {
                if (!isDiscoveringLocked(packageName)) {
                    // There is no peer client discovering this app, so ignore its install/uninstall
                    // event.
                    if (DBG) {
                        Slogf.v(TAG, "Ignore package change for %s as user %d because there is no "
                                + "peer client discovering this app", packageName, mUserId);
                    }
                    return;
                }
                ClientId clientId = new ClientId(mOccupantZone, mUserId, packageName);
                if (Intent.ACTION_PACKAGE_ADDED.equals(intent.getAction())) {
                    Slogf.v(TAG, "%s was installed", clientId);
                    @AppState int newState = calculateAppStateLocked(clientId);
                    setAppStateLocked(clientId, newState, /* callbackToNotify= */ null);
                } else if (Intent.ACTION_PACKAGE_REMOVED.equals(intent.getAction())) {
                    Slogf.v(TAG, "%s was uninstalled", clientId);
                    setAppStateLocked(clientId, INITIAL_APP_STATE, /* callbackToNotify= */ null);
                }
            }
        }
    }

    private final class ProcessObserver extends ProcessObserverCallback {
        @Override
        public void onForegroundActivitiesChanged(int pid, int uid, boolean foregroundActivities) {
            handleProcessRunningStateChange(uid, foregroundActivities
                    ? PROCESS_RUNNING_IN_FOREGROUND
                    : PROCESS_RUNNING_IN_BACKGROUND);
        }

        @Override
        public void onProcessDied(int pid, int uid) {
            handleProcessRunningStateChange(uid, PROCESS_NOT_RUNNING);
        }
    }

    /** Wrapper class for objects that are specific to a non-system user. */
    @VisibleForTesting
    static final class PerUserInfo {

        /** The occupant zone that the user runs in. */
        public final OccupantZoneInfo zone;

        /** The Context of the user. Used to register and unregister the receiver. */
        public final Context context;

        /** The PackageManager of the user. */
        public final PackageManager pm;

        /** The PackageChangeReceiver. Used to listen to package install/uninstall events. */
        public final BroadcastReceiver receiver;

        @VisibleForTesting
        PerUserInfo(OccupantZoneInfo zone, Context context, PackageManager pm,
                BroadcastReceiver receiver) {
            this.zone = zone;
            this.context = context;
            this.pm = pm;
            this.receiver = receiver;
        }
    }

    public CarRemoteDeviceService(Context context,
            CarOccupantZoneService occupantZoneService,
            CarPowerManagementService powerManagementService,
            SystemActivityMonitoringService systemActivityMonitoringService) {
        this(context, occupantZoneService, powerManagementService, systemActivityMonitoringService,
                context.getSystemService(ActivityManager.class),
                context.getSystemService(UserManager.class),
                /* perUserInfoMap= */ new SparseArray<>(),
                /* callbackMap= */ new BinderKeyValueContainer<>(),
                /* appStateMap= */ new ArrayMap<>(),
                /* occupantZoneStateMap= */ new ArrayMap<>());
    }

    @VisibleForTesting
    CarRemoteDeviceService(Context context,
            CarOccupantZoneService occupantZoneService,
            CarPowerManagementService powerManagementService,
            SystemActivityMonitoringService systemActivityMonitoringService,
            ActivityManager activityManager,
            UserManager userManager,
            SparseArray<PerUserInfo> perUserInfoMap,
            BinderKeyValueContainer<ClientId, IStateCallback> callbackMap,
            ArrayMap<ClientId, Integer> appStateMap,
            ArrayMap<OccupantZoneInfo, Integer> occupantZoneStateMap) {
        mContext = context;
        mOccupantZoneService = occupantZoneService;
        mPowerManagementService = powerManagementService;
        mSystemActivityMonitoringService = systemActivityMonitoringService;
        mActivityManager = activityManager;
        mUserManager = userManager;
        mPerUserInfoMap = perUserInfoMap;
        mCallbackMap = callbackMap;
        mAppStateMap = appStateMap;
        mOccupantZoneStateMap = occupantZoneStateMap;
    }

    @Override
    public void init() {
        if (!isPlatformVersionAtLeastU()) {
            Slogf.w(TAG, "CarRemoteDeviceService should run on Android U+");
            return;
        }
        initAllOccupantZones();
        registerUserLifecycleListener();
        initAssignedUsers();
        registerDisplayListener();
    }

    @Override
    public void release() {
        // TODO(b/257117236): implement this method.
    }

    /** Run `adb shell dumpsys car_service --services CarRemoteDeviceService` to dump. */
    @Override
    @ExcludeFromCodeCoverageGeneratedReport(reason = DUMP_INFO)
    public void dump(IndentingPrintWriter writer) {
        writer.println("*CarRemoteDeviceService*");
        synchronized (mLock) {
            writer.printf("%smCallbackMap:\n", INDENTATION_2);
            for (int i = 0; i < mCallbackMap.size(); i++) {
                ClientId discoveringClient = mCallbackMap.keyAt(i);
                IStateCallback callback = mCallbackMap.valueAt(i);
                writer.printf("%s%s, callback:%s\n", INDENTATION_4, discoveringClient, callback);
            }
            writer.printf("%smAppStateMap:\n", INDENTATION_2);
            for (int i = 0; i < mAppStateMap.size(); i++) {
                ClientId client = mAppStateMap.keyAt(i);
                @AppState int state = mAppStateMap.valueAt(i);
                writer.printf("%s%s, state:%s\n", INDENTATION_4, client, appStateToString(state));
            }
            writer.printf("%smOccupantZoneStateMap:\n", INDENTATION_2);
            for (int i = 0; i < mOccupantZoneStateMap.size(); i++) {
                OccupantZoneInfo occupantZone = mOccupantZoneStateMap.keyAt(i);
                @OccupantZoneState int state = mOccupantZoneStateMap.valueAt(i);
                writer.printf("%s%s, state:%s\n", INDENTATION_4, occupantZone,
                        occupantZoneStateToString(state));
            }
            writer.printf("%smPerUserInfoMap:\n", INDENTATION_2);
            for (int i = 0; i < mPerUserInfoMap.size(); i++) {
                int userId = mPerUserInfoMap.keyAt(i);
                PerUserInfo info = mPerUserInfoMap.valueAt(i);
                writer.printf("%suserId:%s, %s, %s, %s, %s\n", INDENTATION_4, userId, info.zone,
                        info.context, info.pm, info.receiver);
            }
        }
    }

    @Override
    public void registerStateCallback(String packageName, IStateCallback callback) {
        assertPermission(mContext, Car.PERMISSION_MANAGE_REMOTE_DEVICE);
        checkCalledByPackage(mContext, packageName);

        ClientId discoveringClient = getCallingClientId(packageName);
        synchronized (mLock) {
            assertNoDuplicateCallbackLock(discoveringClient);
            boolean firstDiscoverer = mCallbackMap.size() == 0;
            mCallbackMap.put(discoveringClient, callback);
            // Notify the discoverer of the latest states.
            updateAllOccupantZoneStateLocked(callback);
            updateAllAppStateWithPackageNameLocked(discoveringClient.packageName, callback);

            if (firstDiscoverer) {
                mSystemActivityMonitoringService.registerProcessObserverCallback(mProcessObserver);
            }
        }
    }

    @Override
    public void unregisterStateCallback(String packageName) {
        assertPermission(mContext, Car.PERMISSION_MANAGE_REMOTE_DEVICE);
        checkCalledByPackage(mContext, packageName);

        ClientId discoveringClient = getCallingClientId(packageName);
        synchronized (mLock) {
            assertHasCallbackLock(discoveringClient);
            mCallbackMap.remove(discoveringClient);
            if (mCallbackMap.size() == 0) {
                mSystemActivityMonitoringService.unregisterProcessObserverCallback(
                        mProcessObserver);
            }
            // If this discoverer is the last discoverer with the package name, remove the app state
            // of all the apps with the package name.
            if (!isDiscoveringLocked(packageName)) {
                clearAllAppStateWithPackageNameLocked(packageName);
            }
        }
    }

    @Override
    public PackageInfo getEndpointPackageInfo(int occupantZoneId, String packageName) {
        assertPermission(mContext, Car.PERMISSION_MANAGE_REMOTE_DEVICE);
        checkCalledByPackage(mContext, packageName);

        int userId = mOccupantZoneService.getUserForOccupant(occupantZoneId);
        if (userId == INVALID_USER_ID) {
            Slogf.e(TAG, "Failed to get PackageInfo of %s in occupant zone %d because it has no "
                    + "user assigned", packageName, occupantZoneId);
            return null;
        }
        return getPackageInfoAsUser(packageName, userId);
    }

    @Override
    public void setOccupantZonePower(OccupantZoneInfo occupantZone, boolean powerOn) {
        assertPermission(mContext, Car.PERMISSION_MANAGE_REMOTE_DEVICE);

        int[] displayIds = mOccupantZoneService.getAllDisplaysForOccupantZone(occupantZone.zoneId);
        for (int id : displayIds) {
            mPowerManagementService.setDisplayPowerState(id, powerOn);
        }
    }

    @Override
    public boolean isOccupantZonePowerOn(OccupantZoneInfo occupantZone) {
        assertPermission(mContext, Car.PERMISSION_MANAGE_REMOTE_DEVICE);

        return mOccupantZoneService.areDisplaysOnForOccupantZone(occupantZone.zoneId);
    }

    private void initAllOccupantZones() {
        List<OccupantZoneInfo> allOccupantZones = mOccupantZoneService.getAllOccupantZones();
        synchronized (mLock) {
            for (int i = 0; i < allOccupantZones.size(); i++) {
                OccupantZoneInfo occupantZone = allOccupantZones.get(i);
                @OccupantZoneState int initialState = calculateOccupantZoneState(occupantZone);
                Slogf.v(TAG, "The state of %s is initialized to %s", occupantZone,
                        occupantZoneStateToString(initialState));
                mOccupantZoneStateMap.put(occupantZone, initialState);
            }
        }
    }

    private void registerUserLifecycleListener() {
        CarUserService userService = CarLocalServices.getService(CarUserService.class);
        UserLifecycleEventFilter userEventFilter = new UserLifecycleEventFilter.Builder()
                // UNLOCKED event indicates the connection becomes ready, while INVISIBLE event
                // indicates the connection changes to not ready.
                .addEventType(USER_LIFECYCLE_EVENT_TYPE_UNLOCKED)
                .addEventType(USER_LIFECYCLE_EVENT_TYPE_INVISIBLE)
                .build();
        userService.addUserLifecycleListener(userEventFilter, mUserLifecycleListener);
    }

    /**
     * Handles the user change in all the occpant zones, including the driver occupant zone and
     * passenger occupant zones.
     */
    private void handleUserChange() {
        synchronized (mLock) {
            for (int i = 0; i < mOccupantZoneStateMap.size(); i++) {
                OccupantZoneInfo occupantZone = mOccupantZoneStateMap.keyAt(i);
                int oldUserId = getAssignedUserLocked(occupantZone);
                int newUserId =
                        mOccupantZoneService.getUserForOccupant(occupantZone.zoneId);
                Slogf.i(TAG, "In %s, old user was %d, new user is %d",
                        occupantZone, oldUserId, newUserId);
                boolean hasOldUser = (oldUserId != INVALID_USER_ID);
                boolean hasNewUser = isNonSystemUser(newUserId);

                if (!hasOldUser && !hasNewUser) {
                    // Still no user secondary assigned in this occupant zone, so do nothing.
                    Slogf.v(TAG, "Still no user secondary assigned in %s", occupantZone);
                    continue;
                }
                if (oldUserId == newUserId) {
                    // The user ID doesn't change in this occupant zone, but the user lifecycle
                    // might have changed, so try to update the occupant zone state.
                    handleSameUserUpdateLocked(newUserId, occupantZone);
                    continue;
                }
                if (hasOldUser && !hasNewUser) {
                    // The old user was unassigned.
                    handleUserUnassignedLocked(oldUserId, occupantZone);
                    continue;
                }
                if (!hasOldUser && hasNewUser) {
                    // The new user was assigned.
                    handleUserAssignedLocked(newUserId, occupantZone);
                    continue;
                }
                // The old user switched to a different new user.
                handleUserSwitchedLocked(oldUserId, newUserId, occupantZone);
            }
        }
    }

    @RequiresApi(Build.VERSION_CODES.UPSIDE_DOWN_CAKE)
    private void registerDisplayListener() {
        DisplayManagerHelper.registerDisplayListener(mContext, new DisplayListener() {
            @Override
            public void onDisplayAdded(int displayId) {
                // No-op.
            }

            @Override
            public void onDisplayRemoved(int displayId) {
                // No-op.
            }

            @Override
            public void onDisplayChanged(int displayId) {
                Slogf.v(TAG, "onDisplayChanged(): displayId %d", displayId);
                OccupantZoneInfo occupantZone =
                        mOccupantZoneService.getOccupantZoneForDisplayId(displayId);
                if (occupantZone == null) {
                    Slogf.i(TAG, "Display %d has no occupant zone assigned", displayId);
                    return;
                }
                synchronized (mLock) {
                    updateOccupantZoneStateLocked(occupantZone,
                            /* callbackToNotify= */null);
                }
            }
        }, /* handler= */null, EVENT_FLAG_DISPLAY_CHANGED);
    }

    private void handleProcessRunningStateChange(int uid, @ProcessRunningState int newState) {
        UserHandle userHandle = UserHandle.getUserHandleForUid(uid);
        if (userHandle.isSystem()) {
            if (DBG) {
                Slogf.v(TAG, "Skip ProcessRunningState change for process with uid %d because "
                        + "the process runs as system user", uid);
            }
            return;
        }
        synchronized (mLock) {
            String packageName = getUniquePackageNameByUidLocked(uid);
            if (packageName == null) {
                return;
            }
            if (!isDiscoveringLocked(packageName)) {
                // There is no peer client discovering this app, so ignore its running state change
                // event.
                if (DBG) {
                    Slogf.v(TAG, "Skip ProcessRunningState change for %s because there is no peer "
                            + "client discovering this app", packageName);
                }
                return;
            }
            Slogf.v(TAG, "%s 's running state changed to %s", packageName,
                    processRunningStateToString(newState));
            int userId = userHandle.getIdentifier();
            // Note: userInfo can't be null here, otherwise getUniquePackageNameByUidLocked() would
            // return null, and it wouldn't get here.
            PerUserInfo userInfo = mPerUserInfoMap.get(userId);
            ClientId clientId = new ClientId(userInfo.zone, userId, packageName);
            @AppState int newAppState =
                    convertProcessRunningStateToAppStateLocked(packageName, userId, newState);
            setAppStateLocked(clientId, newAppState, /* callbackToNotify= */ null);
        }
    }

    private void initAssignedUsers() {
        synchronized (mLock) {
            for (int i = 0; i < mOccupantZoneStateMap.size(); i++) {
                OccupantZoneInfo occupantZone = mOccupantZoneStateMap.keyAt(i);
                int userId = mOccupantZoneService.getUserForOccupant(occupantZone.zoneId);
                Slogf.v(TAG, "User ID of %s is %d ", occupantZone, userId);
                if (!isNonSystemUser(userId)) {
                    continue;
                }
                initAssignedUserLocked(userId, occupantZone);
            }
        }
    }

    /**
     * Initializes PerUserInfo for the given user, and registers a PackageChangeReceiver for the
     * given user.
     *
     * @return {@code true} if the PerUserInfo was initialized successfully
     */
    @GuardedBy("mLock")
    private boolean initAssignedUserLocked(int userId, OccupantZoneInfo occupantZone) {
        if (!isNonSystemUser(userId)) {
            Slogf.w(TAG, "%s is assigned to user %d", occupantZone, userId);
            return false;
        }
        PerUserInfo userInfo = mPerUserInfoMap.get(userId);
        if (userInfo != null && userInfo.zone.equals(occupantZone)) {
            Slogf.v(TAG, "Skip initializing PerUserInfo of user %d because it exists already",
                    userId);
            return true;
        }

        // Init PackageChangeReceiver.
        PackageChangeReceiver receiver = new PackageChangeReceiver(userId, occupantZone);
        IntentFilter filter = new IntentFilter();
        filter.addAction(Intent.ACTION_PACKAGE_ADDED);
        filter.addAction(Intent.ACTION_PACKAGE_REMOVED);
        filter.addDataScheme("package");

        // Init user Context.
        Context userContext = mContext.createContextAsUser(UserHandle.of(userId), /* flags= */ 0);
        if (userContext == null) {
            Slogf.e(TAG, "Failed to create Context as user %d", userId);
            return false;
        }
        Slogf.v(TAG, "registerReceiver() as user %d", userId);

        // Register PackageChangeReceiver.
        userContext.registerReceiver(receiver, filter);

        // Init PackageManager.
        PackageManager pm = userContext.getPackageManager();
        if (pm == null) {
            Slogf.e(TAG, "Failed to create PackageManager as user %d", userId);
            return false;
        }

        userInfo = new PerUserInfo(occupantZone, userContext, pm, receiver);
        mPerUserInfoMap.put(userId, userInfo);
        return true;
    }

    /**
     * Removes PerUserInfo of the given user, and unregisters the PackageChangeReceiver for the
     * given user. This method is called when the given {@code userId} is unassigned.
     */
    @GuardedBy("mLock")
    private void removeUnassignedUserLocked(int userId) {
        PerUserInfo userInfo = mPerUserInfoMap.get(userId);
        if (userInfo == null) {
            Slogf.v(TAG, "Skip removing PerUserInfo of user %d because it doesn't exist", userId);
            return;
        }
        Slogf.v(TAG, "unregisterReceiver() as user %d", userId);
        userInfo.context.unregisterReceiver(userInfo.receiver);

        mPerUserInfoMap.remove(userId);
    }

    @GuardedBy("mLock")
    private void handleSameUserUpdateLocked(int userId, OccupantZoneInfo occupantZone) {
        Slogf.v(TAG, "User %d lifecycle might have changed in %s", userId, occupantZone);
        updateOccupantZoneStateLocked(occupantZone, /* callbackToNotify= */ null);
    }

    @GuardedBy("mLock")
    private void handleUserUnassignedLocked(int userId, OccupantZoneInfo occupantZone) {
        Slogf.v(TAG, "User %d was unassigned in %s", userId, occupantZone);
        removeUnassignedUserLocked(userId);
        updateOccupantZoneStateLocked(occupantZone, /* callbackToNotify= */ null);
        clearAllAppStateAsUserLocked(userId);
    }

    @GuardedBy("mLock")
    private void handleUserAssignedLocked(int userId, OccupantZoneInfo occupantZone) {
        Slogf.v(TAG, "User %d was assigned in %s", userId, occupantZone);
        initAssignedUserLocked(userId, occupantZone);
        updateOccupantZoneStateLocked(occupantZone, /* callbackToNotify= */ null);
        updateAllAppStateForNewUserLocked(userId, occupantZone);
    }

    @GuardedBy("mLock")
    private void handleUserSwitchedLocked(int oldUserId, int newUserId,
            OccupantZoneInfo occupantZone) {
        Slogf.v(TAG, "User %d was switched to %d in %s", oldUserId, newUserId, occupantZone);
        removeUnassignedUserLocked(oldUserId);
        clearAllAppStateAsUserLocked(oldUserId);

        initAssignedUserLocked(newUserId, occupantZone);
        updateAllAppStateForNewUserLocked(newUserId, occupantZone);

        updateOccupantZoneStateLocked(occupantZone, /* callbackToNotify= */ null);
    }

    private ClientId getCallingClientId(String packageName) {
        UserHandle callingUserHandle = Binder.getCallingUserHandle();
        int callingUserId = callingUserHandle.getIdentifier();
        OccupantZoneInfo occupantZone =
                mOccupantZoneService.getOccupantZoneForUser(callingUserHandle);
        // Note: the occupantZone is not null because the calling user must be a valid user.
        return new ClientId(occupantZone, callingUserId, packageName);
    }

    /**
     * Updates the states of all the occupant zones, notifies the newly registered callback
     * {@code callbackToNotify} of the latest state if it is not {@code null}, and notifies other
     * callbacks of the latest state if the state has changed.
     */
    @GuardedBy("mLock")
    private void updateAllOccupantZoneStateLocked(@Nullable IStateCallback callbackToNotify) {
        for (int i = 0; i < mOccupantZoneStateMap.size(); i++) {
            OccupantZoneInfo occupantZone = mOccupantZoneStateMap.keyAt(i);
            updateOccupantZoneStateLocked(occupantZone, callbackToNotify);
        }
    }

    /**
     * Updates the state of the given occupant zone, notifies the newly registered callback
     * {@code callbackToNotify} of the latest state if it is not {@code null}, and notifies other
     * callbacks of the latest state if the state has changed.
     */
    @GuardedBy("mLock")
    private void updateOccupantZoneStateLocked(OccupantZoneInfo occupantZone,
            @Nullable IStateCallback callbackToNotify) {
        @OccupantZoneState int oldState = mOccupantZoneStateMap.get(occupantZone);
        @OccupantZoneState int newState = calculateOccupantZoneState(occupantZone);
        boolean stateChanged = (oldState != newState);
        if (!stateChanged && callbackToNotify == null) {
            Slogf.v(TAG, "Skip updateOccupantZoneStateLocked() for %s because OccupantZoneState"
                    + " stays the same and there is no newly registered callback", occupantZone);
            return;
        }
        Slogf.v(TAG, "The state of %s is changed from %s to %s", occupantZone,
                occupantZoneStateToString(oldState), occupantZoneStateToString(newState));
        mOccupantZoneStateMap.put(occupantZone, newState);

        for (int i = 0; i < mCallbackMap.size(); i++) {
            ClientId discoveringClient = mCallbackMap.keyAt(i);
            // Don't notify discovering clients that are running in this occupant zone.
            if (discoveringClient.occupantZone.equals(occupantZone)) {
                continue;
            }
            IStateCallback callback = mCallbackMap.valueAt(i);
            // If the callback is newly registered, invoke it anyway. Otherwise, invoke it only
            // when the state has changed
            if ((callback == callbackToNotify) || stateChanged) {
                try {
                    callback.onOccupantZoneStateChanged(occupantZone, newState);
                } catch (RemoteException e) {
                    Slogf.e(TAG, e, "Failed to notify %s of OccupantZoneState change",
                            discoveringClient);
                }
            }
        }
    }

    @VisibleForTesting
    @OccupantZoneState
    int calculateOccupantZoneState(OccupantZoneInfo occupantZone) {
        @OccupantZoneState int occupantZoneState = INITIAL_OCCUPANT_ZONE_STATE;
        // The three occupant zones states are independent of each other.
        if (isPowerOn(occupantZone)) {
            occupantZoneState |= FLAG_OCCUPANT_ZONE_POWER_ON;
        }
        if (isScreenUnlocked(occupantZone)) {
            occupantZoneState |= FLAG_OCCUPANT_ZONE_SCREEN_UNLOCKED;
        }
        if (isConnectionReady(occupantZone)) {
            occupantZoneState |= FLAG_OCCUPANT_ZONE_CONNECTION_READY;
        }
        return occupantZoneState;
    }

    private boolean isPowerOn(OccupantZoneInfo occupantZone) {
        return mOccupantZoneService.areDisplaysOnForOccupantZone(occupantZone.zoneId);
    }

    private boolean isScreenUnlocked(OccupantZoneInfo occupantZone) {
        // TODO(b/257117236): implement this method.
        return false;
    }

    /**
     * Returns {@code true} if the given {@code occupantZone} is ready to handle connection request.
     * Returns {@code false} otherwise.
     * <p>
     * If the {@code occupantZone} is on the same SoC as the caller occupant zone, connection ready
     * means the user is ready. If the {@code occupantZone} is on another SoC, connection ready
     * means user ready and internet connection from the caller occupant zone to the {@code
     * occupantZone} is good. User ready means the user has been allocated to the occupant zone,
     * is actively running, is unlocked, and is visible.
     */
    // TODO(b/257118327): support multi-SoC.
    boolean isConnectionReady(OccupantZoneInfo occupantZone) {
        if (!isPlatformVersionAtLeastU()) {
            Slogf.w(TAG, "CarRemoteDeviceService should run on Android U+");
            return false;
        }
        int userId = mOccupantZoneService.getUserForOccupant(occupantZone.zoneId);
        if (!isNonSystemUser(userId)) {
            return false;
        }
        UserHandle userHandle = UserHandle.of(userId);
        return mUserManager.isUserRunning(userHandle) && mUserManager.isUserUnlocked(userHandle)
                && mUserManager.getVisibleUsers().contains(userHandle);
    }

    /**
     * Updates the {@link AppState} of all the apps with the given {@code packageName}, notifies
     * the newly registered callback {@code callbackToNotify} of the latest state, and notifies
     * other callbacks of the latest state if the state has changed.
     */
    @GuardedBy("mLock")
    private void updateAllAppStateWithPackageNameLocked(String packageName,
            IStateCallback callbackToNotify) {
        for (int i = 0; i < mPerUserInfoMap.size(); i++) {
            int userId = mPerUserInfoMap.keyAt(i);
            OccupantZoneInfo occupantZone = mPerUserInfoMap.valueAt(i).zone;
            ClientId discoveredClient = new ClientId(occupantZone, userId, packageName);
            @AppState int newState = calculateAppStateLocked(discoveredClient);
            setAppStateLocked(discoveredClient, newState, callbackToNotify);
        }
    }

    /**
     * Updates the {@link AppState} of all the clients that run as {@code userId}, and notifies
     * the discoverers of the state change. This method is invoked when a new user is assigned to
     * the given occupant zone.
     */
    @GuardedBy("mLock")
    private void updateAllAppStateForNewUserLocked(int userId, OccupantZoneInfo occupantZone) {
        Set<String> updatedApps = new ArraySet<>();
        for (int i = 0; i < mCallbackMap.size(); i++) {
            ClientId discoveringClient = mCallbackMap.keyAt(i);
            // For a given package name, there might be several discoverers (peer clients that have
            // registered a callback), but we only need to update the state of the changed client
            // once.
            if (updatedApps.contains(discoveringClient.packageName)) {
                continue;
            }
            updatedApps.add(discoveringClient.packageName);

            ClientId clientId = new ClientId(occupantZone, userId, discoveringClient.packageName);
            @AppState int newAppState = calculateAppStateLocked(clientId);
            setAppStateLocked(clientId, newAppState, /* callbackToNotify= */ null);
        }
    }

    /**
     * Clears the {@link AppState} of all the apps that run as {@code userId}.
     * This method is called when the given {@code userId} is unassigned for the occupantZone,
     * for which the discoverers are already notified, so there is no need to notify the discoverers
     * in this method.
     */
    @GuardedBy("mLock")
    private void clearAllAppStateAsUserLocked(int userId) {
        for (int i = 0; i < mAppStateMap.size(); i++) {
            ClientId clientId = mAppStateMap.keyAt(i);
            if (clientId.userId == userId) {
                mAppStateMap.removeAt(i);
            }
        }
    }

    /**
     * Clears the {@link AppState} of all the apps that have the given {@code packageName}.
     * This method is called when the last discoverer with the package name is unregistered , so
     * there is no need to notify the discoverers in this method.
     */
    @GuardedBy("mLock")
    private void clearAllAppStateWithPackageNameLocked(String packageName) {
        for (int i = 0; i < mAppStateMap.size(); i++) {
            ClientId clientId = mAppStateMap.keyAt(i);
            if (clientId.packageName.equals(packageName)) {
                mAppStateMap.removeAt(i);
            }
        }
    }

    @GuardedBy("mLock")
    private PackageManager getPackageManagerAsUserLocked(int userId) {
        PerUserInfo userInfo = mPerUserInfoMap.get(userId);
        if (userInfo == null) {
            Slogf.e(TAG, "Failed to get PackageManager as user %d because the user is not"
                    + " assigned to an occupant zone yet", userId);
            return null;
        }
        return userInfo.pm;
    }

    @GuardedBy("mLock")
    private void assertNoDuplicateCallbackLock(ClientId discoveredClient) {
        if (mCallbackMap.containsKey(discoveredClient)) {
            throw new IllegalStateException("The client already registered a StateCallback: "
                    + discoveredClient);
        }
    }

    @GuardedBy("mLock")
    private void assertHasCallbackLock(ClientId discoveredClient) {
        if (!mCallbackMap.containsKey(discoveredClient)) {
            throw new IllegalStateException("The client has no StateCallback registered: "
                    + discoveredClient);
        }
    }

    /**
     * Returns {@code true} if there is a client with the {@code packageName} has registered an
     * {@link IStateCallback}.
     */
    @GuardedBy("mLock")
    private boolean isDiscoveringLocked(String packageName) {
        for (int i = 0; i < mCallbackMap.size(); i++) {
            ClientId discoveringClient = mCallbackMap.keyAt(i);
            if (discoveringClient.packageName.equals(packageName)) {
                return true;
            }
        }
        return false;
    }

    /**
     * Sets the {@link AppState} of the given client, notifies the newly registered callback
     * {@code callbackToNotify} of the latest state if it is not {@code null}, and notifies other
     * peer discoverers of the latest state if the state has changed.
     */
    @GuardedBy("mLock")
    private void setAppStateLocked(ClientId discoveredClient, @AppState int newState,
            @Nullable IStateCallback callbackToNotify) {
        Integer oldAppState = mAppStateMap.get(discoveredClient);
        boolean stateChanged = (oldAppState == null || oldAppState.intValue() != newState);
        if (!stateChanged && callbackToNotify == null) {
            Slogf.v(TAG, "Skip setAppStateLocked() because AppState stays the same and there"
                    + " is no newly registered callback");
            return;
        }
        Slogf.v(TAG, "The app state of %s is set from %s to %s", discoveredClient,
                oldAppState == null ? "null" : appStateToString(oldAppState),
                appStateToString(newState));
        mAppStateMap.put(discoveredClient, newState);

        // Notify its peer clients that are discovering.
        for (int i = 0; i < mCallbackMap.size(); i++) {
            ClientId discoveringClient = mCallbackMap.keyAt(i);
            // A peer client is a client that has the same package name but runs as another user.
            // If it is not a peer client, skip it.
            if (!discoveringClient.packageName.equals(discoveredClient.packageName)
                    || discoveringClient.userId == discoveredClient.userId) {
                continue;
            }
            IStateCallback callback = mCallbackMap.valueAt(i);
            // If the callback is newly registered, invoke it anyway. Otherwise, invoke it only
            // when the state has changed
            if (callback == callbackToNotify || stateChanged) {
                try {
                    callback.onAppStateChanged(discoveredClient.occupantZone, newState);
                } catch (RemoteException e) {
                    Slogf.e(TAG, e, "Failed to notify %d of AppState change", discoveringClient);
                }
            }
        }
    }

    @GuardedBy("mLock")
    @AppState
    private int calculateAppStateLocked(ClientId clientId) {
        @AppState int appState = INITIAL_APP_STATE;
        if (isAppInstalledAsUserLocked(clientId.packageName, clientId.userId)) {
            appState |= FLAG_CLIENT_INSTALLED;
            // In single-SoC model, the peer client is guaranteed to have the same
            // signing info and long version code.
            // TODO(b/257118327): support multiple-SoC.
            appState |= FLAG_CLIENT_SAME_LONG_VERSION | FLAG_CLIENT_SAME_SIGNATURE;

            RunningAppProcessInfo info =
                    getRunningAppProcessInfoAsUserLocked(clientId.packageName, clientId.userId);
            if (isAppRunning(info)) {
                appState |= FLAG_CLIENT_RUNNING;
                if (isAppRunningInForeground(info)) {
                    appState |= FLAG_CLIENT_IN_FOREGROUND;
                }
            }
        }
        return appState;
    }

    @GuardedBy("mLock")
    private int getAssignedUserLocked(OccupantZoneInfo occupantZone) {
        for (int i = 0; i < mPerUserInfoMap.size(); i++) {
            if (occupantZone.equals(mPerUserInfoMap.valueAt(i).zone)) {
                return mPerUserInfoMap.keyAt(i);
            }
        }
        return INVALID_USER_ID;
    }

    /**
     * This method is an unlocked version of {@link #calculateAppStateLocked} and is used for
     * testing only.
     */
    @AppState
    @VisibleForTesting
    int calculateAppState(ClientId clientId) {
        synchronized (mLock) {
            return calculateAppStateLocked(clientId);
        }
    }

    @GuardedBy("mLock")
    private boolean isAppInstalledAsUserLocked(String packageName, int userId) {
        return getPackageInfoAsUserLocked(packageName, userId, /* flags= */ 0) != null;
    }

    PackageInfo getPackageInfoAsUser(String packageName, int userId) {
        synchronized (mLock) {
            return getPackageInfoAsUserLocked(packageName, userId, GET_SIGNING_CERTIFICATES);
        }
    }

    @GuardedBy("mLock")
    private PackageInfo getPackageInfoAsUserLocked(String packageName, int userId, int flags) {
        PackageManager pm = getPackageManagerAsUserLocked(userId);
        if (pm == null) {
            return null;
        }
        try {
            return pm.getPackageInfo(packageName, PackageManager.PackageInfoFlags.of(flags));
        } catch (PackageManager.NameNotFoundException e) {
            return null;
        }
    }

    @GuardedBy("mLock")
    private RunningAppProcessInfo getRunningAppProcessInfoAsUserLocked(String packageName,
            int userId) {
        List<RunningAppProcessInfo> infos = mActivityManager.getRunningAppProcesses();
        if (infos == null) {
            return null;
        }
        for (int i = 0; i < infos.size(); i++) {
            RunningAppProcessInfo processInfo = infos.get(i);
            if (processInfo.processName.equals(packageName)) {
                UserHandle processUserHandle = UserHandle.getUserHandleForUid(processInfo.uid);
                if (processUserHandle.getIdentifier() == userId) {
                    return processInfo;
                }
            }
        }
        return null;
    }

    @GuardedBy("mLock")
    private String getUniquePackageNameByUidLocked(int uid) {
        UserHandle userHandle = UserHandle.getUserHandleForUid(uid);
        int userId = userHandle.getIdentifier();
        PerUserInfo userInfo = mPerUserInfoMap.get(userId);
        if (userInfo == null) {
            // When an occupant zone is assigned with a user, the associated PerUserInfo will be
            // initialized in the ICarOccupantZoneCallback. But the ICarOccupantZoneCallback may be
            // invoked after this method (called by ProcessObserverCallback). In that case, the
            // PerUserInfo will be null (b/277956688). So let's try to initialize the PerUserInfo
            // here.
            Slogf.v(TAG, "PerUserIno for user %d is not initialized yet", userId);
            OccupantZoneInfo occupantZone = mOccupantZoneService.getOccupantZoneForUser(userHandle);
            if (occupantZone == null) {
                // This shouldn't happen. Let's log an error.
                Slogf.e(TAG, "The running state of the process (uid %d) has changed, but the user"
                        + " %d is not assigned to any occupant zone yet", uid, userId);
                return null;
            }
            boolean success = initAssignedUserLocked(userId, occupantZone);
            if (!success) {
                Slogf.wtf(TAG, "Failed to initialize PerUserInfo for user %d in %s", userId,
                        occupantZone);
                return null;
            }
            // Note: userInfo must not be null here because it was initialized successfully.
            userInfo = mPerUserInfoMap.get(userId);
        }
        String[] packageNames = userInfo.pm.getPackagesForUid(uid);
        if (packageNames == null) {
            return null;
        }
        if (packageNames.length == 1) {
            return packageNames[0];
        }
        // packageNames.length can't be 0.
        // Multiple package names means multiple apps share the same user ID through the
        // "sharedUserId" mechanism. However, "sharedUserId" mechanism is deprecated in
        // API level 29, so let's log an error.
        Slogf.i(TAG, "Failed to get the package name by uid! Apps shouldn't use sharedUserId"
                + " because it's deprecated in API level 29: %s", Arrays.toString(packageNames));
        return null;
    }

    @GuardedBy("mLock")
    @AppState
    private int convertProcessRunningStateToAppStateLocked(String packageName, int userId,
            @ProcessRunningState int state) {
        // Note: In single-SoC model, the peer client is guaranteed to have the same
        // signing info and long version code.
        // TODO(b/257118327): support multiple-SoC.
        switch (state) {
            case PROCESS_RUNNING_IN_BACKGROUND:
                return FLAG_CLIENT_INSTALLED | FLAG_CLIENT_SAME_LONG_VERSION
                        | FLAG_CLIENT_SAME_SIGNATURE | FLAG_CLIENT_RUNNING;
            case PROCESS_RUNNING_IN_FOREGROUND:
                return FLAG_CLIENT_INSTALLED | FLAG_CLIENT_SAME_LONG_VERSION
                        | FLAG_CLIENT_SAME_SIGNATURE | FLAG_CLIENT_RUNNING
                        | FLAG_CLIENT_IN_FOREGROUND;
            case PROCESS_NOT_RUNNING:
                return isAppInstalledAsUserLocked(packageName, userId)
                        ? FLAG_CLIENT_INSTALLED | FLAG_CLIENT_SAME_LONG_VERSION
                        | FLAG_CLIENT_SAME_SIGNATURE
                        : INITIAL_APP_STATE;

        }
        throw new IllegalArgumentException("Undefined ProcessRunningState: " + state);
    }

    private static boolean isAppRunning(RunningAppProcessInfo info) {
        return info != null;
    }

    private static boolean isAppRunningInForeground(RunningAppProcessInfo info) {
        return info != null && info.importance == IMPORTANCE_FOREGROUND;
    }

    /** Returns {@code true} if the given user is a valid user and is not the system user. */
    private static boolean isNonSystemUser(int userId) {
        return userId != INVALID_USER_ID && !UserHandle.of(userId).isSystem();
    }

    @ExcludeFromCodeCoverageGeneratedReport(reason = DEBUGGING_CODE)
    private static String occupantZoneStateToString(@OccupantZoneState int state) {
        boolean powerOn = (state & FLAG_OCCUPANT_ZONE_POWER_ON) != 0;
        boolean screenUnlocked = (state & FLAG_OCCUPANT_ZONE_SCREEN_UNLOCKED) != 0;
        boolean connectionReady = (state & FLAG_OCCUPANT_ZONE_CONNECTION_READY) != 0;
        return new StringBuilder(64)
                .append("[")
                .append(powerOn ? "on, " : "off, ")
                .append(screenUnlocked ? "unlocked, " : "locked, ")
                .append(connectionReady ? "ready" : "not-ready")
                .append("]")
                .toString();

    }

    @ExcludeFromCodeCoverageGeneratedReport(reason = DEBUGGING_CODE)
    private static String appStateToString(@AppState int state) {
        boolean installed = (state & FLAG_CLIENT_INSTALLED) != 0;
        boolean sameVersion = (state & FLAG_CLIENT_SAME_LONG_VERSION) != 0;
        boolean sameSignature = (state & FLAG_CLIENT_SAME_SIGNATURE) != 0;
        boolean running = (state & FLAG_CLIENT_RUNNING) != 0;
        boolean inForeground = (state & FLAG_CLIENT_IN_FOREGROUND) != 0;
        return new StringBuilder(64)
                .append("[")
                .append(installed ? "installed, " : "not-installed, ")
                .append(sameVersion ? "same-version, " : "different-version, ")
                .append(sameSignature ? "same-signature, " : "different-signature, ")
                .append(!running
                        ? "not-running"
                        : (inForeground ? "foreground" : "background"))
                .append("]")
                .toString();
    }

    @ExcludeFromCodeCoverageGeneratedReport(reason = DEBUGGING_CODE)
    private static String processRunningStateToString(@ProcessRunningState int state) {
        switch (state) {
            case PROCESS_NOT_RUNNING:
                return "not-running";
            case PROCESS_RUNNING_IN_BACKGROUND:
                return "background";
            case PROCESS_RUNNING_IN_FOREGROUND:
                return "foreground";
            default:
                throw new IllegalArgumentException("Undefined ProcessRunningState: " + state);
        }
    }
}