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_SWITCHED;
 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.app.ActivityManager;
 import android.app.ActivityOptions;
 import android.car.CarNotConnectedException;
 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.Intent;
 import android.content.IntentFilter;
 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 androidx.versionedparcelable.ParcelUtils;

 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.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 {
     private static final String TAG = "Cluster.Service";
     private static final int NAVIGATION_ACTIVITY_RETRY_INTERVAL_MS = 1000;

     static final int NAV_STATE_EVENT_ID = 1;
     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 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) {
         try {
             ActivityOptions options = displayId != INVALID_DISPLAY
                     ? ActivityOptions.makeBasic().setLaunchDisplayId(displayId)
                     : null;
             setClusterActivityLaunchOptions(CarInstrumentClusterManager.CATEGORY_NAVIGATION,
                     options);
             if (Log.isLoggable(TAG, Log.DEBUG)) {
                 Log.d(TAG, String.format("activity options set: %s (displayeId: %d)",
                         options, options.getLaunchDisplayId()));
             }
             setClusterActivityState(CarInstrumentClusterManager.CATEGORY_NAVIGATION,
                     state.toBundle());
             if (Log.isLoggable(TAG, Log.DEBUG)) {
                 Log.d(TAG, String.format("activity state set: %s", state));
             }
         } catch (CarNotConnectedException ex) {
             Log.e(TAG, "Unable to update service", ex);
         }
     }

     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");
         mDisplayProvider = new ClusterDisplayProvider(this, mDisplayListener);

         mUserReceiver.register(this);
     }

     public void onDestroy() {
         super.onDestroy();
         mUserReceiver.unregister(this);
     }

     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) {
             intent = getNavigationActivityIntent(mClusterDisplayId);
             if (intent == null) {
                 mHandler.postDelayed(mLaunchMainActivity, NAVIGATION_ACTIVITY_RETRY_INTERVAL_MS);
                 return;
             }
             userId = ActivityManager.getCurrentUser();
             startFixedActivityModeForDisplayAndUser(intent, options, userId);
         } else {
             intent = getMainClusterActivityIntent();
             startActivityAsUser(intent, options.toBundle(), UserHandle.SYSTEM);
         }
         Log.i(TAG, "launching main activity=" + intent + ", display=" + mClusterDisplayId
                 + ", userId=" + userId);
     }

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

     private Intent getNavigationActivityIntent(int displayId) {
         ComponentName component = MainClusterActivity.getNavigationActivity(this);
         if (component == null) {
             Log.e(TAG, "Failed to resolve the navigation activity");
             return null;
         }
         Rect displaySize = new Rect(0, 0, 320, 240);  // Arbitrary size, better than nothing.
         DisplayManager dm = (DisplayManager) getSystemService(DisplayManager.class);
         Display display = dm.getDisplay(displayId);
         if (display != null) {
             display.getRectSize(displaySize);
         }
         return new Intent(Intent.ACTION_MAIN)
             .setComponent(component)
             .setFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
             .putExtra(CarInstrumentClusterManager.KEY_EXTRA_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 onEvent(int eventType, Bundle bundle) {
                 StringBuilder bundleSummary = new StringBuilder();
                 if (eventType == NAV_STATE_EVENT_ID) {
                     // Required to prevent backwards compatibility crash with old map providers
                     // sending androidx.versionedparcelables
                     bundle.setClassLoader(ParcelUtils.class.getClassLoader());

                     // 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");
                     }
                 } else {
                     for (String key : bundle.keySet()) {
                         bundleSummary.append(key);
                         bundleSummary.append("=");
                         bundleSummary.append(bundle.get(key));
                         bundleSummary.append(" ");
                     }
                 }
                 Log.d(TAG, "onEvent(" + eventType + ", " + 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) {
                     Rect unobscuredArea = new Rect(parseInt(args[2]), parseInt(args[3]),
                             parseInt(args[4]), parseInt(args[5]));
                     try {
                         setClusterActivityState(args[1],
                                 ClusterActivityState.create(true, unobscuredArea).toBundle());
                     } catch (CarNotConnectedException e) {
                         Log.i(TAG, "Failed to set activity state.", e);
                     }
                 } 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_SWITCHED;
	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.app.ActivityManager;
	import android.app.ActivityOptions;
	import android.car.CarNotConnectedException;
	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.Intent;
	import android.content.IntentFilter;
	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 androidx.versionedparcelable.ParcelUtils;

	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.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 {
	private static final String TAG = "Cluster.Service";
	private static final int NAVIGATION_ACTIVITY_RETRY_INTERVAL_MS = 1000;

	static final int NAV_STATE_EVENT_ID = 1;
	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 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) {
	try {
	ActivityOptions options = displayId != INVALID_DISPLAY
	? ActivityOptions.makeBasic().setLaunchDisplayId(displayId)
	: null;
	setClusterActivityLaunchOptions(CarInstrumentClusterManager.CATEGORY_NAVIGATION,
	options);
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, String.format("activity options set: %s (displayeId: %d)",
	options, options.getLaunchDisplayId()));
	}
	setClusterActivityState(CarInstrumentClusterManager.CATEGORY_NAVIGATION,
	state.toBundle());
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, String.format("activity state set: %s", state));
	}
	} catch (CarNotConnectedException ex) {
	Log.e(TAG, "Unable to update service", ex);
	}
	}

	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");
	mDisplayProvider = new ClusterDisplayProvider(this, mDisplayListener);

	mUserReceiver.register(this);
	}

	public void onDestroy() {
	super.onDestroy();
	mUserReceiver.unregister(this);
	}

	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) {
	intent = getNavigationActivityIntent(mClusterDisplayId);
	if (intent == null) {
	mHandler.postDelayed(mLaunchMainActivity, NAVIGATION_ACTIVITY_RETRY_INTERVAL_MS);
	return;
	}
	userId = ActivityManager.getCurrentUser();
	startFixedActivityModeForDisplayAndUser(intent, options, userId);
	} else {
	intent = getMainClusterActivityIntent();
	startActivityAsUser(intent, options.toBundle(), UserHandle.SYSTEM);
	}
	Log.i(TAG, "launching main activity=" + intent + ", display=" + mClusterDisplayId
	+ ", userId=" + userId);
	}

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

	private Intent getNavigationActivityIntent(int displayId) {
	ComponentName component = MainClusterActivity.getNavigationActivity(this);
	if (component == null) {
	Log.e(TAG, "Failed to resolve the navigation activity");
	return null;
	}
	Rect displaySize = new Rect(0, 0, 320, 240); // Arbitrary size, better than nothing.
	DisplayManager dm = (DisplayManager) getSystemService(DisplayManager.class);
	Display display = dm.getDisplay(displayId);
	if (display != null) {
	display.getRectSize(displaySize);
	}
	return new Intent(Intent.ACTION_MAIN)
	.setComponent(component)
	.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
	.putExtra(CarInstrumentClusterManager.KEY_EXTRA_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 onEvent(int eventType, Bundle bundle) {
	StringBuilder bundleSummary = new StringBuilder();
	if (eventType == NAV_STATE_EVENT_ID) {
	// Required to prevent backwards compatibility crash with old map providers
	// sending androidx.versionedparcelables
	bundle.setClassLoader(ParcelUtils.class.getClassLoader());

	// 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");
	}
	} else {
	for (String key : bundle.keySet()) {
	bundleSummary.append(key);
	bundleSummary.append("=");
	bundleSummary.append(bundle.get(key));
	bundleSummary.append(" ");
	}
	}
	Log.d(TAG, "onEvent(" + eventType + ", " + 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) {
	Rect unobscuredArea = new Rect(parseInt(args[2]), parseInt(args[3]),
	parseInt(args[4]), parseInt(args[5]));
	try {
	setClusterActivityState(args[1],
	ClusterActivityState.create(true, unobscuredArea).toBundle());
	} catch (CarNotConnectedException e) {
	Log.i(TAG, "Failed to set activity state.", e);
	}
	} 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);
	}
	}
	}
	}