Android camera: CameraManager Class

CameraManager向外提供的接口：
CameraManager manager = (CameraManager) activity.getSystemService(Context.CAMERA_SERVICE)
getCameraIdList()/ getCameraCharacteristics
openCamera(cameraID);
registerAvailability/TorchCallback

实现方法是通过3个内部类：
AvailabilityCallback : class
onCameraAvailable (no longer in use)
onCameraUnavailable

TorchCallback : class
onTorchModeChanged
onTorchModeUnavailable

CameraManagerGlobal : class

其中主要是CameraManagerGlobal，它的主要作用是建立了和camera service的连接，并注册camera service的Listener等等.
/**
* A per-process global camera manager instance, to retain a connection to the camera service,
* and to distribute camera availability notices to API-registered callbacks
*/
private static final class CameraManagerGlobal extends ICameraServiceListener.Stub
            implements IBinder.DeathRecipient {
        // Singleton instance
        private static final CameraManagerGlobal gCameraManager =
            new CameraManagerGlobal();
        /**
         * This must match the ICameraService definition
         */
        private static final String CAMERA_SERVICE_BINDER_NAME = "media.camera";
        // Access only through getCameraService to deal with binder death
        private ICameraService mCameraService;

        public ICameraService getCameraService() {
            synchronized(mLock) {
                connectCameraServiceLocked();
                return mCameraService;
            }
        }

        /**
         * Connect to the camera service if it's available, and set up listeners.
         * If the service is already connected, do nothing.
         *
         * <p>Sets mCameraService to a valid pointer or null if the connection does not succeed.</p>
         */
        private void connectCameraServiceLocked() {
            Log.i(TAG, "Connecting to camera service");

            IBinder cameraServiceBinder = ServiceManager.getService(CAMERA_SERVICE_BINDER_NAME);

            ICameraService cameraService = ICameraService.Stub.asInterface(cameraServiceBinder);

            try {
                CameraMetadataNative.setupGlobalVendorTagDescriptor();
            }
            try {
/*这里把client端实现的 camera service listener注册到service端*/
                CameraStatus[] cameraStatuses = cameraService.addListener(this);
                for (CameraStatus c : cameraStatuses) {
                    onStatusChangedLocked(c.status, c.cameraId);
                }
                mCameraService = cameraService;
            }
        }

这里的addListener(this)的具体实现是：
        /**
         * Callback from camera service notifying the process about camera availability changes
         */
        @Override
        public void onStatusChanged(int status, String cameraId) throws RemoteException {
            synchronized(mLock) {
                onStatusChangedLocked(status, cameraId);
            }
        }
      
        private void onStatusChangedLocked(int status, String id) {
            final int callbackCount = mCallbackMap.size();
            for (int i = 0; i < callbackCount; i++) {
                Handler handler = mCallbackMap.valueAt(i);
                final AvailabilityCallback callback = mCallbackMap.keyAt(i);


                postSingleUpdate(callback, handler, id, status);
            }
        }
        private void postSingleUpdate(final AvailabilityCallback callback, final Handler handler,
                final String id, final int status) {
            if (isAvailable(status)) {
                handler.post(
                    new Runnable() {
                        @Override
                        public void run() {
   /*这里使用户注册的回调函数起作用*/
                            callback.onCameraAvailable(id);
                        }
                    });
            } else {
                handler.post(
                    new Runnable() {
                        @Override
                        public void run() {
                            callback.onCameraUnavailable(id);
                        }
                    });
            }
        }

public void registerTorchCallback(TorchCallback callback, Handler handler) {
            synchronized(mLock) {
                connectCameraServiceLocked();


                Handler oldHandler = mTorchCallbackMap.put(callback, handler);
                // For new callbacks, provide initial torch information
                if (oldHandler == null) {
                    updateTorchCallbackLocked(callback, handler);
                }
}

public void registerAvailabilityCallback(AvailabilityCallback callback, Handler handler) {
            synchronized (mLock) {
                connectCameraServiceLocked();

                Handler oldHandler = mCallbackMap.put(callback, handler);
                // For new callbacks, provide initial availability information
                if (oldHandler == null) {
                    updateCallbackLocked(callback, handler);
                }
}
}