DirectRenderingCluster/src/android/car/cluster/ClusterRenderingService.java - platform/packages/apps/Car/Cluster - Git at Google

 /*
  * Copyright (C) 2017 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 android.car.cluster;

 import static android.content.Intent.ACTION_USER_UNLOCKED;
 import static android.content.Intent.FLAG_ACTIVITY_NEW_TASK;
 import static android.view.Display.INVALID_DISPLAY;

 import static java.lang.Integer.parseInt;

 import android.annotation.Nullable;
 import android.app.ActivityManager;
 import android.app.ActivityOptions;
 import android.car.Car;
 import android.car.CarAppFocusManager;
 import android.car.cluster.navigation.NavigationState.NavigationStateProto;
 import android.car.cluster.renderer.InstrumentClusterRenderingService;
 import android.car.cluster.renderer.NavigationRenderer;
 import android.car.navigation.CarNavigationInstrumentCluster;
 import android.content.BroadcastReceiver;
 import android.content.ComponentName;
 import android.content.Context;
 import android.content.ContextWrapper;
 import android.content.Intent;
 import android.content.IntentFilter;
 import android.content.pm.ActivityInfo;
 import android.content.pm.PackageManager;
 import android.graphics.Rect;
 import android.hardware.display.DisplayManager;
 import android.hardware.display.DisplayManager.DisplayListener;
 import android.os.Binder;
 import android.os.Bundle;
 import android.os.Handler;
 import android.os.IBinder;
 import android.os.SystemClock;
 import android.os.UserHandle;
 import android.provider.Settings;
 import android.provider.Settings.Global;
 import android.util.Log;
 import android.view.Display;
 import android.view.InputDevice;
 import android.view.KeyEvent;

 import com.android.car.internal.common.UserHelperLite;

 import com.google.protobuf.InvalidProtocolBufferException;

 import java.io.FileDescriptor;
 import java.io.PrintWriter;
 import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.List;
 import java.util.Objects;
 import java.util.function.Consumer;

 /**
  * Implementation of {@link InstrumentClusterRenderingService} which renders an activity on a
  * virtual display that is transmitted to an external screen.
  */
 public class ClusterRenderingService extends InstrumentClusterRenderingService implements
         ImageResolver.BitmapFetcher, CarAppFocusManager.OnAppFocusChangedListener {
     private static final String TAG = "Cluster.Service";

     static final String LOCAL_BINDING_ACTION = "local";
     static final String NAV_STATE_PROTO_BUNDLE_KEY = "navstate2";

     private List<ServiceClient> mClients = new ArrayList<>();
     private ClusterDisplayProvider mDisplayProvider;

     private int mClusterDisplayId = INVALID_DISPLAY;

     private boolean mInstrumentClusterHelperReady;

     private final IBinder mLocalBinder = new LocalBinder();
     private final ImageResolver mImageResolver = new ImageResolver(this);
     private final Handler mHandler = new Handler();
     private final Runnable mLaunchMainActivity = this::launchMainActivity;
     private ComponentName mNavigationClusterActivity = null;
     private int mNavigationClusterUserId = UserHandle.USER_SYSTEM;
     private CarAppFocusManager mAppFocusManager = null;

     private final UserReceiver mUserReceiver = new UserReceiver();

     public interface ServiceClient {
         void onKeyEvent(KeyEvent keyEvent);

         void onNavigationStateChange(NavigationStateProto navState);
     }

     public class LocalBinder extends Binder {
         ClusterRenderingService getService() {
             return ClusterRenderingService.this;
         }
     }

     private final DisplayListener mDisplayListener = new DisplayListener() {
         // Called in the main thread, since ClusterDisplayProvider.DisplayListener was registered
         // with null handler.
         @Override
         public void onDisplayAdded(int displayId) {
             Log.i(TAG, "Cluster display found, displayId: " + displayId);
             mClusterDisplayId = displayId;
             if (mInstrumentClusterHelperReady) {
                 mHandler.post(mLaunchMainActivity);
             }
         }

         @Override
         public void onDisplayRemoved(int displayId) {
             Log.w(TAG, "Cluster display has been removed");
         }

         @Override
         public void onDisplayChanged(int displayId) {

         }
     };

     public void setActivityLaunchOptions(int displayId, ClusterActivityState state) {
         ActivityOptions options = displayId != INVALID_DISPLAY
                 ? ActivityOptions.makeBasic().setLaunchDisplayId(displayId)
                 : null;
         setClusterActivityLaunchOptions(options);
         if (Log.isLoggable(TAG, Log.DEBUG)) {
             Log.d(TAG, String.format("activity options set: %s (displayeId: %d)",
                     options, options != null ? options.getLaunchDisplayId() : -1));
         }
         setClusterActivityState(state);
         if (Log.isLoggable(TAG, Log.DEBUG)) {
             Log.d(TAG, String.format("activity state set: %s", state));
         }
     }

     public void registerClient(ServiceClient client) {
         mClients.add(client);
     }

     public void unregisterClient(ServiceClient client) {
         mClients.remove(client);
     }

     public ImageResolver getImageResolver() {
         return mImageResolver;
     }

     @Override
     public IBinder onBind(Intent intent) {
         Log.d(TAG, "onBind, intent: " + intent);
         if (LOCAL_BINDING_ACTION.equals(intent.getAction())) {
             return mLocalBinder;
         }
         IBinder binder = super.onBind(intent);
         mInstrumentClusterHelperReady = true;
         if (mClusterDisplayId != INVALID_DISPLAY) {
             mHandler.post(mLaunchMainActivity);
         }
         return binder;
     }

     @Override
     public void onCreate() {
         super.onCreate();
         Log.d(TAG, "onCreate");
         // The following will never be null, as this service is initiated by CarService itself.
         Car car = Car.createCar(this);
         mAppFocusManager = (CarAppFocusManager) car.getCarManager(Car.APP_FOCUS_SERVICE);
         mAppFocusManager.addFocusListener(this, CarAppFocusManager.APP_FOCUS_TYPE_NAVIGATION);
         mDisplayProvider = new ClusterDisplayProvider(this, mDisplayListener);
         mUserReceiver.register(this);
         mNavigationClusterActivity = getNavigationClusterActivity();
         Log.i(TAG, "onCreate: set cluster to " + mNavigationClusterActivity);
     }

     @Override
     public void onDestroy() {
         super.onDestroy();
         mAppFocusManager.removeFocusListener(this, CarAppFocusManager.APP_FOCUS_TYPE_NAVIGATION);
         mUserReceiver.unregister(this);
         mDisplayProvider.release();
     }

     @Override
     public void onAppFocusChanged(int appType, boolean active) {
         boolean useNavigationOnly = getResources().getBoolean(R.bool.navigationOnly);
         Log.i(TAG, "onAppFocusChanged: " + appType + ", active: " + active);
         if (useNavigationOnly) {
             launchMainActivity();
         } else {
             // TODO(b/193931272): Update MainClusterActivity
         }
     }

     private void launchMainActivity() {
         mHandler.removeCallbacks(mLaunchMainActivity);
         ActivityOptions options = ActivityOptions.makeBasic();
         options.setLaunchDisplayId(mClusterDisplayId);
         boolean useNavigationOnly = getResources().getBoolean(R.bool.navigationOnly);
         Intent intent;
         int userId = UserHandle.USER_SYSTEM;
         if (useNavigationOnly) {
             userId = ActivityManager.getCurrentUser();
             if (UserHelperLite.isHeadlessSystemUser(userId)) {
                 Log.i(TAG, "Skipping the navigation activity for User 0");
                 return;
             }
             ComponentName newClusterActivity = getNavigationClusterActivity();
             if (Objects.equals(newClusterActivity, mNavigationClusterActivity)
                     && userId == mNavigationClusterUserId) {
                 Log.i(TAG, "Cluster activity hasn't changed. Skipping.");
                 return;
             }
             Log.i(TAG, "Set cluster to " + newClusterActivity);
             onNavigationComponentChanged(newClusterActivity);
             mNavigationClusterActivity = newClusterActivity;
             mNavigationClusterUserId = userId;
             intent = getNavigationActivityIntent(mNavigationClusterActivity, mClusterDisplayId);
             startFixedActivityModeForDisplayAndUser(intent, options, userId);
         } else {
             intent = getMainClusterActivityIntent();
             startActivityAsUser(intent, options.toBundle(), UserHandle.SYSTEM);
         }
         Log.i(TAG, "launching main activity=" + intent + ", display=" + mClusterDisplayId
                 + ", userId=" + userId);
     }

     /**
      * Invoked when the activity to show in the cluster changes
      *
      * @param clusterActivity current activity displayed in cluster. If no application is holding
      *                        {@link CarAppFocusManager#APP_FOCUS_TYPE_NAVIGATION}, this will be the
      *                        default map cluster activity. Otherwise, this will be the cluster
      *                        activity of the focused application (if it has one) or {@code null} if
      *                        the application doesn't have a cluster activity or the activity is
      *                        disabled.
      */
     protected void onNavigationComponentChanged(@Nullable ComponentName clusterActivity) {
         // This method can be used by OEMs to send a signal to the cluster hardware indicating
         // whether Android has or doesn't have a cluster activity.
         //
         // OEMs can use this signal to let the cluster show some other view, or to hide Android's
         // video feed altogether.
     }

     private Intent getMainClusterActivityIntent() {
         return new Intent(this, MainClusterActivity.class).setFlags(FLAG_ACTIVITY_NEW_TASK);
     }

     private ComponentName getNavigationClusterActivity() {
         List<String> focusOwnerPackageNames = mAppFocusManager.getAppTypeOwner(
                 CarAppFocusManager.APP_FOCUS_TYPE_NAVIGATION);

         if (focusOwnerPackageNames == null || focusOwnerPackageNames.isEmpty()) {
             // No application has focus. We use the default navigation app.
             Log.i(TAG, "getNavigationClusterActivity(): no focus owner -> "
                     + "using default nav app");
             ActivityInfo activityInfo = MainClusterActivity.getNavigationActivity(this);
             return new ComponentName(activityInfo.packageName, activityInfo.name);
         } else {
             ComponentName clusterActivity = getComponentFromPackages(focusOwnerPackageNames);
             if (clusterActivity == null) {
                 // If currently focused app has no cluster activity, we indicate so.
                 Log.i(TAG, "getNavigationClusterActivity(): focus owned by "
                         + focusOwnerPackageNames + " but it has no cluster activity -> "
                         + "using empty activity");
                 return null;
             }
             // Otherwise, we use the activity of the currently focused app
             Log.i(TAG, "getNavigationClusterActivity(): focus owned and it has a cluster "
                     + "activity -> using " + focusOwnerPackageNames + " app");
             return clusterActivity;
         }
     }

     private ComponentName getComponentFromPackages(List<String> packageNames) {
         for (String packageName : packageNames) {
             ComponentName result = getComponentFromPackage(packageName);
             if (result != null) {
                 return result;
             }
         }
         return null;
     }

     private Intent getNavigationActivityIntent(ComponentName component, int displayId) {
         if (component == null) {
             Log.i(TAG, "Focused application doesn't have a cluster activity. Using fallback.");
             component = new ComponentName(this, EmptyNavigationActivity.class);
         }
         Rect displaySize = new Rect(0, 0, 240, 320);  // Arbitrary size, better than nothing.
         DisplayManager dm = getSystemService(DisplayManager.class);
         Display display = dm.getDisplay(displayId);
         if (display != null) {
             display.getRectSize(displaySize);
         }
         setClusterActivityState(ClusterActivityState.create(/* visible= */ true,
                     /* unobscuredBounds= */ new Rect(0, 0, 240, 320)));
         return new Intent(Intent.ACTION_MAIN)
             .setComponent(component)
             .setFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
             .putExtra(Car.CAR_EXTRA_CLUSTER_ACTIVITY_STATE,
                 ClusterActivityState.create(/* visible= */ true,
                     /* unobscuredBounds= */ displaySize).toBundle());
     }

     @Override
     public void onKeyEvent(KeyEvent keyEvent) {
         if (Log.isLoggable(TAG, Log.DEBUG)) {
             Log.d(TAG, "onKeyEvent, keyEvent: " + keyEvent);
         }
         broadcastClientEvent(client -> client.onKeyEvent(keyEvent));
     }

     /**
      * Broadcasts an event to all the registered service clients
      *
      * @param event event to broadcast
      */
     private void broadcastClientEvent(Consumer<ServiceClient> event) {
         for (ServiceClient client : mClients) {
             event.accept(client);
         }
     }

     @Override
     public NavigationRenderer getNavigationRenderer() {
         NavigationRenderer navigationRenderer = new NavigationRenderer() {
             @Override
             public CarNavigationInstrumentCluster getNavigationProperties() {
                 CarNavigationInstrumentCluster config =
                         CarNavigationInstrumentCluster.createCluster(1000);
                 Log.d(TAG, "getNavigationProperties, returns: " + config);
                 return config;
             }

             @Override
             public void onNavigationStateChanged(Bundle bundle) {
                 StringBuilder bundleSummary = new StringBuilder();

                 // Attempt to read proto byte array
                 byte[] protoBytes = bundle.getByteArray(NAV_STATE_PROTO_BUNDLE_KEY);
                 if (protoBytes != null) {
                     try {
                         NavigationStateProto navState = NavigationStateProto.parseFrom(
                                 protoBytes);
                         bundleSummary.append(navState.toString());

                         // Update clients
                         broadcastClientEvent(
                                 client -> client.onNavigationStateChange(navState));
                     } catch (InvalidProtocolBufferException e) {
                         Log.e(TAG, "Error parsing navigation state proto", e);
                     }
                 } else {
                     Log.e(TAG, "Received nav state byte array is null");
                 }
                 Log.d(TAG, "onNavigationStateChanged(" + bundleSummary + ")");
             }
         };

         Log.i(TAG, "createNavigationRenderer, returns: " + navigationRenderer);
         return navigationRenderer;
     }

     @Override
     protected void dump(FileDescriptor fd, PrintWriter writer, String[] args) {
         if (args != null && args.length > 0) {
             execShellCommand(args);
         } else {
             super.dump(fd, writer, args);
             writer.println("DisplayProvider: " + mDisplayProvider);
         }
     }

     private void emulateKeyEvent(int keyCode) {
         Log.i(TAG, "emulateKeyEvent, keyCode: " + keyCode);
         long downTime = SystemClock.uptimeMillis();
         long eventTime = SystemClock.uptimeMillis();
         KeyEvent event = obtainKeyEvent(keyCode, downTime, eventTime, KeyEvent.ACTION_DOWN);
         onKeyEvent(event);

         eventTime = SystemClock.uptimeMillis();
         event = obtainKeyEvent(keyCode, downTime, eventTime, KeyEvent.ACTION_UP);
         onKeyEvent(event);
     }

     private KeyEvent obtainKeyEvent(int keyCode, long downTime, long eventTime, int action) {
         int scanCode = 0;
         if (keyCode == KeyEvent.KEYCODE_DPAD_DOWN) {
             scanCode = 108;
         } else if (keyCode == KeyEvent.KEYCODE_DPAD_RIGHT) {
             scanCode = 106;
         }
         return KeyEvent.obtain(
                 downTime,
                 eventTime,
                 action,
                 keyCode,
                 0 /* repeat */,
                 0 /* meta state */,
                 0 /* deviceId*/,
                 scanCode /* scancode */,
                 KeyEvent.FLAG_FROM_SYSTEM /* flags */,
                 InputDevice.SOURCE_KEYBOARD,
                 null /* characters */);
     }

     private void execShellCommand(String[] args) {
         Log.i(TAG, "execShellCommand, args: " + Arrays.toString(args));

         String command = args[0];

         switch (command) {
             case "injectKey": {
                 if (args.length > 1) {
                     emulateKeyEvent(parseInt(args[1]));
                 } else {
                     Log.i(TAG, "Not enough arguments");
                 }
                 break;
             }
             case "destroyOverlayDisplay": {
                 Settings.Global.putString(getContentResolver(),
                         Global.OVERLAY_DISPLAY_DEVICES, "");
                 break;
             }

             case "createOverlayDisplay": {
                 if (args.length > 1) {
                     Settings.Global.putString(getContentResolver(),
                             Global.OVERLAY_DISPLAY_DEVICES, args[1]);
                 } else {
                     Log.i(TAG, "Not enough arguments, expected 2");
                 }
                 break;
             }

             case "setUnobscuredArea": {
                 if (args.length > 5) {
                     setClusterActivityState(ClusterActivityState.create(true,
                             new Rect(parseInt(args[2]), parseInt(args[3]),
                                     parseInt(args[4]), parseInt(args[5]))));
                 } else {
                     Log.i(TAG, "wrong format, expected: category left top right bottom");
                 }
             }
         }
     }

     private class UserReceiver extends BroadcastReceiver {
         void register(Context context) {
             IntentFilter intentFilter = new IntentFilter(ACTION_USER_UNLOCKED);
             context.registerReceiverAsUser(this, UserHandle.ALL, intentFilter, null, null);
         }

         void unregister(Context context) {
             context.unregisterReceiver(this);
         }

         @Override
         public void onReceive(Context context, Intent intent) {
             if (Log.isLoggable(TAG, Log.DEBUG)) {
                 Log.d(TAG, "Broadcast received: " + intent);
             }
             int userId = intent.getIntExtra(Intent.EXTRA_USER_HANDLE, UserHandle.USER_NULL);
             if (userId == ActivityManager.getCurrentUser() &&
                 mInstrumentClusterHelperReady && mClusterDisplayId != INVALID_DISPLAY) {
                 mHandler.post(mLaunchMainActivity);
             }
         }
     }
 }
	/*
	* Copyright (C) 2017 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 android.car.cluster;

	import static android.content.Intent.ACTION_USER_UNLOCKED;
	import static android.content.Intent.FLAG_ACTIVITY_NEW_TASK;
	import static android.view.Display.INVALID_DISPLAY;

	import static java.lang.Integer.parseInt;

	import android.annotation.Nullable;
	import android.app.ActivityManager;
	import android.app.ActivityOptions;
	import android.car.Car;
	import android.car.CarAppFocusManager;
	import android.car.cluster.navigation.NavigationState.NavigationStateProto;
	import android.car.cluster.renderer.InstrumentClusterRenderingService;
	import android.car.cluster.renderer.NavigationRenderer;
	import android.car.navigation.CarNavigationInstrumentCluster;
	import android.content.BroadcastReceiver;
	import android.content.ComponentName;
	import android.content.Context;
	import android.content.ContextWrapper;
	import android.content.Intent;
	import android.content.IntentFilter;
	import android.content.pm.ActivityInfo;
	import android.content.pm.PackageManager;
	import android.graphics.Rect;
	import android.hardware.display.DisplayManager;
	import android.hardware.display.DisplayManager.DisplayListener;
	import android.os.Binder;
	import android.os.Bundle;
	import android.os.Handler;
	import android.os.IBinder;
	import android.os.SystemClock;
	import android.os.UserHandle;
	import android.provider.Settings;
	import android.provider.Settings.Global;
	import android.util.Log;
	import android.view.Display;
	import android.view.InputDevice;
	import android.view.KeyEvent;

	import com.android.car.internal.common.UserHelperLite;

	import com.google.protobuf.InvalidProtocolBufferException;

	import java.io.FileDescriptor;
	import java.io.PrintWriter;
	import java.util.ArrayList;
	import java.util.Arrays;
	import java.util.List;
	import java.util.Objects;
	import java.util.function.Consumer;

	/**
	* Implementation of {@link InstrumentClusterRenderingService} which renders an activity on a
	* virtual display that is transmitted to an external screen.
	*/
	public class ClusterRenderingService extends InstrumentClusterRenderingService implements
	ImageResolver.BitmapFetcher, CarAppFocusManager.OnAppFocusChangedListener {
	private static final String TAG = "Cluster.Service";

	static final String LOCAL_BINDING_ACTION = "local";
	static final String NAV_STATE_PROTO_BUNDLE_KEY = "navstate2";

	private List<ServiceClient> mClients = new ArrayList<>();
	private ClusterDisplayProvider mDisplayProvider;

	private int mClusterDisplayId = INVALID_DISPLAY;

	private boolean mInstrumentClusterHelperReady;

	private final IBinder mLocalBinder = new LocalBinder();
	private final ImageResolver mImageResolver = new ImageResolver(this);
	private final Handler mHandler = new Handler();
	private final Runnable mLaunchMainActivity = this::launchMainActivity;
	private ComponentName mNavigationClusterActivity = null;
	private int mNavigationClusterUserId = UserHandle.USER_SYSTEM;
	private CarAppFocusManager mAppFocusManager = null;

	private final UserReceiver mUserReceiver = new UserReceiver();

	public interface ServiceClient {
	void onKeyEvent(KeyEvent keyEvent);

	void onNavigationStateChange(NavigationStateProto navState);
	}

	public class LocalBinder extends Binder {
	ClusterRenderingService getService() {
	return ClusterRenderingService.this;
	}
	}

	private final DisplayListener mDisplayListener = new DisplayListener() {
	// Called in the main thread, since ClusterDisplayProvider.DisplayListener was registered
	// with null handler.
	@Override
	public void onDisplayAdded(int displayId) {
	Log.i(TAG, "Cluster display found, displayId: " + displayId);
	mClusterDisplayId = displayId;
	if (mInstrumentClusterHelperReady) {
	mHandler.post(mLaunchMainActivity);
	}
	}

	@Override
	public void onDisplayRemoved(int displayId) {
	Log.w(TAG, "Cluster display has been removed");
	}

	@Override
	public void onDisplayChanged(int displayId) {

	}
	};

	public void setActivityLaunchOptions(int displayId, ClusterActivityState state) {
	ActivityOptions options = displayId != INVALID_DISPLAY
	? ActivityOptions.makeBasic().setLaunchDisplayId(displayId)
	: null;
	setClusterActivityLaunchOptions(options);
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, String.format("activity options set: %s (displayeId: %d)",
	options, options != null ? options.getLaunchDisplayId() : -1));
	}
	setClusterActivityState(state);
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, String.format("activity state set: %s", state));
	}
	}

	public void registerClient(ServiceClient client) {
	mClients.add(client);
	}

	public void unregisterClient(ServiceClient client) {
	mClients.remove(client);
	}

	public ImageResolver getImageResolver() {
	return mImageResolver;
	}

	@Override
	public IBinder onBind(Intent intent) {
	Log.d(TAG, "onBind, intent: " + intent);
	if (LOCAL_BINDING_ACTION.equals(intent.getAction())) {
	return mLocalBinder;
	}
	IBinder binder = super.onBind(intent);
	mInstrumentClusterHelperReady = true;
	if (mClusterDisplayId != INVALID_DISPLAY) {
	mHandler.post(mLaunchMainActivity);
	}
	return binder;
	}

	@Override
	public void onCreate() {
	super.onCreate();
	Log.d(TAG, "onCreate");
	// The following will never be null, as this service is initiated by CarService itself.
	Car car = Car.createCar(this);
	mAppFocusManager = (CarAppFocusManager) car.getCarManager(Car.APP_FOCUS_SERVICE);
	mAppFocusManager.addFocusListener(this, CarAppFocusManager.APP_FOCUS_TYPE_NAVIGATION);
	mDisplayProvider = new ClusterDisplayProvider(this, mDisplayListener);
	mUserReceiver.register(this);
	mNavigationClusterActivity = getNavigationClusterActivity();
	Log.i(TAG, "onCreate: set cluster to " + mNavigationClusterActivity);
	}

	@Override
	public void onDestroy() {
	super.onDestroy();
	mAppFocusManager.removeFocusListener(this, CarAppFocusManager.APP_FOCUS_TYPE_NAVIGATION);
	mUserReceiver.unregister(this);
	mDisplayProvider.release();
	}

	@Override
	public void onAppFocusChanged(int appType, boolean active) {
	boolean useNavigationOnly = getResources().getBoolean(R.bool.navigationOnly);
	Log.i(TAG, "onAppFocusChanged: " + appType + ", active: " + active);
	if (useNavigationOnly) {
	launchMainActivity();
	} else {
	// TODO(b/193931272): Update MainClusterActivity
	}
	}

	private void launchMainActivity() {
	mHandler.removeCallbacks(mLaunchMainActivity);
	ActivityOptions options = ActivityOptions.makeBasic();
	options.setLaunchDisplayId(mClusterDisplayId);
	boolean useNavigationOnly = getResources().getBoolean(R.bool.navigationOnly);
	Intent intent;
	int userId = UserHandle.USER_SYSTEM;
	if (useNavigationOnly) {
	userId = ActivityManager.getCurrentUser();
	if (UserHelperLite.isHeadlessSystemUser(userId)) {
	Log.i(TAG, "Skipping the navigation activity for User 0");
	return;
	}
	ComponentName newClusterActivity = getNavigationClusterActivity();
	if (Objects.equals(newClusterActivity, mNavigationClusterActivity)
	&& userId == mNavigationClusterUserId) {
	Log.i(TAG, "Cluster activity hasn't changed. Skipping.");
	return;
	}
	Log.i(TAG, "Set cluster to " + newClusterActivity);
	onNavigationComponentChanged(newClusterActivity);
	mNavigationClusterActivity = newClusterActivity;
	mNavigationClusterUserId = userId;
	intent = getNavigationActivityIntent(mNavigationClusterActivity, mClusterDisplayId);
	startFixedActivityModeForDisplayAndUser(intent, options, userId);
	} else {
	intent = getMainClusterActivityIntent();
	startActivityAsUser(intent, options.toBundle(), UserHandle.SYSTEM);
	}
	Log.i(TAG, "launching main activity=" + intent + ", display=" + mClusterDisplayId
	+ ", userId=" + userId);
	}

	/**
	* Invoked when the activity to show in the cluster changes
	*
	* @param clusterActivity current activity displayed in cluster. If no application is holding
	* {@link CarAppFocusManager#APP_FOCUS_TYPE_NAVIGATION}, this will be the
	* default map cluster activity. Otherwise, this will be the cluster
	* activity of the focused application (if it has one) or {@code null} if
	* the application doesn't have a cluster activity or the activity is
	* disabled.
	*/
	protected void onNavigationComponentChanged(@Nullable ComponentName clusterActivity) {
	// This method can be used by OEMs to send a signal to the cluster hardware indicating
	// whether Android has or doesn't have a cluster activity.
	//
	// OEMs can use this signal to let the cluster show some other view, or to hide Android's
	// video feed altogether.
	}

	private Intent getMainClusterActivityIntent() {
	return new Intent(this, MainClusterActivity.class).setFlags(FLAG_ACTIVITY_NEW_TASK);
	}

	private ComponentName getNavigationClusterActivity() {
	List<String> focusOwnerPackageNames = mAppFocusManager.getAppTypeOwner(
	CarAppFocusManager.APP_FOCUS_TYPE_NAVIGATION);

	if (focusOwnerPackageNames == null \|\| focusOwnerPackageNames.isEmpty()) {
	// No application has focus. We use the default navigation app.
	Log.i(TAG, "getNavigationClusterActivity(): no focus owner -> "
	+ "using default nav app");
	ActivityInfo activityInfo = MainClusterActivity.getNavigationActivity(this);
	return new ComponentName(activityInfo.packageName, activityInfo.name);
	} else {
	ComponentName clusterActivity = getComponentFromPackages(focusOwnerPackageNames);
	if (clusterActivity == null) {
	// If currently focused app has no cluster activity, we indicate so.
	Log.i(TAG, "getNavigationClusterActivity(): focus owned by "
	+ focusOwnerPackageNames + " but it has no cluster activity -> "
	+ "using empty activity");
	return null;
	}
	// Otherwise, we use the activity of the currently focused app
	Log.i(TAG, "getNavigationClusterActivity(): focus owned and it has a cluster "
	+ "activity -> using " + focusOwnerPackageNames + " app");
	return clusterActivity;
	}
	}

	private ComponentName getComponentFromPackages(List<String> packageNames) {
	for (String packageName : packageNames) {
	ComponentName result = getComponentFromPackage(packageName);
	if (result != null) {
	return result;
	}
	}
	return null;
	}

	private Intent getNavigationActivityIntent(ComponentName component, int displayId) {
	if (component == null) {
	Log.i(TAG, "Focused application doesn't have a cluster activity. Using fallback.");
	component = new ComponentName(this, EmptyNavigationActivity.class);
	}
	Rect displaySize = new Rect(0, 0, 240, 320); // Arbitrary size, better than nothing.
	DisplayManager dm = getSystemService(DisplayManager.class);
	Display display = dm.getDisplay(displayId);
	if (display != null) {
	display.getRectSize(displaySize);
	}
	setClusterActivityState(ClusterActivityState.create(/* visible= */ true,
	/* unobscuredBounds= */ new Rect(0, 0, 240, 320)));
	return new Intent(Intent.ACTION_MAIN)
	.setComponent(component)
	.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
	.putExtra(Car.CAR_EXTRA_CLUSTER_ACTIVITY_STATE,
	ClusterActivityState.create(/* visible= */ true,
	/* unobscuredBounds= */ displaySize).toBundle());
	}

	@Override
	public void onKeyEvent(KeyEvent keyEvent) {
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "onKeyEvent, keyEvent: " + keyEvent);
	}
	broadcastClientEvent(client -> client.onKeyEvent(keyEvent));
	}

	/**
	* Broadcasts an event to all the registered service clients
	*
	* @param event event to broadcast
	*/
	private void broadcastClientEvent(Consumer<ServiceClient> event) {
	for (ServiceClient client : mClients) {
	event.accept(client);
	}
	}

	@Override
	public NavigationRenderer getNavigationRenderer() {
	NavigationRenderer navigationRenderer = new NavigationRenderer() {
	@Override
	public CarNavigationInstrumentCluster getNavigationProperties() {
	CarNavigationInstrumentCluster config =
	CarNavigationInstrumentCluster.createCluster(1000);
	Log.d(TAG, "getNavigationProperties, returns: " + config);
	return config;
	}

	@Override
	public void onNavigationStateChanged(Bundle bundle) {
	StringBuilder bundleSummary = new StringBuilder();

	// Attempt to read proto byte array
	byte[] protoBytes = bundle.getByteArray(NAV_STATE_PROTO_BUNDLE_KEY);
	if (protoBytes != null) {
	try {
	NavigationStateProto navState = NavigationStateProto.parseFrom(
	protoBytes);
	bundleSummary.append(navState.toString());

	// Update clients
	broadcastClientEvent(
	client -> client.onNavigationStateChange(navState));
	} catch (InvalidProtocolBufferException e) {
	Log.e(TAG, "Error parsing navigation state proto", e);
	}
	} else {
	Log.e(TAG, "Received nav state byte array is null");
	}
	Log.d(TAG, "onNavigationStateChanged(" + bundleSummary + ")");
	}
	};

	Log.i(TAG, "createNavigationRenderer, returns: " + navigationRenderer);
	return navigationRenderer;
	}

	@Override
	protected void dump(FileDescriptor fd, PrintWriter writer, String[] args) {
	if (args != null && args.length > 0) {
	execShellCommand(args);
	} else {
	super.dump(fd, writer, args);
	writer.println("DisplayProvider: " + mDisplayProvider);
	}
	}

	private void emulateKeyEvent(int keyCode) {
	Log.i(TAG, "emulateKeyEvent, keyCode: " + keyCode);
	long downTime = SystemClock.uptimeMillis();
	long eventTime = SystemClock.uptimeMillis();
	KeyEvent event = obtainKeyEvent(keyCode, downTime, eventTime, KeyEvent.ACTION_DOWN);
	onKeyEvent(event);

	eventTime = SystemClock.uptimeMillis();
	event = obtainKeyEvent(keyCode, downTime, eventTime, KeyEvent.ACTION_UP);
	onKeyEvent(event);
	}

	private KeyEvent obtainKeyEvent(int keyCode, long downTime, long eventTime, int action) {
	int scanCode = 0;
	if (keyCode == KeyEvent.KEYCODE_DPAD_DOWN) {
	scanCode = 108;
	} else if (keyCode == KeyEvent.KEYCODE_DPAD_RIGHT) {
	scanCode = 106;
	}
	return KeyEvent.obtain(
	downTime,
	eventTime,
	action,
	keyCode,
	0 /* repeat */,
	0 /* meta state */,
	0 /* deviceId*/,
	scanCode /* scancode */,
	KeyEvent.FLAG_FROM_SYSTEM /* flags */,
	InputDevice.SOURCE_KEYBOARD,
	null /* characters */);
	}

	private void execShellCommand(String[] args) {
	Log.i(TAG, "execShellCommand, args: " + Arrays.toString(args));

	String command = args[0];

	switch (command) {
	case "injectKey": {
	if (args.length > 1) {
	emulateKeyEvent(parseInt(args[1]));
	} else {
	Log.i(TAG, "Not enough arguments");
	}
	break;
	}
	case "destroyOverlayDisplay": {
	Settings.Global.putString(getContentResolver(),
	Global.OVERLAY_DISPLAY_DEVICES, "");
	break;
	}

	case "createOverlayDisplay": {
	if (args.length > 1) {
	Settings.Global.putString(getContentResolver(),
	Global.OVERLAY_DISPLAY_DEVICES, args[1]);
	} else {
	Log.i(TAG, "Not enough arguments, expected 2");
	}
	break;
	}

	case "setUnobscuredArea": {
	if (args.length > 5) {
	setClusterActivityState(ClusterActivityState.create(true,
	new Rect(parseInt(args[2]), parseInt(args[3]),
	parseInt(args[4]), parseInt(args[5]))));
	} else {
	Log.i(TAG, "wrong format, expected: category left top right bottom");
	}
	}
	}
	}

	private class UserReceiver extends BroadcastReceiver {
	void register(Context context) {
	IntentFilter intentFilter = new IntentFilter(ACTION_USER_UNLOCKED);
	context.registerReceiverAsUser(this, UserHandle.ALL, intentFilter, null, null);
	}

	void unregister(Context context) {
	context.unregisterReceiver(this);
	}

	@Override
	public void onReceive(Context context, Intent intent) {
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "Broadcast received: " + intent);
	}
	int userId = intent.getIntExtra(Intent.EXTRA_USER_HANDLE, UserHandle.USER_NULL);
	if (userId == ActivityManager.getCurrentUser() &&
	mInstrumentClusterHelperReady && mClusterDisplayId != INVALID_DISPLAY) {
	mHandler.post(mLaunchMainActivity);
	}
	}
	}
	}