service/src/com/android/car/cluster/InstrumentClusterService.java - platform/packages/services/Car - Gitiles

 /*
  * Copyright (C) 2016 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
 package com.android.car.cluster;

 import static android.car.cluster.renderer.InstrumentClusterRenderingService.EXTRA_BUNDLE_KEY_FOR_INSTRUMENT_CLUSTER_HELPER;

 import android.annotation.Nullable;
 import android.annotation.SystemApi;
 import android.app.ActivityOptions;
 import android.car.CarAppFocusManager;
 import android.car.cluster.IInstrumentClusterManagerCallback;
 import android.car.cluster.IInstrumentClusterManagerService;
 import android.car.cluster.renderer.IInstrumentCluster;
 import android.car.cluster.renderer.IInstrumentClusterHelper;
 import android.car.cluster.renderer.IInstrumentClusterNavigation;
 import android.content.ComponentName;
 import android.content.Context;
 import android.content.Intent;
 import android.content.ServiceConnection;
 import android.os.Binder;
 import android.os.Bundle;
 import android.os.Handler;
 import android.os.IBinder;
 import android.os.Message;
 import android.os.RemoteException;
 import android.os.UserHandle;
 import android.text.TextUtils;
 import android.util.Log;
 import android.view.KeyEvent;

 import com.android.car.AppFocusService;
 import com.android.car.AppFocusService.FocusOwnershipCallback;
 import com.android.car.CarInputService;
 import com.android.car.CarInputService.KeyEventListener;
 import com.android.car.CarLocalServices;
 import com.android.car.CarLog;
 import com.android.car.CarServiceBase;
 import com.android.car.R;
 import com.android.car.am.FixedActivityService;
 import com.android.car.user.CarUserService;
 import com.android.internal.annotations.GuardedBy;

 import java.io.PrintWriter;
 import java.util.Objects;

 /**
  * Service responsible for interaction with car's instrument cluster.
  *
  * @hide
  */
 @SystemApi
 public class InstrumentClusterService implements CarServiceBase, FocusOwnershipCallback,
         KeyEventListener {
     private static final String TAG = CarLog.TAG_CLUSTER;
     private static final ContextOwner NO_OWNER = new ContextOwner(0, 0);

     private final Context mContext;
     private final AppFocusService mAppFocusService;
     private final CarInputService mCarInputService;
     /**
      * TODO: (b/121277787) Remove this on master.
      * @deprecated CarInstrumentClusterManager is being deprecated.
      */
     @Deprecated
     private final ClusterManagerService mClusterManagerService = new ClusterManagerService();
     private final Object mLock = new Object();
     @GuardedBy("mLock")
     private ContextOwner mNavContextOwner = NO_OWNER;
     @GuardedBy("mLock")
     private IInstrumentCluster mRendererService;
     // If renderer service crashed / stopped and this class fails to rebind with it immediately,
     // we should wait some time before next attempt. This may happen during APK update for example.
     @GuardedBy("mLock")
     private DeferredRebinder mDeferredRebinder;
     // Whether {@link android.car.cluster.renderer.InstrumentClusterRendererService} is bound
     // (although not necessarily connected)
     @GuardedBy("mLock")
     private boolean mRendererBound = false;

     /**
      * Connection to {@link android.car.cluster.renderer.InstrumentClusterRendererService}
      */
     private final ServiceConnection mRendererServiceConnection = new ServiceConnection() {
         @Override
         public void onServiceConnected(ComponentName name, IBinder binder) {
             if (Log.isLoggable(TAG, Log.DEBUG)) {
                 Log.d(TAG, "onServiceConnected, name: " + name + ", binder: " + binder);
             }
             IInstrumentCluster service = IInstrumentCluster.Stub.asInterface(binder);
             ContextOwner navContextOwner;
             synchronized (mLock) {
                 mRendererService = service;
                 navContextOwner = mNavContextOwner;
             }
             if (navContextOwner != null && service != null) {
                 notifyNavContextOwnerChanged(service, navContextOwner);
             }
         }

         @Override
         public void onServiceDisconnected(ComponentName name) {
             if (Log.isLoggable(TAG, Log.DEBUG)) {
                 Log.d(TAG, "onServiceDisconnected, name: " + name);
             }
             mContext.unbindService(this);
             DeferredRebinder rebinder;
             synchronized (mLock) {
                 mRendererBound = false;
                 mRendererService = null;
                 if (mDeferredRebinder == null) {
                     mDeferredRebinder = new DeferredRebinder();
                 }
                 rebinder = mDeferredRebinder;
             }
             rebinder.rebind();
         }
     };

     private final IInstrumentClusterHelper mInstrumentClusterHelper =
             new IInstrumentClusterHelper.Stub() {
                 @Override
                 public boolean startFixedActivityModeForDisplayAndUser(Intent intent,
                         Bundle activityOptionsBundle, int userId) {
                     Binder.clearCallingIdentity();
                     ActivityOptions options = new ActivityOptions(activityOptionsBundle);
                     FixedActivityService service = CarLocalServices.getService(
                             FixedActivityService.class);
                     return service.startFixedActivityModeForDisplayAndUser(intent, options,
                             options.getLaunchDisplayId(), userId);
                 }

                 @Override
                 public void stopFixedActivityMode(int displayId) {
                     Binder.clearCallingIdentity();
                     FixedActivityService service = CarLocalServices.getService(
                             FixedActivityService.class);
                     service.stopFixedActivityMode(displayId);
                 }
             };

     public InstrumentClusterService(Context context, AppFocusService appFocusService,
             CarInputService carInputService) {
         mContext = context;
         mAppFocusService = appFocusService;
         mCarInputService = carInputService;
     }

     @Override
     public void init() {
         if (Log.isLoggable(TAG, Log.DEBUG)) {
             Log.d(TAG, "init");
         }

         mAppFocusService.registerContextOwnerChangedCallback(this /* FocusOwnershipCallback */);
         mCarInputService.setInstrumentClusterKeyListener(this /* KeyEventListener */);
         // TODO(b/124246323) Start earlier once data storage for cluster is clarified
         //  for early boot.
         CarLocalServices.getService(CarUserService.class).runOnUser0Unlock(() -> {
             mRendererBound = bindInstrumentClusterRendererService();
         });
     }

     @Override
     public void release() {
         if (Log.isLoggable(TAG, Log.DEBUG)) {
             Log.d(TAG, "release");
         }

         mAppFocusService.unregisterContextOwnerChangedCallback(this);
         if (mRendererBound) {
             mContext.unbindService(mRendererServiceConnection);
             mRendererBound = false;
         }
     }

     @Override
     public void dump(PrintWriter writer) {
         writer.println("**" + getClass().getSimpleName() + "**");
         writer.println("bound with renderer: " + mRendererBound);
         writer.println("renderer service: " + mRendererService);
         writer.println("context owner: " + mNavContextOwner);
     }

     @Override
     public void onFocusAcquired(int appType, int uid, int pid) {
         changeNavContextOwner(appType, uid, pid, true);
     }

     @Override
     public void onFocusAbandoned(int appType, int uid, int pid) {
         changeNavContextOwner(appType, uid, pid, false);
     }

     private void changeNavContextOwner(int appType, int uid, int pid, boolean acquire) {
         if (appType != CarAppFocusManager.APP_FOCUS_TYPE_NAVIGATION) {
             return;
         }

         IInstrumentCluster service;
         ContextOwner requester = new ContextOwner(uid, pid);
         ContextOwner newOwner = acquire ? requester : NO_OWNER;
         synchronized (mLock) {
             if ((acquire && Objects.equals(mNavContextOwner, requester))
                     || (!acquire && !Objects.equals(mNavContextOwner, requester))) {
                 // Nothing to do here. Either the same owner is acquiring twice, or someone is
                 // abandoning a focus they didn't have.
                 Log.w(TAG, "Invalid nav context owner change (acquiring: " + acquire
                         + "), current owner: [" + mNavContextOwner
                         + "], requester: [" + requester + "]");
                 return;
             }

             mNavContextOwner = newOwner;
             service = mRendererService;
         }

         if (service != null) {
             notifyNavContextOwnerChanged(service, newOwner);
         }
     }

     private static void notifyNavContextOwnerChanged(IInstrumentCluster service,
             ContextOwner owner) {
         try {
             service.setNavigationContextOwner(owner.uid, owner.pid);
         } catch (RemoteException e) {
             Log.e(TAG, "Failed to call setNavigationContextOwner", e);
         }
     }

     private boolean bindInstrumentClusterRendererService() {
         String rendererService = mContext.getString(R.string.instrumentClusterRendererService);
         if (TextUtils.isEmpty(rendererService)) {
             Log.i(TAG, "Instrument cluster renderer was not configured");
             return false;
         }

         Log.d(TAG, "bindInstrumentClusterRendererService, component: " + rendererService);

         Intent intent = new Intent();
         intent.setComponent(ComponentName.unflattenFromString(rendererService));
         // Litle bit inefficiency here as Intent.getIBinderExtra() is a hidden API.
         Bundle bundle = new Bundle();
         bundle.putBinder(EXTRA_BUNDLE_KEY_FOR_INSTRUMENT_CLUSTER_HELPER,
                 mInstrumentClusterHelper.asBinder());
         intent.putExtra(EXTRA_BUNDLE_KEY_FOR_INSTRUMENT_CLUSTER_HELPER, bundle);
         return mContext.bindServiceAsUser(intent, mRendererServiceConnection,
                 Context.BIND_AUTO_CREATE | Context.BIND_IMPORTANT, UserHandle.SYSTEM);
     }

     @Nullable
     public IInstrumentClusterNavigation getNavigationService() {
         try {
             IInstrumentCluster service = getInstrumentClusterRendererService();
             return service == null ? null : service.getNavigationService();
         } catch (RemoteException e) {
             Log.e(TAG, "getNavigationServiceBinder" , e);
             return null;
         }
     }

     /**
      * @deprecated {@link android.car.cluster.CarInstrumentClusterManager} is now deprecated.
      */
     @Deprecated
     public IInstrumentClusterManagerService.Stub getManagerService() {
         return mClusterManagerService;
     }

     @Override
     public void onKeyEvent(KeyEvent event) {
         if (Log.isLoggable(TAG, Log.DEBUG)) {
             Log.d(TAG, "InstrumentClusterService#onKeyEvent: " + event);
         }

         IInstrumentCluster service = getInstrumentClusterRendererService();
         if (service != null) {
             try {
                 service.onKeyEvent(event);
             } catch (RemoteException e) {
                 Log.e(TAG, "onKeyEvent", e);
             }
         }
     }

     private IInstrumentCluster getInstrumentClusterRendererService() {
         IInstrumentCluster service;
         synchronized (mLock) {
             service = mRendererService;
         }
         return service;
     }

     private static class ContextOwner {
         final int uid;
         final int pid;

         ContextOwner(int uid, int pid) {
             this.uid = uid;
             this.pid = pid;
         }

         @Override
         public String toString() {
             return "uid: " + uid + ", pid: " + pid;
         }

         @Override
         public boolean equals(Object o) {
             if (this == o) return true;
             if (o == null || getClass() != o.getClass()) return false;
             ContextOwner that = (ContextOwner) o;
             return uid == that.uid && pid == that.pid;
         }

         @Override
         public int hashCode() {
             return Objects.hash(uid, pid);
         }
     }

     /**
      * TODO: (b/121277787) Remove on master
      * @deprecated CarClusterManager is being deprecated.
      */
     @Deprecated
     private class ClusterManagerService extends IInstrumentClusterManagerService.Stub {
         @Override
         public void startClusterActivity(Intent intent) throws RemoteException {
             // No op.
         }

         @Override
         public void registerCallback(IInstrumentClusterManagerCallback callback)
                 throws RemoteException {
             // No op.
         }

         @Override
         public void unregisterCallback(IInstrumentClusterManagerCallback callback)
                 throws RemoteException {
             // No op.
         }
     }

     private class DeferredRebinder extends Handler {
         private static final long NEXT_REBIND_ATTEMPT_DELAY_MS = 1000L;
         private static final int NUMBER_OF_ATTEMPTS = 10;

         public void rebind() {
             mRendererBound = bindInstrumentClusterRendererService();

             if (!mRendererBound) {
                 removeMessages(0);
                 sendMessageDelayed(obtainMessage(0, NUMBER_OF_ATTEMPTS, 0),
                         NEXT_REBIND_ATTEMPT_DELAY_MS);
             }
         }

         @Override
         public void handleMessage(Message msg) {
             mRendererBound = bindInstrumentClusterRendererService();

             if (mRendererBound) {
                 Log.w(TAG, "Failed to bound to render service, next attempt in "
                         + NEXT_REBIND_ATTEMPT_DELAY_MS + "ms.");

                 int attempts = msg.arg1;
                 if (--attempts >= 0) {
                     sendMessageDelayed(obtainMessage(0, attempts, 0), NEXT_REBIND_ATTEMPT_DELAY_MS);
                 } else {
                     Log.wtf(TAG, "Failed to rebind with cluster rendering service");
                 }
             }
         }
     }
 }
	/*
	* Copyright (C) 2016 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/
	package com.android.car.cluster;

	import static android.car.cluster.renderer.InstrumentClusterRenderingService.EXTRA_BUNDLE_KEY_FOR_INSTRUMENT_CLUSTER_HELPER;

	import android.annotation.Nullable;
	import android.annotation.SystemApi;
	import android.app.ActivityOptions;
	import android.car.CarAppFocusManager;
	import android.car.cluster.IInstrumentClusterManagerCallback;
	import android.car.cluster.IInstrumentClusterManagerService;
	import android.car.cluster.renderer.IInstrumentCluster;
	import android.car.cluster.renderer.IInstrumentClusterHelper;
	import android.car.cluster.renderer.IInstrumentClusterNavigation;
	import android.content.ComponentName;
	import android.content.Context;
	import android.content.Intent;
	import android.content.ServiceConnection;
	import android.os.Binder;
	import android.os.Bundle;
	import android.os.Handler;
	import android.os.IBinder;
	import android.os.Message;
	import android.os.RemoteException;
	import android.os.UserHandle;
	import android.text.TextUtils;
	import android.util.Log;
	import android.view.KeyEvent;

	import com.android.car.AppFocusService;
	import com.android.car.AppFocusService.FocusOwnershipCallback;
	import com.android.car.CarInputService;
	import com.android.car.CarInputService.KeyEventListener;
	import com.android.car.CarLocalServices;
	import com.android.car.CarLog;
	import com.android.car.CarServiceBase;
	import com.android.car.R;
	import com.android.car.am.FixedActivityService;
	import com.android.car.user.CarUserService;
	import com.android.internal.annotations.GuardedBy;

	import java.io.PrintWriter;
	import java.util.Objects;

	/**
	* Service responsible for interaction with car's instrument cluster.
	*
	* @hide
	*/
	@SystemApi
	public class InstrumentClusterService implements CarServiceBase, FocusOwnershipCallback,
	KeyEventListener {
	private static final String TAG = CarLog.TAG_CLUSTER;
	private static final ContextOwner NO_OWNER = new ContextOwner(0, 0);

	private final Context mContext;
	private final AppFocusService mAppFocusService;
	private final CarInputService mCarInputService;
	/**
	* TODO: (b/121277787) Remove this on master.
	* @deprecated CarInstrumentClusterManager is being deprecated.
	*/
	@Deprecated
	private final ClusterManagerService mClusterManagerService = new ClusterManagerService();
	private final Object mLock = new Object();
	@GuardedBy("mLock")
	private ContextOwner mNavContextOwner = NO_OWNER;
	@GuardedBy("mLock")
	private IInstrumentCluster mRendererService;
	// If renderer service crashed / stopped and this class fails to rebind with it immediately,
	// we should wait some time before next attempt. This may happen during APK update for example.
	@GuardedBy("mLock")
	private DeferredRebinder mDeferredRebinder;
	// Whether {@link android.car.cluster.renderer.InstrumentClusterRendererService} is bound
	// (although not necessarily connected)
	@GuardedBy("mLock")
	private boolean mRendererBound = false;

	/**
	* Connection to {@link android.car.cluster.renderer.InstrumentClusterRendererService}
	*/
	private final ServiceConnection mRendererServiceConnection = new ServiceConnection() {
	@Override
	public void onServiceConnected(ComponentName name, IBinder binder) {
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "onServiceConnected, name: " + name + ", binder: " + binder);
	}
	IInstrumentCluster service = IInstrumentCluster.Stub.asInterface(binder);
	ContextOwner navContextOwner;
	synchronized (mLock) {
	mRendererService = service;
	navContextOwner = mNavContextOwner;
	}
	if (navContextOwner != null && service != null) {
	notifyNavContextOwnerChanged(service, navContextOwner);
	}
	}

	@Override
	public void onServiceDisconnected(ComponentName name) {
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "onServiceDisconnected, name: " + name);
	}
	mContext.unbindService(this);
	DeferredRebinder rebinder;
	synchronized (mLock) {
	mRendererBound = false;
	mRendererService = null;
	if (mDeferredRebinder == null) {
	mDeferredRebinder = new DeferredRebinder();
	}
	rebinder = mDeferredRebinder;
	}
	rebinder.rebind();
	}
	};

	private final IInstrumentClusterHelper mInstrumentClusterHelper =
	new IInstrumentClusterHelper.Stub() {
	@Override
	public boolean startFixedActivityModeForDisplayAndUser(Intent intent,
	Bundle activityOptionsBundle, int userId) {
	Binder.clearCallingIdentity();
	ActivityOptions options = new ActivityOptions(activityOptionsBundle);
	FixedActivityService service = CarLocalServices.getService(
	FixedActivityService.class);
	return service.startFixedActivityModeForDisplayAndUser(intent, options,
	options.getLaunchDisplayId(), userId);
	}

	@Override
	public void stopFixedActivityMode(int displayId) {
	Binder.clearCallingIdentity();
	FixedActivityService service = CarLocalServices.getService(
	FixedActivityService.class);
	service.stopFixedActivityMode(displayId);
	}
	};

	public InstrumentClusterService(Context context, AppFocusService appFocusService,
	CarInputService carInputService) {
	mContext = context;
	mAppFocusService = appFocusService;
	mCarInputService = carInputService;
	}

	@Override
	public void init() {
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "init");
	}

	mAppFocusService.registerContextOwnerChangedCallback(this /* FocusOwnershipCallback */);
	mCarInputService.setInstrumentClusterKeyListener(this /* KeyEventListener */);
	// TODO(b/124246323) Start earlier once data storage for cluster is clarified
	// for early boot.
	CarLocalServices.getService(CarUserService.class).runOnUser0Unlock(() -> {
	mRendererBound = bindInstrumentClusterRendererService();
	});
	}

	@Override
	public void release() {
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "release");
	}

	mAppFocusService.unregisterContextOwnerChangedCallback(this);
	if (mRendererBound) {
	mContext.unbindService(mRendererServiceConnection);
	mRendererBound = false;
	}
	}

	@Override
	public void dump(PrintWriter writer) {
	writer.println("" + getClass().getSimpleName() + "");
	writer.println("bound with renderer: " + mRendererBound);
	writer.println("renderer service: " + mRendererService);
	writer.println("context owner: " + mNavContextOwner);
	}

	@Override
	public void onFocusAcquired(int appType, int uid, int pid) {
	changeNavContextOwner(appType, uid, pid, true);
	}

	@Override
	public void onFocusAbandoned(int appType, int uid, int pid) {
	changeNavContextOwner(appType, uid, pid, false);
	}

	private void changeNavContextOwner(int appType, int uid, int pid, boolean acquire) {
	if (appType != CarAppFocusManager.APP_FOCUS_TYPE_NAVIGATION) {
	return;
	}

	IInstrumentCluster service;
	ContextOwner requester = new ContextOwner(uid, pid);
	ContextOwner newOwner = acquire ? requester : NO_OWNER;
	synchronized (mLock) {
	if ((acquire && Objects.equals(mNavContextOwner, requester))
	\|\| (!acquire && !Objects.equals(mNavContextOwner, requester))) {
	// Nothing to do here. Either the same owner is acquiring twice, or someone is
	// abandoning a focus they didn't have.
	Log.w(TAG, "Invalid nav context owner change (acquiring: " + acquire
	+ "), current owner: [" + mNavContextOwner
	+ "], requester: [" + requester + "]");
	return;
	}

	mNavContextOwner = newOwner;
	service = mRendererService;
	}

	if (service != null) {
	notifyNavContextOwnerChanged(service, newOwner);
	}
	}

	private static void notifyNavContextOwnerChanged(IInstrumentCluster service,
	ContextOwner owner) {
	try {
	service.setNavigationContextOwner(owner.uid, owner.pid);
	} catch (RemoteException e) {
	Log.e(TAG, "Failed to call setNavigationContextOwner", e);
	}
	}

	private boolean bindInstrumentClusterRendererService() {
	String rendererService = mContext.getString(R.string.instrumentClusterRendererService);
	if (TextUtils.isEmpty(rendererService)) {
	Log.i(TAG, "Instrument cluster renderer was not configured");
	return false;
	}

	Log.d(TAG, "bindInstrumentClusterRendererService, component: " + rendererService);

	Intent intent = new Intent();
	intent.setComponent(ComponentName.unflattenFromString(rendererService));
	// Litle bit inefficiency here as Intent.getIBinderExtra() is a hidden API.
	Bundle bundle = new Bundle();
	bundle.putBinder(EXTRA_BUNDLE_KEY_FOR_INSTRUMENT_CLUSTER_HELPER,
	mInstrumentClusterHelper.asBinder());
	intent.putExtra(EXTRA_BUNDLE_KEY_FOR_INSTRUMENT_CLUSTER_HELPER, bundle);
	return mContext.bindServiceAsUser(intent, mRendererServiceConnection,
	Context.BIND_AUTO_CREATE \| Context.BIND_IMPORTANT, UserHandle.SYSTEM);
	}

	@Nullable
	public IInstrumentClusterNavigation getNavigationService() {
	try {
	IInstrumentCluster service = getInstrumentClusterRendererService();
	return service == null ? null : service.getNavigationService();
	} catch (RemoteException e) {
	Log.e(TAG, "getNavigationServiceBinder" , e);
	return null;
	}
	}

	/**
	* @deprecated {@link android.car.cluster.CarInstrumentClusterManager} is now deprecated.
	*/
	@Deprecated
	public IInstrumentClusterManagerService.Stub getManagerService() {
	return mClusterManagerService;
	}

	@Override
	public void onKeyEvent(KeyEvent event) {
	if (Log.isLoggable(TAG, Log.DEBUG)) {
	Log.d(TAG, "InstrumentClusterService#onKeyEvent: " + event);
	}

	IInstrumentCluster service = getInstrumentClusterRendererService();
	if (service != null) {
	try {
	service.onKeyEvent(event);
	} catch (RemoteException e) {
	Log.e(TAG, "onKeyEvent", e);
	}
	}
	}

	private IInstrumentCluster getInstrumentClusterRendererService() {
	IInstrumentCluster service;
	synchronized (mLock) {
	service = mRendererService;
	}
	return service;
	}

	private static class ContextOwner {
	final int uid;
	final int pid;

	ContextOwner(int uid, int pid) {
	this.uid = uid;
	this.pid = pid;
	}

	@Override
	public String toString() {
	return "uid: " + uid + ", pid: " + pid;
	}

	@Override
	public boolean equals(Object o) {
	if (this == o) return true;
	if (o == null \|\| getClass() != o.getClass()) return false;
	ContextOwner that = (ContextOwner) o;
	return uid == that.uid && pid == that.pid;
	}

	@Override
	public int hashCode() {
	return Objects.hash(uid, pid);
	}
	}

	/**
	* TODO: (b/121277787) Remove on master
	* @deprecated CarClusterManager is being deprecated.
	*/
	@Deprecated
	private class ClusterManagerService extends IInstrumentClusterManagerService.Stub {
	@Override
	public void startClusterActivity(Intent intent) throws RemoteException {
	// No op.
	}

	@Override
	public void registerCallback(IInstrumentClusterManagerCallback callback)
	throws RemoteException {
	// No op.
	}

	@Override
	public void unregisterCallback(IInstrumentClusterManagerCallback callback)
	throws RemoteException {
	// No op.
	}
	}

	private class DeferredRebinder extends Handler {
	private static final long NEXT_REBIND_ATTEMPT_DELAY_MS = 1000L;
	private static final int NUMBER_OF_ATTEMPTS = 10;

	public void rebind() {
	mRendererBound = bindInstrumentClusterRendererService();

	if (!mRendererBound) {
	removeMessages(0);
	sendMessageDelayed(obtainMessage(0, NUMBER_OF_ATTEMPTS, 0),
	NEXT_REBIND_ATTEMPT_DELAY_MS);
	}
	}

	@Override
	public void handleMessage(Message msg) {
	mRendererBound = bindInstrumentClusterRendererService();

	if (mRendererBound) {
	Log.w(TAG, "Failed to bound to render service, next attempt in "
	+ NEXT_REBIND_ATTEMPT_DELAY_MS + "ms.");

	int attempts = msg.arg1;
	if (--attempts >= 0) {
	sendMessageDelayed(obtainMessage(0, attempts, 0), NEXT_REBIND_ATTEMPT_DELAY_MS);
	} else {
	Log.wtf(TAG, "Failed to rebind with cluster rendering service");
	}
	}
	}
	}
	}