services/core/java/com/android/server/camera/CameraServiceProxy.java - platform/frameworks/base - Git at Google

 /*
  * Copyright 2015 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.server.camera;

 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
 import android.content.IntentFilter;
 import android.hardware.ICameraService;
 import android.hardware.ICameraServiceProxy;
 import android.metrics.LogMaker;
 import android.nfc.INfcAdapter;
 import android.os.Binder;
 import android.os.Handler;
 import android.os.IBinder;
 import android.os.Message;
 import android.os.Process;
 import android.os.RemoteException;
 import android.os.SystemClock;
 import android.os.SystemProperties;
 import android.os.UserManager;
 import android.util.ArrayMap;
 import android.util.ArraySet;
 import android.util.Slog;

 import com.android.internal.logging.MetricsLogger;
 import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
 import com.android.server.LocalServices;
 import com.android.server.ServiceThread;
 import com.android.server.SystemService;

 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.List;
 import java.util.Set;

 /**
  * CameraServiceProxy is the system_server analog to the camera service running in mediaserver.
  *
  * @hide
  */
 public class CameraServiceProxy extends SystemService
         implements Handler.Callback, IBinder.DeathRecipient {
     private static final String TAG = "CameraService_proxy";
     private static final boolean DEBUG = false;

     /**
      * This must match the ICameraService.aidl definition
      */
     private static final String CAMERA_SERVICE_BINDER_NAME = "media.camera";

     public static final String CAMERA_SERVICE_PROXY_BINDER_NAME = "media.camera.proxy";

     // Flags arguments to NFC adapter to enable/disable NFC
     public static final int DISABLE_POLLING_FLAGS = 0x1000;
     public static final int ENABLE_POLLING_FLAGS = 0x0000;

     // Handler message codes
     private static final int MSG_SWITCH_USER = 1;

     private static final int RETRY_DELAY_TIME = 20; //ms

     // Maximum entries to keep in usage history before dumping out
     private static final int MAX_USAGE_HISTORY = 100;

     private final Context mContext;
     private final ServiceThread mHandlerThread;
     private final Handler mHandler;
     private UserManager mUserManager;

     private final Object mLock = new Object();
     private Set<Integer> mEnabledCameraUsers;
     private int mLastUser;

     private ICameraService mCameraServiceRaw;

     private final ArrayMap<String, CameraUsageEvent> mActiveCameraUsage = new ArrayMap<>();
     private final List<CameraUsageEvent> mCameraUsageHistory = new ArrayList<>();
     private final MetricsLogger mLogger = new MetricsLogger();
     private static final String NFC_NOTIFICATION_PROP = "ro.camera.notify_nfc";
     private static final String NFC_SERVICE_BINDER_NAME = "nfc";
     private static final IBinder nfcInterfaceToken = new Binder();

     private final boolean mNotifyNfc;

     /**
      * Structure to track camera usage
      */
     private static class CameraUsageEvent {
         public final int mCameraFacing;
         public final String mClientName;

         private boolean mCompleted;
         private long mDurationOrStartTimeMs;  // Either start time, or duration once completed

         public CameraUsageEvent(int facing, String clientName) {
             mCameraFacing = facing;
             mClientName = clientName;
             mDurationOrStartTimeMs = SystemClock.elapsedRealtime();
             mCompleted = false;
         }

         public void markCompleted() {
             if (mCompleted) {
                 return;
             }
             mCompleted = true;
             mDurationOrStartTimeMs = SystemClock.elapsedRealtime() - mDurationOrStartTimeMs;
             if (CameraServiceProxy.DEBUG) {
                 Slog.v(TAG, "A camera facing " + cameraFacingToString(mCameraFacing) +
                         " was in use by " + mClientName + " for " +
                         mDurationOrStartTimeMs + " ms");
             }
         }

         /**
          * Return duration of camera usage event, or 0 if the event is not done
          */
         public long getDuration() {
             return mCompleted ? mDurationOrStartTimeMs : 0;
         }
     }

     private final BroadcastReceiver mIntentReceiver = new BroadcastReceiver() {
         @Override
         public void onReceive(Context context, Intent intent) {
             final String action = intent.getAction();
             if (action == null) return;

             switch (action) {
                 case Intent.ACTION_USER_ADDED:
                 case Intent.ACTION_USER_REMOVED:
                 case Intent.ACTION_USER_INFO_CHANGED:
                 case Intent.ACTION_MANAGED_PROFILE_ADDED:
                 case Intent.ACTION_MANAGED_PROFILE_REMOVED:
                     synchronized(mLock) {
                         // Return immediately if we haven't seen any users start yet
                         if (mEnabledCameraUsers == null) return;
                         switchUserLocked(mLastUser);
                     }
                     break;
                 default:
                     break; // do nothing
             }

         }
     };

     private final ICameraServiceProxy.Stub mCameraServiceProxy = new ICameraServiceProxy.Stub() {
         @Override
         public void pingForUserUpdate() {
             notifySwitchWithRetries(30);
         }

         @Override
         public void notifyCameraState(String cameraId, int newCameraState, int facing,
                 String clientName) {
             String state = cameraStateToString(newCameraState);
             String facingStr = cameraFacingToString(facing);
             if (DEBUG) Slog.v(TAG, "Camera " + cameraId + " facing " + facingStr + " state now " +
                     state + " for client " + clientName);

             updateActivityCount(cameraId, newCameraState, facing, clientName);
         }
     };

     public CameraServiceProxy(Context context) {
         super(context);
         mContext = context;
         mHandlerThread = new ServiceThread(TAG, Process.THREAD_PRIORITY_DISPLAY, /*allowTo*/false);
         mHandlerThread.start();
         mHandler = new Handler(mHandlerThread.getLooper(), this);

         mNotifyNfc = SystemProperties.getInt(NFC_NOTIFICATION_PROP, 0) > 0;
         if (DEBUG) Slog.v(TAG, "Notify NFC behavior is " + (mNotifyNfc ? "active" : "disabled"));
     }

     @Override
     public boolean handleMessage(Message msg) {
         switch(msg.what) {
             case MSG_SWITCH_USER: {
                 notifySwitchWithRetries(msg.arg1);
             } break;
             default: {
                 Slog.e(TAG, "CameraServiceProxy error, invalid message: " + msg.what);
             } break;
         }
         return true;
     }

     @Override
     public void onStart() {
         mUserManager = UserManager.get(mContext);
         if (mUserManager == null) {
             // Should never see this unless someone messes up the SystemServer service boot order.
             throw new IllegalStateException("UserManagerService must start before" +
                     " CameraServiceProxy!");
         }

         IntentFilter filter = new IntentFilter();
         filter.addAction(Intent.ACTION_USER_ADDED);
         filter.addAction(Intent.ACTION_USER_REMOVED);
         filter.addAction(Intent.ACTION_USER_INFO_CHANGED);
         filter.addAction(Intent.ACTION_MANAGED_PROFILE_ADDED);
         filter.addAction(Intent.ACTION_MANAGED_PROFILE_REMOVED);
         mContext.registerReceiver(mIntentReceiver, filter);

         publishBinderService(CAMERA_SERVICE_PROXY_BINDER_NAME, mCameraServiceProxy);
         publishLocalService(CameraServiceProxy.class, this);

         CameraStatsJobService.schedule(mContext);
     }

     @Override
     public void onStartUser(int userHandle) {
         synchronized(mLock) {
             if (mEnabledCameraUsers == null) {
                 // Initialize mediaserver, or update mediaserver if we are recovering from a crash.
                 switchUserLocked(userHandle);
             }
         }
     }

     @Override
     public void onSwitchUser(int userHandle) {
         synchronized(mLock) {
             switchUserLocked(userHandle);
         }
     }

     /**
      * Handle the death of the native camera service
      */
     @Override
     public void binderDied() {
         if (DEBUG) Slog.w(TAG, "Native camera service has died");
         synchronized(mLock) {
             mCameraServiceRaw = null;

             // All cameras reset to idle on camera service death
             boolean wasEmpty = mActiveCameraUsage.isEmpty();
             mActiveCameraUsage.clear();

             if ( mNotifyNfc && !wasEmpty ) {
                 notifyNfcService(/*enablePolling*/ true);
             }
         }
     }

     /**
      * Dump camera usage events to log.
      * Package-private
      */
     void dumpUsageEvents() {
         synchronized(mLock) {
             // Randomize order of events so that it's not meaningful
             Collections.shuffle(mCameraUsageHistory);
             for (CameraUsageEvent e : mCameraUsageHistory) {
                 if (DEBUG) {
                     Slog.v(TAG, "Camera: " + e.mClientName + " used a camera facing " +
                             cameraFacingToString(e.mCameraFacing) + " for " +
                             e.getDuration() + " ms");
                 }
                 int subtype = 0;
                 switch(e.mCameraFacing) {
                     case ICameraServiceProxy.CAMERA_FACING_BACK:
                         subtype = MetricsEvent.CAMERA_BACK_USED;
                         break;
                     case ICameraServiceProxy.CAMERA_FACING_FRONT:
                         subtype = MetricsEvent.CAMERA_FRONT_USED;
                         break;
                     case ICameraServiceProxy.CAMERA_FACING_EXTERNAL:
                         subtype = MetricsEvent.CAMERA_EXTERNAL_USED;
                         break;
                     default:
                         continue;
                 }
                 LogMaker l = new LogMaker(MetricsEvent.ACTION_CAMERA_EVENT)
                         .setType(MetricsEvent.TYPE_ACTION)
                         .setSubtype(subtype)
                         .setLatency(e.getDuration())
                         .setPackageName(e.mClientName);
                 mLogger.write(l);
             }
             mCameraUsageHistory.clear();
         }
         CameraStatsJobService.schedule(mContext);
     }

     private void switchUserLocked(int userHandle) {
         Set<Integer> currentUserHandles = getEnabledUserHandles(userHandle);
         mLastUser = userHandle;
         if (mEnabledCameraUsers == null || !mEnabledCameraUsers.equals(currentUserHandles)) {
             // Some user handles have been added or removed, update mediaserver.
             mEnabledCameraUsers = currentUserHandles;
             notifyMediaserverLocked(ICameraService.EVENT_USER_SWITCHED, currentUserHandles);
         }
     }

     private Set<Integer> getEnabledUserHandles(int currentUserHandle) {
         int[] userProfiles = mUserManager.getEnabledProfileIds(currentUserHandle);
         Set<Integer> handles = new ArraySet<>(userProfiles.length);

         for (int id : userProfiles) {
             handles.add(id);
         }

         return handles;
     }

     private void notifySwitchWithRetries(int retries) {
         synchronized(mLock) {
             if (mEnabledCameraUsers == null) {
                 return;
             }
             if (notifyMediaserverLocked(ICameraService.EVENT_USER_SWITCHED, mEnabledCameraUsers)) {
                 retries = 0;
             }
         }
         if (retries <= 0) {
             return;
         }
         Slog.i(TAG, "Could not notify camera service of user switch, retrying...");
         mHandler.sendMessageDelayed(mHandler.obtainMessage(MSG_SWITCH_USER, retries - 1, 0, null),
                 RETRY_DELAY_TIME);
     }

     private boolean notifyMediaserverLocked(int eventType, Set<Integer> updatedUserHandles) {
         // Forward the user switch event to the native camera service running in the mediaserver
         // process.
         if (mCameraServiceRaw == null) {
             IBinder cameraServiceBinder = getBinderService(CAMERA_SERVICE_BINDER_NAME);
             if (cameraServiceBinder == null) {
                 Slog.w(TAG, "Could not notify mediaserver, camera service not available.");
                 return false; // Camera service not active, cannot evict user clients.
             }
             try {
                 cameraServiceBinder.linkToDeath(this, /*flags*/ 0);
             } catch (RemoteException e) {
                 Slog.w(TAG, "Could not link to death of native camera service");
                 return false;
             }

             mCameraServiceRaw = ICameraService.Stub.asInterface(cameraServiceBinder);
         }

         try {
             mCameraServiceRaw.notifySystemEvent(eventType, toArray(updatedUserHandles));
         } catch (RemoteException e) {
             Slog.w(TAG, "Could not notify mediaserver, remote exception: " + e);
             // Not much we can do if camera service is dead.
             return false;
         }
         return true;
     }

     private void updateActivityCount(String cameraId, int newCameraState, int facing, String clientName) {
         synchronized(mLock) {
             // Update active camera list and notify NFC if necessary
             boolean wasEmpty = mActiveCameraUsage.isEmpty();
             switch (newCameraState) {
                 case ICameraServiceProxy.CAMERA_STATE_OPEN:
                     break;
                 case ICameraServiceProxy.CAMERA_STATE_ACTIVE:
                     CameraUsageEvent newEvent = new CameraUsageEvent(facing, clientName);
                     CameraUsageEvent oldEvent = mActiveCameraUsage.put(cameraId, newEvent);
                     if (oldEvent != null) {
                         Slog.w(TAG, "Camera " + cameraId + " was already marked as active");
                         oldEvent.markCompleted();
                         mCameraUsageHistory.add(oldEvent);
                     }
                     break;
                 case ICameraServiceProxy.CAMERA_STATE_IDLE:
                 case ICameraServiceProxy.CAMERA_STATE_CLOSED:
                     CameraUsageEvent doneEvent = mActiveCameraUsage.remove(cameraId);
                     if (doneEvent != null) {
                         doneEvent.markCompleted();
                         mCameraUsageHistory.add(doneEvent);
                         if (mCameraUsageHistory.size() > MAX_USAGE_HISTORY) {
                             dumpUsageEvents();
                         }
                     }
                     break;
             }
             boolean isEmpty = mActiveCameraUsage.isEmpty();
             if ( mNotifyNfc && (wasEmpty != isEmpty) ) {
                 notifyNfcService(isEmpty);
             }
         }
     }

     private void notifyNfcService(boolean enablePolling) {

         IBinder nfcServiceBinder = getBinderService(NFC_SERVICE_BINDER_NAME);
         if (nfcServiceBinder == null) {
             Slog.w(TAG, "Could not connect to NFC service to notify it of camera state");
             return;
         }
         INfcAdapter nfcAdapterRaw = INfcAdapter.Stub.asInterface(nfcServiceBinder);
         int flags = enablePolling ? ENABLE_POLLING_FLAGS : DISABLE_POLLING_FLAGS;
         if (DEBUG) Slog.v(TAG, "Setting NFC reader mode to flags " + flags);
         try {
             nfcAdapterRaw.setReaderMode(nfcInterfaceToken, null, flags, null);
         } catch (RemoteException e) {
             Slog.w(TAG, "Could not notify NFC service, remote exception: " + e);
         }
     }

     private static int[] toArray(Collection<Integer> c) {
         int len = c.size();
         int[] ret = new int[len];
         int idx = 0;
         for (Integer i : c) {
             ret[idx++] = i;
         }
         return ret;
     }

     private static String cameraStateToString(int newCameraState) {
         switch (newCameraState) {
             case ICameraServiceProxy.CAMERA_STATE_OPEN: return "CAMERA_STATE_OPEN";
             case ICameraServiceProxy.CAMERA_STATE_ACTIVE: return "CAMERA_STATE_ACTIVE";
             case ICameraServiceProxy.CAMERA_STATE_IDLE: return "CAMERA_STATE_IDLE";
             case ICameraServiceProxy.CAMERA_STATE_CLOSED: return "CAMERA_STATE_CLOSED";
             default: break;
         }
         return "CAMERA_STATE_UNKNOWN";
     }

     private static String cameraFacingToString(int cameraFacing) {
         switch (cameraFacing) {
             case ICameraServiceProxy.CAMERA_FACING_BACK: return "CAMERA_FACING_BACK";
             case ICameraServiceProxy.CAMERA_FACING_FRONT: return "CAMERA_FACING_FRONT";
             case ICameraServiceProxy.CAMERA_FACING_EXTERNAL: return "CAMERA_FACING_EXTERNAL";
             default: break;
         }
         return "CAMERA_FACING_UNKNOWN";
     }

 }
	/*
	* Copyright 2015 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.server.camera;

	import android.content.BroadcastReceiver;
	import android.content.Context;
	import android.content.Intent;
	import android.content.IntentFilter;
	import android.hardware.ICameraService;
	import android.hardware.ICameraServiceProxy;
	import android.metrics.LogMaker;
	import android.nfc.INfcAdapter;
	import android.os.Binder;
	import android.os.Handler;
	import android.os.IBinder;
	import android.os.Message;
	import android.os.Process;
	import android.os.RemoteException;
	import android.os.SystemClock;
	import android.os.SystemProperties;
	import android.os.UserManager;
	import android.util.ArrayMap;
	import android.util.ArraySet;
	import android.util.Slog;

	import com.android.internal.logging.MetricsLogger;
	import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
	import com.android.server.LocalServices;
	import com.android.server.ServiceThread;
	import com.android.server.SystemService;

	import java.util.ArrayList;
	import java.util.Collection;
	import java.util.Collections;
	import java.util.List;
	import java.util.Set;

	/**
	* CameraServiceProxy is the system_server analog to the camera service running in mediaserver.
	*
	* @hide
	*/
	public class CameraServiceProxy extends SystemService
	implements Handler.Callback, IBinder.DeathRecipient {
	private static final String TAG = "CameraService_proxy";
	private static final boolean DEBUG = false;

	/**
	* This must match the ICameraService.aidl definition
	*/
	private static final String CAMERA_SERVICE_BINDER_NAME = "media.camera";

	public static final String CAMERA_SERVICE_PROXY_BINDER_NAME = "media.camera.proxy";

	// Flags arguments to NFC adapter to enable/disable NFC
	public static final int DISABLE_POLLING_FLAGS = 0x1000;
	public static final int ENABLE_POLLING_FLAGS = 0x0000;

	// Handler message codes
	private static final int MSG_SWITCH_USER = 1;

	private static final int RETRY_DELAY_TIME = 20; //ms

	// Maximum entries to keep in usage history before dumping out
	private static final int MAX_USAGE_HISTORY = 100;

	private final Context mContext;
	private final ServiceThread mHandlerThread;
	private final Handler mHandler;
	private UserManager mUserManager;

	private final Object mLock = new Object();
	private Set<Integer> mEnabledCameraUsers;
	private int mLastUser;

	private ICameraService mCameraServiceRaw;

	private final ArrayMap<String, CameraUsageEvent> mActiveCameraUsage = new ArrayMap<>();
	private final List<CameraUsageEvent> mCameraUsageHistory = new ArrayList<>();
	private final MetricsLogger mLogger = new MetricsLogger();
	private static final String NFC_NOTIFICATION_PROP = "ro.camera.notify_nfc";
	private static final String NFC_SERVICE_BINDER_NAME = "nfc";
	private static final IBinder nfcInterfaceToken = new Binder();

	private final boolean mNotifyNfc;

	/**
	* Structure to track camera usage
	*/
	private static class CameraUsageEvent {
	public final int mCameraFacing;
	public final String mClientName;

	private boolean mCompleted;
	private long mDurationOrStartTimeMs; // Either start time, or duration once completed

	public CameraUsageEvent(int facing, String clientName) {
	mCameraFacing = facing;
	mClientName = clientName;
	mDurationOrStartTimeMs = SystemClock.elapsedRealtime();
	mCompleted = false;
	}

	public void markCompleted() {
	if (mCompleted) {
	return;
	}
	mCompleted = true;
	mDurationOrStartTimeMs = SystemClock.elapsedRealtime() - mDurationOrStartTimeMs;
	if (CameraServiceProxy.DEBUG) {
	Slog.v(TAG, "A camera facing " + cameraFacingToString(mCameraFacing) +
	" was in use by " + mClientName + " for " +
	mDurationOrStartTimeMs + " ms");
	}
	}

	/**
	* Return duration of camera usage event, or 0 if the event is not done
	*/
	public long getDuration() {
	return mCompleted ? mDurationOrStartTimeMs : 0;
	}
	}

	private final BroadcastReceiver mIntentReceiver = new BroadcastReceiver() {
	@Override
	public void onReceive(Context context, Intent intent) {
	final String action = intent.getAction();
	if (action == null) return;

	switch (action) {
	case Intent.ACTION_USER_ADDED:
	case Intent.ACTION_USER_REMOVED:
	case Intent.ACTION_USER_INFO_CHANGED:
	case Intent.ACTION_MANAGED_PROFILE_ADDED:
	case Intent.ACTION_MANAGED_PROFILE_REMOVED:
	synchronized(mLock) {
	// Return immediately if we haven't seen any users start yet
	if (mEnabledCameraUsers == null) return;
	switchUserLocked(mLastUser);
	}
	break;
	default:
	break; // do nothing
	}

	}
	};

	private final ICameraServiceProxy.Stub mCameraServiceProxy = new ICameraServiceProxy.Stub() {
	@Override
	public void pingForUserUpdate() {
	notifySwitchWithRetries(30);
	}

	@Override
	public void notifyCameraState(String cameraId, int newCameraState, int facing,
	String clientName) {
	String state = cameraStateToString(newCameraState);
	String facingStr = cameraFacingToString(facing);
	if (DEBUG) Slog.v(TAG, "Camera " + cameraId + " facing " + facingStr + " state now " +
	state + " for client " + clientName);

	updateActivityCount(cameraId, newCameraState, facing, clientName);
	}
	};

	public CameraServiceProxy(Context context) {
	super(context);
	mContext = context;
	mHandlerThread = new ServiceThread(TAG, Process.THREAD_PRIORITY_DISPLAY, /allowTo/false);
	mHandlerThread.start();
	mHandler = new Handler(mHandlerThread.getLooper(), this);

	mNotifyNfc = SystemProperties.getInt(NFC_NOTIFICATION_PROP, 0) > 0;
	if (DEBUG) Slog.v(TAG, "Notify NFC behavior is " + (mNotifyNfc ? "active" : "disabled"));
	}

	@Override
	public boolean handleMessage(Message msg) {
	switch(msg.what) {
	case MSG_SWITCH_USER: {
	notifySwitchWithRetries(msg.arg1);
	} break;
	default: {
	Slog.e(TAG, "CameraServiceProxy error, invalid message: " + msg.what);
	} break;
	}
	return true;
	}

	@Override
	public void onStart() {
	mUserManager = UserManager.get(mContext);
	if (mUserManager == null) {
	// Should never see this unless someone messes up the SystemServer service boot order.
	throw new IllegalStateException("UserManagerService must start before" +
	" CameraServiceProxy!");
	}

	IntentFilter filter = new IntentFilter();
	filter.addAction(Intent.ACTION_USER_ADDED);
	filter.addAction(Intent.ACTION_USER_REMOVED);
	filter.addAction(Intent.ACTION_USER_INFO_CHANGED);
	filter.addAction(Intent.ACTION_MANAGED_PROFILE_ADDED);
	filter.addAction(Intent.ACTION_MANAGED_PROFILE_REMOVED);
	mContext.registerReceiver(mIntentReceiver, filter);

	publishBinderService(CAMERA_SERVICE_PROXY_BINDER_NAME, mCameraServiceProxy);
	publishLocalService(CameraServiceProxy.class, this);

	CameraStatsJobService.schedule(mContext);
	}

	@Override
	public void onStartUser(int userHandle) {
	synchronized(mLock) {
	if (mEnabledCameraUsers == null) {
	// Initialize mediaserver, or update mediaserver if we are recovering from a crash.
	switchUserLocked(userHandle);
	}
	}
	}

	@Override
	public void onSwitchUser(int userHandle) {
	synchronized(mLock) {
	switchUserLocked(userHandle);
	}
	}

	/**
	* Handle the death of the native camera service
	*/
	@Override
	public void binderDied() {
	if (DEBUG) Slog.w(TAG, "Native camera service has died");
	synchronized(mLock) {
	mCameraServiceRaw = null;

	// All cameras reset to idle on camera service death
	boolean wasEmpty = mActiveCameraUsage.isEmpty();
	mActiveCameraUsage.clear();

	if ( mNotifyNfc && !wasEmpty ) {
	notifyNfcService(/enablePolling/ true);
	}
	}
	}

	/**
	* Dump camera usage events to log.
	* Package-private
	*/
	void dumpUsageEvents() {
	synchronized(mLock) {
	// Randomize order of events so that it's not meaningful
	Collections.shuffle(mCameraUsageHistory);
	for (CameraUsageEvent e : mCameraUsageHistory) {
	if (DEBUG) {
	Slog.v(TAG, "Camera: " + e.mClientName + " used a camera facing " +
	cameraFacingToString(e.mCameraFacing) + " for " +
	e.getDuration() + " ms");
	}
	int subtype = 0;
	switch(e.mCameraFacing) {
	case ICameraServiceProxy.CAMERA_FACING_BACK:
	subtype = MetricsEvent.CAMERA_BACK_USED;
	break;
	case ICameraServiceProxy.CAMERA_FACING_FRONT:
	subtype = MetricsEvent.CAMERA_FRONT_USED;
	break;
	case ICameraServiceProxy.CAMERA_FACING_EXTERNAL:
	subtype = MetricsEvent.CAMERA_EXTERNAL_USED;
	break;
	default:
	continue;
	}
	LogMaker l = new LogMaker(MetricsEvent.ACTION_CAMERA_EVENT)
	.setType(MetricsEvent.TYPE_ACTION)
	.setSubtype(subtype)
	.setLatency(e.getDuration())
	.setPackageName(e.mClientName);
	mLogger.write(l);
	}
	mCameraUsageHistory.clear();
	}
	CameraStatsJobService.schedule(mContext);
	}

	private void switchUserLocked(int userHandle) {
	Set<Integer> currentUserHandles = getEnabledUserHandles(userHandle);
	mLastUser = userHandle;
	if (mEnabledCameraUsers == null \|\| !mEnabledCameraUsers.equals(currentUserHandles)) {
	// Some user handles have been added or removed, update mediaserver.
	mEnabledCameraUsers = currentUserHandles;
	notifyMediaserverLocked(ICameraService.EVENT_USER_SWITCHED, currentUserHandles);
	}
	}

	private Set<Integer> getEnabledUserHandles(int currentUserHandle) {
	int[] userProfiles = mUserManager.getEnabledProfileIds(currentUserHandle);
	Set<Integer> handles = new ArraySet<>(userProfiles.length);

	for (int id : userProfiles) {
	handles.add(id);
	}

	return handles;
	}

	private void notifySwitchWithRetries(int retries) {
	synchronized(mLock) {
	if (mEnabledCameraUsers == null) {
	return;
	}
	if (notifyMediaserverLocked(ICameraService.EVENT_USER_SWITCHED, mEnabledCameraUsers)) {
	retries = 0;
	}
	}
	if (retries <= 0) {
	return;
	}
	Slog.i(TAG, "Could not notify camera service of user switch, retrying...");
	mHandler.sendMessageDelayed(mHandler.obtainMessage(MSG_SWITCH_USER, retries - 1, 0, null),
	RETRY_DELAY_TIME);
	}

	private boolean notifyMediaserverLocked(int eventType, Set<Integer> updatedUserHandles) {
	// Forward the user switch event to the native camera service running in the mediaserver
	// process.
	if (mCameraServiceRaw == null) {
	IBinder cameraServiceBinder = getBinderService(CAMERA_SERVICE_BINDER_NAME);
	if (cameraServiceBinder == null) {
	Slog.w(TAG, "Could not notify mediaserver, camera service not available.");
	return false; // Camera service not active, cannot evict user clients.
	}
	try {
	cameraServiceBinder.linkToDeath(this, /flags/ 0);
	} catch (RemoteException e) {
	Slog.w(TAG, "Could not link to death of native camera service");
	return false;
	}

	mCameraServiceRaw = ICameraService.Stub.asInterface(cameraServiceBinder);
	}

	try {
	mCameraServiceRaw.notifySystemEvent(eventType, toArray(updatedUserHandles));
	} catch (RemoteException e) {
	Slog.w(TAG, "Could not notify mediaserver, remote exception: " + e);
	// Not much we can do if camera service is dead.
	return false;
	}
	return true;
	}

	private void updateActivityCount(String cameraId, int newCameraState, int facing, String clientName) {
	synchronized(mLock) {
	// Update active camera list and notify NFC if necessary
	boolean wasEmpty = mActiveCameraUsage.isEmpty();
	switch (newCameraState) {
	case ICameraServiceProxy.CAMERA_STATE_OPEN:
	break;
	case ICameraServiceProxy.CAMERA_STATE_ACTIVE:
	CameraUsageEvent newEvent = new CameraUsageEvent(facing, clientName);
	CameraUsageEvent oldEvent = mActiveCameraUsage.put(cameraId, newEvent);
	if (oldEvent != null) {
	Slog.w(TAG, "Camera " + cameraId + " was already marked as active");
	oldEvent.markCompleted();
	mCameraUsageHistory.add(oldEvent);
	}
	break;
	case ICameraServiceProxy.CAMERA_STATE_IDLE:
	case ICameraServiceProxy.CAMERA_STATE_CLOSED:
	CameraUsageEvent doneEvent = mActiveCameraUsage.remove(cameraId);
	if (doneEvent != null) {
	doneEvent.markCompleted();
	mCameraUsageHistory.add(doneEvent);
	if (mCameraUsageHistory.size() > MAX_USAGE_HISTORY) {
	dumpUsageEvents();
	}
	}
	break;
	}
	boolean isEmpty = mActiveCameraUsage.isEmpty();
	if ( mNotifyNfc && (wasEmpty != isEmpty) ) {
	notifyNfcService(isEmpty);
	}
	}
	}

	private void notifyNfcService(boolean enablePolling) {

	IBinder nfcServiceBinder = getBinderService(NFC_SERVICE_BINDER_NAME);
	if (nfcServiceBinder == null) {
	Slog.w(TAG, "Could not connect to NFC service to notify it of camera state");
	return;
	}
	INfcAdapter nfcAdapterRaw = INfcAdapter.Stub.asInterface(nfcServiceBinder);
	int flags = enablePolling ? ENABLE_POLLING_FLAGS : DISABLE_POLLING_FLAGS;
	if (DEBUG) Slog.v(TAG, "Setting NFC reader mode to flags " + flags);
	try {
	nfcAdapterRaw.setReaderMode(nfcInterfaceToken, null, flags, null);
	} catch (RemoteException e) {
	Slog.w(TAG, "Could not notify NFC service, remote exception: " + e);
	}
	}

	private static int[] toArray(Collection<Integer> c) {
	int len = c.size();
	int[] ret = new int[len];
	int idx = 0;
	for (Integer i : c) {
	ret[idx++] = i;
	}
	return ret;
	}

	private static String cameraStateToString(int newCameraState) {
	switch (newCameraState) {
	case ICameraServiceProxy.CAMERA_STATE_OPEN: return "CAMERA_STATE_OPEN";
	case ICameraServiceProxy.CAMERA_STATE_ACTIVE: return "CAMERA_STATE_ACTIVE";
	case ICameraServiceProxy.CAMERA_STATE_IDLE: return "CAMERA_STATE_IDLE";
	case ICameraServiceProxy.CAMERA_STATE_CLOSED: return "CAMERA_STATE_CLOSED";
	default: break;
	}
	return "CAMERA_STATE_UNKNOWN";
	}

	private static String cameraFacingToString(int cameraFacing) {
	switch (cameraFacing) {
	case ICameraServiceProxy.CAMERA_FACING_BACK: return "CAMERA_FACING_BACK";
	case ICameraServiceProxy.CAMERA_FACING_FRONT: return "CAMERA_FACING_FRONT";
	case ICameraServiceProxy.CAMERA_FACING_EXTERNAL: return "CAMERA_FACING_EXTERNAL";
	default: break;
	}
	return "CAMERA_FACING_UNKNOWN";
	}

	}