com/android/systemui/statusbar/phone/NavigationModeController.java - platform/prebuilts/fullsdk/sources/android-29 - Git at Google

 /*
  * Copyright (C) 2019 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.systemui.statusbar.phone;

 import static android.content.Intent.ACTION_OVERLAY_CHANGED;
 import static android.content.Intent.ACTION_PREFERRED_ACTIVITY_CHANGED;
 import static android.os.UserHandle.USER_CURRENT;
 import static android.view.WindowManagerPolicyConstants.NAV_BAR_MODE_3BUTTON;
 import static android.view.WindowManagerPolicyConstants.NAV_BAR_MODE_3BUTTON_OVERLAY;
 import static android.view.WindowManagerPolicyConstants.NAV_BAR_MODE_GESTURAL;
 import static android.view.WindowManagerPolicyConstants.NAV_BAR_MODE_GESTURAL_OVERLAY;

 import android.app.Notification;
 import android.app.NotificationManager;
 import android.app.PendingIntent;
 import android.content.BroadcastReceiver;
 import android.content.ComponentName;
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
 import android.content.om.IOverlayManager;
 import android.content.pm.ApplicationInfo;
 import android.content.pm.PackageManager;
 import android.content.res.ApkAssets;
 import android.os.PatternMatcher;
 import android.os.RemoteException;
 import android.os.ServiceManager;
 import android.os.UserHandle;
 import android.provider.Settings;
 import android.provider.Settings.Secure;
 import android.text.TextUtils;
 import android.util.Log;
 import android.util.SparseBooleanArray;

 import com.android.systemui.Dumpable;
 import com.android.systemui.R;
 import com.android.systemui.UiOffloadThread;
 import com.android.systemui.shared.system.ActivityManagerWrapper;
 import com.android.systemui.statusbar.policy.DeviceProvisionedController;
 import com.android.systemui.util.NotificationChannels;

 import java.io.FileDescriptor;
 import java.io.PrintWriter;
 import java.util.ArrayList;
 import java.util.Arrays;

 import javax.inject.Inject;
 import javax.inject.Singleton;

 /**
  * Controller for tracking the current navigation bar mode.
  */
 @Singleton
 public class NavigationModeController implements Dumpable {

     private static final String TAG = NavigationModeController.class.getSimpleName();
     private static final boolean DEBUG = false;

     private static final int SYSTEM_APP_MASK =
             ApplicationInfo.FLAG_SYSTEM | ApplicationInfo.FLAG_UPDATED_SYSTEM_APP;
     static final String SHARED_PREFERENCES_NAME = "navigation_mode_controller_preferences";
     static final String PREFS_SWITCHED_FROM_GESTURE_NAV_KEY = "switched_from_gesture_nav";

     public interface ModeChangedListener {
         void onNavigationModeChanged(int mode);
     }

     private final Context mContext;
     private Context mCurrentUserContext;
     private final IOverlayManager mOverlayManager;
     private final DeviceProvisionedController mDeviceProvisionedController;
     private final UiOffloadThread mUiOffloadThread;

     private SparseBooleanArray mRestoreGesturalNavBarMode = new SparseBooleanArray();

     private int mMode = NAV_BAR_MODE_3BUTTON;
     private ArrayList<ModeChangedListener> mListeners = new ArrayList<>();

     private String mLastDefaultLauncher;

     private BroadcastReceiver mReceiver = new BroadcastReceiver() {
         @Override
         public void onReceive(Context context, Intent intent) {
             switch (intent.getAction()) {
                 case ACTION_OVERLAY_CHANGED:
                     if (DEBUG) {
                         Log.d(TAG, "ACTION_OVERLAY_CHANGED");
                     }
                     updateCurrentInteractionMode(true /* notify */);
                     break;
                 case ACTION_PREFERRED_ACTIVITY_CHANGED:
                     if (DEBUG) {
                         Log.d(TAG, "ACTION_PREFERRED_ACTIVITY_CHANGED");
                     }
                     final String launcher = getDefaultLauncherPackageName(mCurrentUserContext);
                     // Check if it is a default launcher change
                     if (!TextUtils.equals(mLastDefaultLauncher, launcher)) {
                         switchFromGestureNavModeIfNotSupportedByDefaultLauncher();
                         showNotificationIfDefaultLauncherSupportsGestureNav();
                         mLastDefaultLauncher = launcher;
                     }
                     break;
             }
         }
     };

     private final DeviceProvisionedController.DeviceProvisionedListener mDeviceProvisionedCallback =
             new DeviceProvisionedController.DeviceProvisionedListener() {
                 @Override
                 public void onDeviceProvisionedChanged() {
                     if (DEBUG) {
                         Log.d(TAG, "onDeviceProvisionedChanged: "
                                 + mDeviceProvisionedController.isDeviceProvisioned());
                     }
                     // Once the device has been provisioned, check if we can restore gestural nav
                     restoreGesturalNavOverlayIfNecessary();
                 }

                 @Override
                 public void onUserSetupChanged() {
                     if (DEBUG) {
                         Log.d(TAG, "onUserSetupChanged: "
                                 + mDeviceProvisionedController.isCurrentUserSetup());
                     }
                     // Once the user has been setup, check if we can restore gestural nav
                     restoreGesturalNavOverlayIfNecessary();
                 }

                 @Override
                 public void onUserSwitched() {
                     if (DEBUG) {
                         Log.d(TAG, "onUserSwitched: "
                                 + ActivityManagerWrapper.getInstance().getCurrentUserId());
                     }

                     // Update the nav mode for the current user
                     updateCurrentInteractionMode(true /* notify */);
                     switchFromGestureNavModeIfNotSupportedByDefaultLauncher();

                     // When switching users, defer enabling the gestural nav overlay until the user
                     // is all set up
                     deferGesturalNavOverlayIfNecessary();
                 }
             };

     @Inject
     public NavigationModeController(Context context,
             DeviceProvisionedController deviceProvisionedController,
             UiOffloadThread uiOffloadThread) {
         mContext = context;
         mCurrentUserContext = context;
         mOverlayManager = IOverlayManager.Stub.asInterface(
                 ServiceManager.getService(Context.OVERLAY_SERVICE));
         mUiOffloadThread = uiOffloadThread;
         mDeviceProvisionedController = deviceProvisionedController;
         mDeviceProvisionedController.addCallback(mDeviceProvisionedCallback);

         IntentFilter overlayFilter = new IntentFilter(ACTION_OVERLAY_CHANGED);
         overlayFilter.addDataScheme("package");
         overlayFilter.addDataSchemeSpecificPart("android", PatternMatcher.PATTERN_LITERAL);
         mContext.registerReceiverAsUser(mReceiver, UserHandle.ALL, overlayFilter, null, null);

         IntentFilter preferredActivityFilter = new IntentFilter(ACTION_PREFERRED_ACTIVITY_CHANGED);
         mContext.registerReceiverAsUser(mReceiver, UserHandle.ALL, preferredActivityFilter, null,
                 null);
         // We are only interested in launcher changes, so keeping track of the current default.
         mLastDefaultLauncher = getDefaultLauncherPackageName(mContext);

         updateCurrentInteractionMode(false /* notify */);
         switchFromGestureNavModeIfNotSupportedByDefaultLauncher();

         // Check if we need to defer enabling gestural nav
         deferGesturalNavOverlayIfNecessary();
     }

     public void updateCurrentInteractionMode(boolean notify) {
         mCurrentUserContext = getCurrentUserContext();
         int mode = getCurrentInteractionMode(mCurrentUserContext);
         mMode = mode;
         mUiOffloadThread.submit(() -> {
             Settings.Secure.putString(mCurrentUserContext.getContentResolver(),
                     Secure.NAVIGATION_MODE, String.valueOf(mode));
         });
         if (DEBUG) {
             Log.e(TAG, "updateCurrentInteractionMode: mode=" + mMode
                     + " contextUser=" + mCurrentUserContext.getUserId());
             dumpAssetPaths(mCurrentUserContext);
         }

         if (notify) {
             for (int i = 0; i < mListeners.size(); i++) {
                 mListeners.get(i).onNavigationModeChanged(mode);
             }
         }
     }

     public int addListener(ModeChangedListener listener) {
         mListeners.add(listener);
         return getCurrentInteractionMode(mCurrentUserContext);
     }

     public void removeListener(ModeChangedListener listener) {
         mListeners.remove(listener);
     }

     private int getCurrentInteractionMode(Context context) {
         int mode = context.getResources().getInteger(
                 com.android.internal.R.integer.config_navBarInteractionMode);
         if (DEBUG) {
             Log.d(TAG, "getCurrentInteractionMode: mode=" + mMode
                     + " contextUser=" + context.getUserId());
         }
         return mode;
     }

     public Context getCurrentUserContext() {
         int userId = ActivityManagerWrapper.getInstance().getCurrentUserId();
         if (DEBUG) {
             Log.d(TAG, "getCurrentUserContext: contextUser=" + mContext.getUserId()
                     + " currentUser=" + userId);
         }
         if (mContext.getUserId() == userId) {
             return mContext;
         }
         try {
             return mContext.createPackageContextAsUser(mContext.getPackageName(),
                     0 /* flags */, UserHandle.of(userId));
         } catch (PackageManager.NameNotFoundException e) {
             // Never happens for the sysui package
             return null;
         }
     }

     private void deferGesturalNavOverlayIfNecessary() {
         final int userId = mDeviceProvisionedController.getCurrentUser();
         mRestoreGesturalNavBarMode.put(userId, false);
         if (mDeviceProvisionedController.isDeviceProvisioned()
                 && mDeviceProvisionedController.isCurrentUserSetup()) {
             // User is already setup and device is provisioned, nothing to do
             if (DEBUG) {
                 Log.d(TAG, "deferGesturalNavOverlayIfNecessary: device is provisioned and user is "
                         + "setup");
             }
             return;
         }

         ArrayList<String> defaultOverlays = new ArrayList<>();
         try {
             defaultOverlays.addAll(Arrays.asList(mOverlayManager.getDefaultOverlayPackages()));
         } catch (RemoteException e) {
             Log.e(TAG, "deferGesturalNavOverlayIfNecessary: failed to fetch default overlays");
         }
         if (!defaultOverlays.contains(NAV_BAR_MODE_GESTURAL_OVERLAY)) {
             // No default gesture nav overlay
             if (DEBUG) {
                 Log.d(TAG, "deferGesturalNavOverlayIfNecessary: no default gestural overlay, "
                         + "default=" + defaultOverlays);
             }
             return;
         }

         // If the default is gestural, force-enable three button mode until the device is
         // provisioned
         setModeOverlay(NAV_BAR_MODE_3BUTTON_OVERLAY, USER_CURRENT);
         mRestoreGesturalNavBarMode.put(userId, true);
         if (DEBUG) {
             Log.d(TAG, "deferGesturalNavOverlayIfNecessary: setting to 3 button mode");
         }
     }

     private void restoreGesturalNavOverlayIfNecessary() {
         if (DEBUG) {
             Log.d(TAG, "restoreGesturalNavOverlayIfNecessary: needs restore="
                     + mRestoreGesturalNavBarMode);
         }
         final int userId = mDeviceProvisionedController.getCurrentUser();
         if (mRestoreGesturalNavBarMode.get(userId)) {
             // Restore the gestural state if necessary
             setModeOverlay(NAV_BAR_MODE_GESTURAL_OVERLAY, USER_CURRENT);
             mRestoreGesturalNavBarMode.put(userId, false);
         }
     }

     public void setModeOverlay(String overlayPkg, int userId) {
         mUiOffloadThread.submit(() -> {
             try {
                 mOverlayManager.setEnabledExclusiveInCategory(overlayPkg, userId);
                 if (DEBUG) {
                     Log.d(TAG, "setModeOverlay: overlayPackage=" + overlayPkg
                             + " userId=" + userId);
                 }
             } catch (RemoteException e) {
                 Log.e(TAG, "Failed to enable overlay " + overlayPkg + " for user " + userId);
             }
         });
     }

     private void switchFromGestureNavModeIfNotSupportedByDefaultLauncher() {
         if (getCurrentInteractionMode(mCurrentUserContext) != NAV_BAR_MODE_GESTURAL) {
             return;
         }
         final Boolean supported = isGestureNavSupportedByDefaultLauncher(mCurrentUserContext);
         if (supported == null || supported) {
             return;
         }

         Log.d(TAG, "Switching system navigation to 3-button mode:"
                 + " defaultLauncher=" + getDefaultLauncherPackageName(mCurrentUserContext)
                 + " contextUser=" + mCurrentUserContext.getUserId());

         setModeOverlay(NAV_BAR_MODE_3BUTTON_OVERLAY, USER_CURRENT);
         showNotification(mCurrentUserContext, R.string.notification_content_system_nav_changed);
         mCurrentUserContext.getSharedPreferences(SHARED_PREFERENCES_NAME, Context.MODE_PRIVATE)
                 .edit().putBoolean(PREFS_SWITCHED_FROM_GESTURE_NAV_KEY, true).apply();
     }

     private void showNotificationIfDefaultLauncherSupportsGestureNav() {
         boolean previouslySwitchedFromGestureNav = mCurrentUserContext
                 .getSharedPreferences(SHARED_PREFERENCES_NAME, Context.MODE_PRIVATE)
                 .getBoolean(PREFS_SWITCHED_FROM_GESTURE_NAV_KEY, false);
         if (!previouslySwitchedFromGestureNav) {
             return;
         }
         if (getCurrentInteractionMode(mCurrentUserContext) == NAV_BAR_MODE_GESTURAL) {
             return;
         }
         final Boolean supported = isGestureNavSupportedByDefaultLauncher(mCurrentUserContext);
         if (supported == null || !supported) {
             return;
         }

         showNotification(mCurrentUserContext, R.string.notification_content_gesture_nav_available);
         mCurrentUserContext.getSharedPreferences(SHARED_PREFERENCES_NAME, Context.MODE_PRIVATE)
                 .edit().putBoolean(PREFS_SWITCHED_FROM_GESTURE_NAV_KEY, false).apply();
     }

     /**
      * Returns null if there is no default launcher set for the current user. Returns true if the
      * current default launcher supports Gesture Navigation. Returns false otherwise.
      */
     private Boolean isGestureNavSupportedByDefaultLauncher(Context context) {
         final String defaultLauncherPackageName = getDefaultLauncherPackageName(context);
         if (DEBUG) {
             Log.d(TAG, "isGestureNavSupportedByDefaultLauncher:"
                     + " defaultLauncher=" + defaultLauncherPackageName
                     + " contextUser=" + context.getUserId());
         }
         if (defaultLauncherPackageName == null) {
             return null;
         }
         if (isSystemApp(context, defaultLauncherPackageName)) {
             return true;
         }
         return false;
     }

     private String getDefaultLauncherPackageName(Context context) {
         final ComponentName cn = context.getPackageManager().getHomeActivities(new ArrayList<>());
         if (cn == null) {
             return null;
         }
         return cn.getPackageName();
     }

     /** Returns true if the app for the given package name is a system app for this device */
     private boolean isSystemApp(Context context, String packageName) {
         try {
             ApplicationInfo ai = context.getPackageManager().getApplicationInfo(packageName,
                     PackageManager.GET_META_DATA);
             return ai != null && ((ai.flags & SYSTEM_APP_MASK) != 0);
         } catch (PackageManager.NameNotFoundException e) {
             return false;
         }
     }

     private void showNotification(Context context, int resId) {
         final CharSequence message = context.getResources().getString(resId);
         if (DEBUG) {
             Log.d(TAG, "showNotification: message=" + message);
         }

         final Notification.Builder builder =
                 new Notification.Builder(mContext, NotificationChannels.ALERTS)
                         .setContentText(message)
                         .setStyle(new Notification.BigTextStyle())
                         .setSmallIcon(R.drawable.ic_info)
                         .setAutoCancel(true)
                         .setContentIntent(PendingIntent.getActivity(context, 0, new Intent(), 0));
         context.getSystemService(NotificationManager.class).notify(TAG, 0, builder.build());
     }

     @Override
     public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
         pw.println("NavigationModeController:");
         pw.println("  mode=" + mMode);
         String defaultOverlays = "";
         try {
             defaultOverlays = String.join(", ", mOverlayManager.getDefaultOverlayPackages());
         } catch (RemoteException e) {
             defaultOverlays = "failed_to_fetch";
         }
         pw.println("  defaultOverlays=" + defaultOverlays);
         dumpAssetPaths(mCurrentUserContext);

         pw.println("  defaultLauncher=" + mLastDefaultLauncher);
         boolean previouslySwitchedFromGestureNav = mCurrentUserContext
                 .getSharedPreferences(SHARED_PREFERENCES_NAME, Context.MODE_PRIVATE)
                 .getBoolean(PREFS_SWITCHED_FROM_GESTURE_NAV_KEY, false);
         pw.println("  previouslySwitchedFromGestureNav=" + previouslySwitchedFromGestureNav);
     }

     private void dumpAssetPaths(Context context) {
         Log.d(TAG, "assetPaths=");
         ApkAssets[] assets = context.getResources().getAssets().getApkAssets();
         for (ApkAssets a : assets) {
             Log.d(TAG, "    " + a.getAssetPath());
         }
     }
 }
	/*
	* Copyright (C) 2019 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.systemui.statusbar.phone;

	import static android.content.Intent.ACTION_OVERLAY_CHANGED;
	import static android.content.Intent.ACTION_PREFERRED_ACTIVITY_CHANGED;
	import static android.os.UserHandle.USER_CURRENT;
	import static android.view.WindowManagerPolicyConstants.NAV_BAR_MODE_3BUTTON;
	import static android.view.WindowManagerPolicyConstants.NAV_BAR_MODE_3BUTTON_OVERLAY;
	import static android.view.WindowManagerPolicyConstants.NAV_BAR_MODE_GESTURAL;
	import static android.view.WindowManagerPolicyConstants.NAV_BAR_MODE_GESTURAL_OVERLAY;

	import android.app.Notification;
	import android.app.NotificationManager;
	import android.app.PendingIntent;
	import android.content.BroadcastReceiver;
	import android.content.ComponentName;
	import android.content.Context;
	import android.content.Intent;
	import android.content.IntentFilter;
	import android.content.om.IOverlayManager;
	import android.content.pm.ApplicationInfo;
	import android.content.pm.PackageManager;
	import android.content.res.ApkAssets;
	import android.os.PatternMatcher;
	import android.os.RemoteException;
	import android.os.ServiceManager;
	import android.os.UserHandle;
	import android.provider.Settings;
	import android.provider.Settings.Secure;
	import android.text.TextUtils;
	import android.util.Log;
	import android.util.SparseBooleanArray;

	import com.android.systemui.Dumpable;
	import com.android.systemui.R;
	import com.android.systemui.UiOffloadThread;
	import com.android.systemui.shared.system.ActivityManagerWrapper;
	import com.android.systemui.statusbar.policy.DeviceProvisionedController;
	import com.android.systemui.util.NotificationChannels;

	import java.io.FileDescriptor;
	import java.io.PrintWriter;
	import java.util.ArrayList;
	import java.util.Arrays;

	import javax.inject.Inject;
	import javax.inject.Singleton;

	/**
	* Controller for tracking the current navigation bar mode.
	*/
	@Singleton
	public class NavigationModeController implements Dumpable {

	private static final String TAG = NavigationModeController.class.getSimpleName();
	private static final boolean DEBUG = false;

	private static final int SYSTEM_APP_MASK =
	ApplicationInfo.FLAG_SYSTEM \| ApplicationInfo.FLAG_UPDATED_SYSTEM_APP;
	static final String SHARED_PREFERENCES_NAME = "navigation_mode_controller_preferences";
	static final String PREFS_SWITCHED_FROM_GESTURE_NAV_KEY = "switched_from_gesture_nav";

	public interface ModeChangedListener {
	void onNavigationModeChanged(int mode);
	}

	private final Context mContext;
	private Context mCurrentUserContext;
	private final IOverlayManager mOverlayManager;
	private final DeviceProvisionedController mDeviceProvisionedController;
	private final UiOffloadThread mUiOffloadThread;

	private SparseBooleanArray mRestoreGesturalNavBarMode = new SparseBooleanArray();

	private int mMode = NAV_BAR_MODE_3BUTTON;
	private ArrayList<ModeChangedListener> mListeners = new ArrayList<>();

	private String mLastDefaultLauncher;

	private BroadcastReceiver mReceiver = new BroadcastReceiver() {
	@Override
	public void onReceive(Context context, Intent intent) {
	switch (intent.getAction()) {
	case ACTION_OVERLAY_CHANGED:
	if (DEBUG) {
	Log.d(TAG, "ACTION_OVERLAY_CHANGED");
	}
	updateCurrentInteractionMode(true /* notify */);
	break;
	case ACTION_PREFERRED_ACTIVITY_CHANGED:
	if (DEBUG) {
	Log.d(TAG, "ACTION_PREFERRED_ACTIVITY_CHANGED");
	}
	final String launcher = getDefaultLauncherPackageName(mCurrentUserContext);
	// Check if it is a default launcher change
	if (!TextUtils.equals(mLastDefaultLauncher, launcher)) {
	switchFromGestureNavModeIfNotSupportedByDefaultLauncher();
	showNotificationIfDefaultLauncherSupportsGestureNav();
	mLastDefaultLauncher = launcher;
	}
	break;
	}
	}
	};

	private final DeviceProvisionedController.DeviceProvisionedListener mDeviceProvisionedCallback =
	new DeviceProvisionedController.DeviceProvisionedListener() {
	@Override
	public void onDeviceProvisionedChanged() {
	if (DEBUG) {
	Log.d(TAG, "onDeviceProvisionedChanged: "
	+ mDeviceProvisionedController.isDeviceProvisioned());
	}
	// Once the device has been provisioned, check if we can restore gestural nav
	restoreGesturalNavOverlayIfNecessary();
	}

	@Override
	public void onUserSetupChanged() {
	if (DEBUG) {
	Log.d(TAG, "onUserSetupChanged: "
	+ mDeviceProvisionedController.isCurrentUserSetup());
	}
	// Once the user has been setup, check if we can restore gestural nav
	restoreGesturalNavOverlayIfNecessary();
	}

	@Override
	public void onUserSwitched() {
	if (DEBUG) {
	Log.d(TAG, "onUserSwitched: "
	+ ActivityManagerWrapper.getInstance().getCurrentUserId());
	}

	// Update the nav mode for the current user
	updateCurrentInteractionMode(true /* notify */);
	switchFromGestureNavModeIfNotSupportedByDefaultLauncher();

	// When switching users, defer enabling the gestural nav overlay until the user
	// is all set up
	deferGesturalNavOverlayIfNecessary();
	}
	};

	@Inject
	public NavigationModeController(Context context,
	DeviceProvisionedController deviceProvisionedController,
	UiOffloadThread uiOffloadThread) {
	mContext = context;
	mCurrentUserContext = context;
	mOverlayManager = IOverlayManager.Stub.asInterface(
	ServiceManager.getService(Context.OVERLAY_SERVICE));
	mUiOffloadThread = uiOffloadThread;
	mDeviceProvisionedController = deviceProvisionedController;
	mDeviceProvisionedController.addCallback(mDeviceProvisionedCallback);

	IntentFilter overlayFilter = new IntentFilter(ACTION_OVERLAY_CHANGED);
	overlayFilter.addDataScheme("package");
	overlayFilter.addDataSchemeSpecificPart("android", PatternMatcher.PATTERN_LITERAL);
	mContext.registerReceiverAsUser(mReceiver, UserHandle.ALL, overlayFilter, null, null);

	IntentFilter preferredActivityFilter = new IntentFilter(ACTION_PREFERRED_ACTIVITY_CHANGED);
	mContext.registerReceiverAsUser(mReceiver, UserHandle.ALL, preferredActivityFilter, null,
	null);
	// We are only interested in launcher changes, so keeping track of the current default.
	mLastDefaultLauncher = getDefaultLauncherPackageName(mContext);

	updateCurrentInteractionMode(false /* notify */);
	switchFromGestureNavModeIfNotSupportedByDefaultLauncher();

	// Check if we need to defer enabling gestural nav
	deferGesturalNavOverlayIfNecessary();
	}

	public void updateCurrentInteractionMode(boolean notify) {
	mCurrentUserContext = getCurrentUserContext();
	int mode = getCurrentInteractionMode(mCurrentUserContext);
	mMode = mode;
	mUiOffloadThread.submit(() -> {
	Settings.Secure.putString(mCurrentUserContext.getContentResolver(),
	Secure.NAVIGATION_MODE, String.valueOf(mode));
	});
	if (DEBUG) {
	Log.e(TAG, "updateCurrentInteractionMode: mode=" + mMode
	+ " contextUser=" + mCurrentUserContext.getUserId());
	dumpAssetPaths(mCurrentUserContext);
	}

	if (notify) {
	for (int i = 0; i < mListeners.size(); i++) {
	mListeners.get(i).onNavigationModeChanged(mode);
	}
	}
	}

	public int addListener(ModeChangedListener listener) {
	mListeners.add(listener);
	return getCurrentInteractionMode(mCurrentUserContext);
	}

	public void removeListener(ModeChangedListener listener) {
	mListeners.remove(listener);
	}

	private int getCurrentInteractionMode(Context context) {
	int mode = context.getResources().getInteger(
	com.android.internal.R.integer.config_navBarInteractionMode);
	if (DEBUG) {
	Log.d(TAG, "getCurrentInteractionMode: mode=" + mMode
	+ " contextUser=" + context.getUserId());
	}
	return mode;
	}

	public Context getCurrentUserContext() {
	int userId = ActivityManagerWrapper.getInstance().getCurrentUserId();
	if (DEBUG) {
	Log.d(TAG, "getCurrentUserContext: contextUser=" + mContext.getUserId()
	+ " currentUser=" + userId);
	}
	if (mContext.getUserId() == userId) {
	return mContext;
	}
	try {
	return mContext.createPackageContextAsUser(mContext.getPackageName(),
	0 /* flags */, UserHandle.of(userId));
	} catch (PackageManager.NameNotFoundException e) {
	// Never happens for the sysui package
	return null;
	}
	}

	private void deferGesturalNavOverlayIfNecessary() {
	final int userId = mDeviceProvisionedController.getCurrentUser();
	mRestoreGesturalNavBarMode.put(userId, false);
	if (mDeviceProvisionedController.isDeviceProvisioned()
	&& mDeviceProvisionedController.isCurrentUserSetup()) {
	// User is already setup and device is provisioned, nothing to do
	if (DEBUG) {
	Log.d(TAG, "deferGesturalNavOverlayIfNecessary: device is provisioned and user is "
	+ "setup");
	}
	return;
	}

	ArrayList<String> defaultOverlays = new ArrayList<>();
	try {
	defaultOverlays.addAll(Arrays.asList(mOverlayManager.getDefaultOverlayPackages()));
	} catch (RemoteException e) {
	Log.e(TAG, "deferGesturalNavOverlayIfNecessary: failed to fetch default overlays");
	}
	if (!defaultOverlays.contains(NAV_BAR_MODE_GESTURAL_OVERLAY)) {
	// No default gesture nav overlay
	if (DEBUG) {
	Log.d(TAG, "deferGesturalNavOverlayIfNecessary: no default gestural overlay, "
	+ "default=" + defaultOverlays);
	}
	return;
	}

	// If the default is gestural, force-enable three button mode until the device is
	// provisioned
	setModeOverlay(NAV_BAR_MODE_3BUTTON_OVERLAY, USER_CURRENT);
	mRestoreGesturalNavBarMode.put(userId, true);
	if (DEBUG) {
	Log.d(TAG, "deferGesturalNavOverlayIfNecessary: setting to 3 button mode");
	}
	}

	private void restoreGesturalNavOverlayIfNecessary() {
	if (DEBUG) {
	Log.d(TAG, "restoreGesturalNavOverlayIfNecessary: needs restore="
	+ mRestoreGesturalNavBarMode);
	}
	final int userId = mDeviceProvisionedController.getCurrentUser();
	if (mRestoreGesturalNavBarMode.get(userId)) {
	// Restore the gestural state if necessary
	setModeOverlay(NAV_BAR_MODE_GESTURAL_OVERLAY, USER_CURRENT);
	mRestoreGesturalNavBarMode.put(userId, false);
	}
	}

	public void setModeOverlay(String overlayPkg, int userId) {
	mUiOffloadThread.submit(() -> {
	try {
	mOverlayManager.setEnabledExclusiveInCategory(overlayPkg, userId);
	if (DEBUG) {
	Log.d(TAG, "setModeOverlay: overlayPackage=" + overlayPkg
	+ " userId=" + userId);
	}
	} catch (RemoteException e) {
	Log.e(TAG, "Failed to enable overlay " + overlayPkg + " for user " + userId);
	}
	});
	}

	private void switchFromGestureNavModeIfNotSupportedByDefaultLauncher() {
	if (getCurrentInteractionMode(mCurrentUserContext) != NAV_BAR_MODE_GESTURAL) {
	return;
	}
	final Boolean supported = isGestureNavSupportedByDefaultLauncher(mCurrentUserContext);
	if (supported == null \|\| supported) {
	return;
	}

	Log.d(TAG, "Switching system navigation to 3-button mode:"
	+ " defaultLauncher=" + getDefaultLauncherPackageName(mCurrentUserContext)
	+ " contextUser=" + mCurrentUserContext.getUserId());

	setModeOverlay(NAV_BAR_MODE_3BUTTON_OVERLAY, USER_CURRENT);
	showNotification(mCurrentUserContext, R.string.notification_content_system_nav_changed);
	mCurrentUserContext.getSharedPreferences(SHARED_PREFERENCES_NAME, Context.MODE_PRIVATE)
	.edit().putBoolean(PREFS_SWITCHED_FROM_GESTURE_NAV_KEY, true).apply();
	}

	private void showNotificationIfDefaultLauncherSupportsGestureNav() {
	boolean previouslySwitchedFromGestureNav = mCurrentUserContext
	.getSharedPreferences(SHARED_PREFERENCES_NAME, Context.MODE_PRIVATE)
	.getBoolean(PREFS_SWITCHED_FROM_GESTURE_NAV_KEY, false);
	if (!previouslySwitchedFromGestureNav) {
	return;
	}
	if (getCurrentInteractionMode(mCurrentUserContext) == NAV_BAR_MODE_GESTURAL) {
	return;
	}
	final Boolean supported = isGestureNavSupportedByDefaultLauncher(mCurrentUserContext);
	if (supported == null \|\| !supported) {
	return;
	}

	showNotification(mCurrentUserContext, R.string.notification_content_gesture_nav_available);
	mCurrentUserContext.getSharedPreferences(SHARED_PREFERENCES_NAME, Context.MODE_PRIVATE)
	.edit().putBoolean(PREFS_SWITCHED_FROM_GESTURE_NAV_KEY, false).apply();
	}

	/**
	* Returns null if there is no default launcher set for the current user. Returns true if the
	* current default launcher supports Gesture Navigation. Returns false otherwise.
	*/
	private Boolean isGestureNavSupportedByDefaultLauncher(Context context) {
	final String defaultLauncherPackageName = getDefaultLauncherPackageName(context);
	if (DEBUG) {
	Log.d(TAG, "isGestureNavSupportedByDefaultLauncher:"
	+ " defaultLauncher=" + defaultLauncherPackageName
	+ " contextUser=" + context.getUserId());
	}
	if (defaultLauncherPackageName == null) {
	return null;
	}
	if (isSystemApp(context, defaultLauncherPackageName)) {
	return true;
	}
	return false;
	}

	private String getDefaultLauncherPackageName(Context context) {
	final ComponentName cn = context.getPackageManager().getHomeActivities(new ArrayList<>());
	if (cn == null) {
	return null;
	}
	return cn.getPackageName();
	}

	/** Returns true if the app for the given package name is a system app for this device */
	private boolean isSystemApp(Context context, String packageName) {
	try {
	ApplicationInfo ai = context.getPackageManager().getApplicationInfo(packageName,
	PackageManager.GET_META_DATA);
	return ai != null && ((ai.flags & SYSTEM_APP_MASK) != 0);
	} catch (PackageManager.NameNotFoundException e) {
	return false;
	}
	}

	private void showNotification(Context context, int resId) {
	final CharSequence message = context.getResources().getString(resId);
	if (DEBUG) {
	Log.d(TAG, "showNotification: message=" + message);
	}

	final Notification.Builder builder =
	new Notification.Builder(mContext, NotificationChannels.ALERTS)
	.setContentText(message)
	.setStyle(new Notification.BigTextStyle())
	.setSmallIcon(R.drawable.ic_info)
	.setAutoCancel(true)
	.setContentIntent(PendingIntent.getActivity(context, 0, new Intent(), 0));
	context.getSystemService(NotificationManager.class).notify(TAG, 0, builder.build());
	}

	@Override
	public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
	pw.println("NavigationModeController:");
	pw.println(" mode=" + mMode);
	String defaultOverlays = "";
	try {
	defaultOverlays = String.join(", ", mOverlayManager.getDefaultOverlayPackages());
	} catch (RemoteException e) {
	defaultOverlays = "failed_to_fetch";
	}
	pw.println(" defaultOverlays=" + defaultOverlays);
	dumpAssetPaths(mCurrentUserContext);

	pw.println(" defaultLauncher=" + mLastDefaultLauncher);
	boolean previouslySwitchedFromGestureNav = mCurrentUserContext
	.getSharedPreferences(SHARED_PREFERENCES_NAME, Context.MODE_PRIVATE)
	.getBoolean(PREFS_SWITCHED_FROM_GESTURE_NAV_KEY, false);
	pw.println(" previouslySwitchedFromGestureNav=" + previouslySwitchedFromGestureNav);
	}

	private void dumpAssetPaths(Context context) {
	Log.d(TAG, "assetPaths=");
	ApkAssets[] assets = context.getResources().getAssets().getApkAssets();
	for (ApkAssets a : assets) {
	Log.d(TAG, " " + a.getAssetPath());
	}
	}
	}