Android Multimedia框架总结（十九）Camera2框架C/S模型之CameraService启动及与Client连接过程

转载请把头部出处链接和尾部二维码一起转载，本文出自逆流的鱼yuiop：http://blog.csdn.net/hejjunlin/article/details/53150322

Agenda:

一张图看Camera2框架类图

CameraService启动

ICameraService.cpp

Camera2Client.h与Camera2Client.cpp

ICamera.h与 ICamera.cpp

Camera2Client与CameraService连接

一张图看Camera2框架类图：



CameraService启动

CameraService是在MediaServer启动过程中进行的

main_mediaserver.cpp (frameworks\av\media\mediaserver)



在 main函数中会执行到CameraService::instantiate()， CameraService 本身并没有实现这个方法

CameraService.h (frameworks\av\services\camera\libcameraservice)



BinderService.h (frameworks\native\include\binder)

在其父类中instantiate()函数，BinderService是一个模板类



CameraService.cpp (frameworks\av\services\camera\libcameraservice)



到这里，CameraService就启动了。

ICameraService.cpp



在\frameworks\av\services\camera

libcameraservice.so中相关文件

Camera2Client.h

namespace camera2 {

class StreamingProcessor;
class JpegProcessor;
class ZslProcessorInterface;
class CaptureSequencer;
class CallbackProcessor;

}

class IMemory;
/**
* Interface between android.hardware.Camera API and Camera HAL device for versions
* CAMERA_DEVICE_API_VERSION_2_0 and 3_0.
*/
class Camera2Client :
public Camera2ClientBase<CameraService::Client>
{
public:
/**
* ICamera interface (see ICamera for details)
*/

virtual void            disconnect();
virtual status_t        connect(const sp<ICameraClient>& client);
virtual status_t        lock();
virtual status_t        unlock();
virtual status_t        setPreviewTarget(
const sp<IGraphicBufferProducer>& bufferProducer);
virtual void            setPreviewCallbackFlag(int flag);
virtual status_t        setPreviewCallbackTarget(
const sp<IGraphicBufferProducer>& callbackProducer);

virtual status_t        startPreview();
virtual void            stopPreview();
virtual bool            previewEnabled();
virtual status_t        storeMetaDataInBuffers(bool enabled);
virtual status_t        startRecording();
virtual void            stopRecording();
virtual bool            recordingEnabled();
virtual void            releaseRecordingFrame(const sp<IMemory>& mem);
virtual status_t        autoFocus();
virtual status_t        cancelAutoFocus();
virtual status_t        takePicture(int msgType);
virtual status_t        setParameters(const String8& params);
virtual String8         getParameters() const;
virtual status_t        sendCommand(int32_t cmd, int32_t arg1, int32_t arg2);
virtual void            notifyError(ICameraDeviceCallbacks::CameraErrorCode errorCode,
const CaptureResultExtras& resultExtras);

/**
* Interface used by CameraService
*/

Camera2Client(const sp<CameraService>& cameraService,
const sp<ICameraClient>& cameraClient,
const String16& clientPackageName,
int cameraId,
int cameraFacing,
int clientPid,
uid_t clientUid,
int servicePid,
bool legacyMode);

virtual ~Camera2Client();

status_t initialize(CameraModule *module);

virtual status_t dump(int fd, const Vector<String16>& args);

/**
* Interface used by CameraDeviceBase
*/

virtual void notifyAutoFocus(uint8_t newState, int triggerId);
virtual void notifyAutoExposure(uint8_t newState, int triggerId);
virtual void notifyShutter(const CaptureResultExtras& resultExtras,
nsecs_t timestamp);

/**
* Interface used by independent components of Camera2Client.
*/

camera2::SharedParameters& getParameters();

int getPreviewStreamId() const;
int getCaptureStreamId() const;
int getCallbackStreamId() const;
int getRecordingStreamId() const;
int getZslStreamId() const;

status_t registerFrameListener(int32_t minId, int32_t maxId,
wp<camera2::FrameProcessor::FilteredListener> listener,
bool sendPartials = true);
status_t removeFrameListener(int32_t minId, int32_t maxId,
wp<camera2::FrameProcessor::FilteredListener> listener);

status_t stopStream();

// For the slowJpegMode to create jpeg stream when precapture sequence is done
status_t createJpegStreamL(camera2::Parameters ¶ms);

static size_t calculateBufferSize(int width, int height,
int format, int stride);

static const int32_t kPreviewRequestIdStart = 10000000;
static const int32_t kPreviewRequestIdEnd   = 20000000;

static const int32_t kRecordingRequestIdStart  = 20000000;
static const int32_t kRecordingRequestIdEnd    = 30000000;

static const int32_t kCaptureRequestIdStart = 30000000;
static const int32_t kCaptureRequestIdEnd   = 40000000;

// Constant strings for ATRACE logging
static const char* kAutofocusLabel;
static const char* kTakepictureLabel;

// Used with stream IDs
static const int NO_STREAM = -1;

private:
/** ICamera interface-related private members */
typedef camera2::Parameters Parameters;

status_t setPreviewWindowL(const sp<IBinder>& binder,
sp<Surface> window);
status_t startPreviewL(Parameters ¶ms, bool restart);
void     stopPreviewL();
status_t startRecordingL(Parameters ¶ms, bool restart);
bool     recordingEnabledL();

// Individual commands for sendCommand()
status_t commandStartSmoothZoomL();
status_t commandStopSmoothZoomL();
status_t commandSetDisplayOrientationL(int degrees);
status_t commandEnableShutterSoundL(bool enable);
status_t commandPlayRecordingSoundL();
status_t commandStartFaceDetectionL(int type);
status_t commandStopFaceDetectionL(Parameters ¶ms);
status_t commandEnableFocusMoveMsgL(bool enable);
status_t commandPingL();
status_t commandSetVideoBufferCountL(size_t count);
status_t commandSetVideoFormatL(int format, android_dataspace dataSpace);

// Current camera device configuration
camera2::SharedParameters mParameters;

/** Camera device-related private members */

void     setPreviewCallbackFlagL(Parameters ¶ms, int flag);
status_t updateRequests(Parameters ¶ms);

template <typename ProcessorT>
status_t updateProcessorStream(sp<ProcessorT> processor, Parameters params);
template <typename ProcessorT,
status_t (ProcessorT::*updateStreamF)(const Parameters &)>
status_t updateProcessorStream(sp<ProcessorT> processor, Parameters params);

sp<camera2::FrameProcessor> mFrameProcessor;

/* Preview/Recording related members */

sp<IBinder> mPreviewSurface;
sp<camera2::StreamingProcessor> mStreamingProcessor;

/** Preview callback related members */

sp<camera2::CallbackProcessor> mCallbackProcessor;

/* Still image capture related members */

sp<camera2::CaptureSequencer> mCaptureSequencer;
sp<camera2::JpegProcessor> mJpegProcessor;
sp<camera2::ZslProcessorInterface> mZslProcessor;
sp<Thread> mZslProcessorThread;

/** Notification-related members */

bool mAfInMotion;

/** Utility members */
bool mLegacyMode;

// Wait until the camera device has received the latest control settings
status_t syncWithDevice();

// Video snapshot jpeg size overriding helper function
status_t overrideVideoSnapshotSize(Parameters ¶ms);
};

}; // namespace android

\frameworks\av\services\camera\libcameraservice\api1

Camera2Client.cpp

//create by 逆流的鱼yuiop on 2016/11/13
//blog地址：http://blog.csdn.net/hejjunlin
status_t Camera2Client::startPreview() {
ATRACE_CALL();
ALOGV("%s: E", __FUNCTION__);
Mutex::Autolock icl(mBinderSerializationLock);
status_t res;
if ( (res = checkPid(__FUNCTION__) ) != OK) return res;
SharedParameters::Lock l(mParameters);
return startPreviewL(l.mParameters, false);
}

status_t Camera2Client::startPreviewL(Parameters ¶ms, bool restart) {
ATRACE_CALL();
status_t res;

ALOGV("%s: state == %d, restart = %d", __FUNCTION__, params.state, restart);

if ( (params.state == Parameters::PREVIEW ||
params.state == Parameters::RECORD ||
params.state == Parameters::VIDEO_SNAPSHOT)
&& !restart) {
// Succeed attempt to re-enter a streaming state
ALOGI("%s: Camera %d: Preview already active, ignoring restart",
__FUNCTION__, mCameraId);
return OK;
}
if (params.state > Parameters::PREVIEW && !restart) {
ALOGE("%s: Can't start preview in state %s",
__FUNCTION__,
Parameters::getStateName(params.state));
return INVALID_OPERATION;
}

if (!mStreamingProcessor->haveValidPreviewWindow()) {
params.state = Parameters::WAITING_FOR_PREVIEW_WINDOW;
return OK;
}
params.state = Parameters::STOPPED;
int lastPreviewStreamId = mStreamingProcessor->getPreviewStreamId();

res = mStreamingProcessor->updatePreviewStream(params);
if (res != OK) {
ALOGE("%s: Camera %d: Unable to update preview stream: %s (%d)",
__FUNCTION__, mCameraId, strerror(-res), res);
return res;
}

bool previewStreamChanged = mStreamingProcessor->getPreviewStreamId() != lastPreviewStreamId;

// We could wait to create the JPEG output stream until first actual use
// (first takePicture call). However, this would substantially increase the
// first capture latency on HAL3 devices, and potentially on some HAL2
// devices. So create it unconditionally at preview start. As a drawback,
// this increases gralloc memory consumption for applications that don't
// ever take a picture. Do not enter this mode when jpeg stream will slow
// down preview.
// TODO: Find a better compromise, though this likely would involve HAL
// changes.
int lastJpegStreamId = mJpegProcessor->getStreamId();
// If jpeg stream will slow down preview, make sure we remove it before starting preview
if (params.slowJpegMode) {
mJpegProcessor->deleteStream();
} else {
res = updateProcessorStream(mJpegProcessor, params);
if (res != OK) {
ALOGE("%s: Camera %d: Can't pre-configure still image "
"stream: %s (%d)",
__FUNCTION__, mCameraId, strerror(-res), res);
return res;
}
}
bool jpegStreamChanged = mJpegProcessor->getStreamId() != lastJpegStreamId;

Vector<int32_t> outputStreams;
bool callbacksEnabled = (params.previewCallbackFlags &
CAMERA_FRAME_CALLBACK_FLAG_ENABLE_MASK) ||
params.previewCallbackSurface;

if (callbacksEnabled) {
// Can't have recording stream hanging around when enabling callbacks,
// since it exceeds the max stream count on some devices.
if (mStreamingProcessor->getRecordingStreamId() != NO_STREAM) {
ALOGV("%s: Camera %d: Clearing out recording stream before "
"creating callback stream", __FUNCTION__, mCameraId);
res = mStreamingProcessor->stopStream();
if (res != OK) {
ALOGE("%s: Camera %d: Can't stop streaming to delete "
"recording stream", __FUNCTION__, mCameraId);
return res;
}
res = mStreamingProcessor->deleteRecordingStream();
if (res != OK) {
ALOGE("%s: Camera %d: Unable to delete recording stream before "
"enabling callbacks: %s (%d)", __FUNCTION__, mCameraId,
strerror(-res), res);
return res;
}
}

res = mCallbackProcessor->updateStream(params);
if (res != OK) {
ALOGE("%s: Camera %d: Unable to update callback stream: %s (%d)",
__FUNCTION__, mCameraId, strerror(-res), res);
return res;
}
outputStreams.push(getCallbackStreamId());
} else if (previewStreamChanged && mCallbackProcessor->getStreamId() != NO_STREAM) {
/**
* Delete the unused callback stream when preview stream is changed and
* preview is not enabled. Don't need stop preview stream as preview is in
* STOPPED state now.
*/
ALOGV("%s: Camera %d: Delete unused preview callback stream.",  __FUNCTION__, mCameraId);
res = mCallbackProcessor->deleteStream();
if (res != OK) {
ALOGE("%s: Camera %d: Unable to delete callback stream %s (%d)",
__FUNCTION__, mCameraId, strerror(-res), res);
return res;
}
}

if (params.zslMode && !params.recordingHint &&
getRecordingStreamId() == NO_STREAM) {
res = updateProcessorStream(mZslProcessor, params);
if (res != OK) {
ALOGE("%s: Camera %d: Unable to update ZSL stream: %s (%d)",
__FUNCTION__, mCameraId, strerror(-res), res);
return res;
}

if (jpegStreamChanged) {
ALOGV("%s: Camera %d: Clear ZSL buffer queue when Jpeg size is changed",
__FUNCTION__, mCameraId);
mZslProcessor->clearZslQueue();
}
outputStreams.push(getZslStreamId());
} else {
mZslProcessor->deleteStream();
}

outputStreams.push(getPreviewStreamId());

if (!params.recordingHint) {
if (!restart) {
res = mStreamingProcessor->updatePreviewRequest(params);
if (res != OK) {
ALOGE("%s: Camera %d: Can't set up preview request: "
"%s (%d)", __FUNCTION__, mCameraId,
strerror(-res), res);
return res;
}
}
res = mStreamingProcessor->startStream(StreamingProcessor::PREVIEW,
outputStreams);
} else {
if (!restart) {
res = mStreamingProcessor->updateRecordingRequest(params);
if (res != OK) {
ALOGE("%s: Camera %d: Can't set up preview request with "
"record hint: %s (%d)", __FUNCTION__, mCameraId,
strerror(-res), res);
return res;
}
}
res = mStreamingProcessor->startStream(StreamingProcessor::RECORD,
outputStreams);
}
if (res != OK) {
ALOGE("%s: Camera %d: Unable to start streaming preview: %s (%d)",
__FUNCTION__, mCameraId, strerror(-res), res);
return res;
}

params.state = Parameters::PREVIEW;
return OK;
}

void Camera2Client::stopPreview() {
ATRACE_CALL();
ALOGV("%s: E", __FUNCTION__);
Mutex::Autolock icl(mBinderSerializationLock);
status_t res;
if ( (res = checkPid(__FUNCTION__) ) != OK) return;
stopPreviewL();
}

ICamera.h

//create by 逆流的鱼yuiop on 2016/11/13
//blog地址：http://blog.csdn.net/hejjunlin
namespace android {

class ICameraClient;
class IGraphicBufferProducer;
class Surface;

class ICamera: public IInterface
{
/**
* Keep up-to-date with ICamera.aidl in frameworks/base
*/
public:
DECLARE_META_INTERFACE(Camera);

virtual void            disconnect() = 0;

// connect new client with existing camera remote
virtual status_t        connect(const sp<ICameraClient>& client) = 0;

// prevent other processes from using this ICamera interface
virtual status_t        lock() = 0;

// allow other processes to use this ICamera interface
virtual status_t        unlock() = 0;

// pass the buffered IGraphicBufferProducer to the camera service
virtual status_t        setPreviewTarget(
const sp<IGraphicBufferProducer>& bufferProducer) = 0;

// set the preview callback flag to affect how the received frames from
// preview are handled. Enabling preview callback flags disables any active
// preview callback surface set by setPreviewCallbackTarget().
virtual void            setPreviewCallbackFlag(int flag) = 0;
// set a buffer interface to use for client-received preview frames instead
// of preview callback buffers. Passing a valid interface here disables any
// active preview callbacks set by setPreviewCallbackFlag(). Passing NULL
// disables the use of the callback target.
virtual status_t        setPreviewCallbackTarget(
const sp<IGraphicBufferProducer>& callbackProducer) = 0;

// start preview mode, must call setPreviewTarget first
virtual status_t        startPreview() = 0;

// stop preview mode
virtual void            stopPreview() = 0;

// get preview state
virtual bool            previewEnabled() = 0;

// start recording mode
virtual status_t        startRecording() = 0;

// stop recording mode
virtual void            stopRecording() = 0;

// get recording state
virtual bool            recordingEnabled() = 0;

// release a recording frame
virtual void            releaseRecordingFrame(const sp<IMemory>& mem) = 0;

// auto focus
virtual status_t        autoFocus() = 0;

// cancel auto focus
virtual status_t        cancelAutoFocus() = 0;

/*
* take a picture.
* @param msgType the message type an application selectively turn on/off
* on a photo-by-photo basis. The supported message types are:
* CAMERA_MSG_SHUTTER, CAMERA_MSG_RAW_IMAGE, CAMERA_MSG_COMPRESSED_IMAGE,
* and CAMERA_MSG_POSTVIEW_FRAME. Any other message types will be ignored.
*/
virtual status_t        takePicture(int msgType) = 0;

// set preview/capture parameters - key/value pairs
virtual status_t        setParameters(const String8& params) = 0;

// get preview/capture parameters - key/value pairs
virtual String8         getParameters() const = 0;

// send command to camera driver
virtual status_t        sendCommand(int32_t cmd, int32_t arg1, int32_t arg2) = 0;

// tell the camera hal to store meta data or real YUV data in video buffers.
virtual status_t        storeMetaDataInBuffers(bool enabled) = 0;
};

// ----------------------------------------------------------------------------

class BnCamera: public BnInterface<ICamera>
{
public:
virtual status_t    onTransact( uint32_t code,
const Parcel& data,
Parcel* reply,
uint32_t flags = 0);
};

}; // namespace android

#endif

ICamera.cpp

namespace android {

enum {
DISCONNECT = IBinder::FIRST_CALL_TRANSACTION,
SET_PREVIEW_TARGET,
SET_PREVIEW_CALLBACK_FLAG,
SET_PREVIEW_CALLBACK_TARGET,
START_PREVIEW,
STOP_PREVIEW,
AUTO_FOCUS,
CANCEL_AUTO_FOCUS,
TAKE_PICTURE,
SET_PARAMETERS,
GET_PARAMETERS,
SEND_COMMAND,
CONNECT,
LOCK,
UNLOCK,
PREVIEW_ENABLED,
START_RECORDING,
STOP_RECORDING,
RECORDING_ENABLED,
RELEASE_RECORDING_FRAME,
STORE_META_DATA_IN_BUFFERS,
};

class BpCamera: public BpInterface<ICamera>
{
public:
BpCamera(const sp<IBinder>& impl)
: BpInterface<ICamera>(impl)
{
}

// disconnect from camera service
void disconnect()
{
ALOGV("disconnect");
Parcel data, reply;
data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
remote()->transact(DISCONNECT, data, &reply);
reply.readExceptionCode();
}

// pass the buffered IGraphicBufferProducer to the camera service
status_t setPreviewTarget(const sp<IGraphicBufferProducer>& bufferProducer)
{
ALOGV("setPreviewTarget");
Parcel data, reply;
data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
sp<IBinder> b(IInterface::asBinder(bufferProducer));
data.writeStrongBinder(b);
remote()->transact(SET_PREVIEW_TARGET, data, &reply);
return reply.readInt32();
}

// set the preview callback flag to affect how the received frames from
// preview are handled. See Camera.h for details.
void setPreviewCallbackFlag(int flag)
{
ALOGV("setPreviewCallbackFlag(%d)", flag);
Parcel data, reply;
data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
data.writeInt32(flag);
remote()->transact(SET_PREVIEW_CALLBACK_FLAG, data, &reply);
}

status_t setPreviewCallbackTarget(
const sp<IGraphicBufferProducer>& callbackProducer)
{
ALOGV("setPreviewCallbackTarget");
Parcel data, reply;
data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
sp<IBinder> b(IInterface::asBinder(callbackProducer));
data.writeStrongBinder(b);
remote()->transact(SET_PREVIEW_CALLBACK_TARGET, data, &reply);
return reply.readInt32();
}

// start preview mode, must call setPreviewTarget first
status_t startPreview()
{
ALOGV("startPreview");
Parcel data, reply;
data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
remote()->transact(START_PREVIEW, data, &reply);
return reply.readInt32();
}

// start recording mode, must call setPreviewTarget first
status_t startRecording()
{
ALOGV("startRecording");
Parcel data, reply;
data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
remote()->transact(START_RECORDING, data, &reply);
return reply.readInt32();
}

// stop preview mode
void stopPreview()
{
ALOGV("stopPreview");
Parcel data, reply;
data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
remote()->transact(STOP_PREVIEW, data, &reply);
}

// stop recording mode
void stopRecording()
{
ALOGV("stopRecording");
Parcel data, reply;
data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
remote()->transact(STOP_RECORDING, data, &reply);
}

void releaseRecordingFrame(const sp<IMemory>& mem)
{
ALOGV("releaseRecordingFrame");
Parcel data, reply;
data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
data.writeStrongBinder(IInterface::asBinder(mem));
remote()->transact(RELEASE_RECORDING_FRAME, data, &reply);
}

status_t storeMetaDataInBuffers(bool enabled)
{
ALOGV("storeMetaDataInBuffers: %s", enabled? "true": "false");
Parcel data, reply;
data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
data.writeInt32(enabled);
remote()->transact(STORE_META_DATA_IN_BUFFERS, data, &reply);
return reply.readInt32();
}

// check preview state
bool previewEnabled()
{
ALOGV("previewEnabled");
Parcel data, reply;
data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
remote()->transact(PREVIEW_ENABLED, data, &reply);
return reply.readInt32();
}

// check recording state
bool recordingEnabled()
{
ALOGV("recordingEnabled");
Parcel data, reply;
data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
remote()->transact(RECORDING_ENABLED, data, &reply);
return reply.readInt32();
}

// auto focus
status_t autoFocus()
{
ALOGV("autoFocus");
Parcel data, reply;
data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
remote()->transact(AUTO_FOCUS, data, &reply);
status_t ret = reply.readInt32();
return ret;
}

// cancel focus
status_t cancelAutoFocus()
{
ALOGV("cancelAutoFocus");
Parcel data, reply;
data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
remote()->transact(CANCEL_AUTO_FOCUS, data, &reply);
status_t ret = reply.readInt32();
return ret;
}

// take a picture - returns an IMemory (ref-counted mmap)
status_t takePicture(int msgType)
{
ALOGV("takePicture: 0x%x", msgType);
Parcel data, reply;
data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
data.writeInt32(msgType);
remote()->transact(TAKE_PICTURE, data, &reply);
status_t ret = reply.readInt32();
return ret;
}

// set preview/capture parameters - key/value pairs
status_t setParameters(const String8& params)
{
ALOGV("setParameters");
Parcel data, reply;
data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
data.writeString8(params);
remote()->transact(SET_PARAMETERS, data, &reply);
return reply.readInt32();
}

// get preview/capture parameters - key/value pairs
String8 getParameters() const
{
ALOGV("getParameters");
Parcel data, reply;
data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
remote()->transact(GET_PARAMETERS, data, &reply);
return reply.readString8();
}
virtual status_t sendCommand(int32_t cmd, int32_t arg1, int32_t arg2)
{
ALOGV("sendCommand");
Parcel data, reply;
data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
data.writeInt32(cmd);
data.writeInt32(arg1);
data.writeInt32(arg2);
remote()->transact(SEND_COMMAND, data, &reply);
return reply.readInt32();
}
virtual status_t connect(const sp<ICameraClient>& cameraClient)
{
Parcel data, reply;
data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
data.writeStrongBinder(IInterface::asBinder(cameraClient));
remote()->transact(CONNECT, data, &reply);
return reply.readInt32();
}
virtual status_t lock()
{
Parcel data, reply;
data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
remote()->transact(LOCK, data, &reply);
return reply.readInt32();
}
virtual status_t unlock()
{
Parcel data, reply;
data.writeInterfaceToken(ICamera::getInterfaceDescriptor());
remote()->transact(UNLOCK, data, &reply);
return reply.readInt32();
}
};

IMPLEMENT_META_INTERFACE(Camera, "android.hardware.ICamera");

// ----------------------------------------------------------------------

status_t BnCamera::onTransact(
uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
{
switch(code) {
case DISCONNECT: {
ALOGV("DISCONNECT");
CHECK_INTERFACE(ICamera, data, reply);
disconnect();
reply->writeNoException();
return NO_ERROR;
} break;
case SET_PREVIEW_TARGET: {
ALOGV("SET_PREVIEW_TARGET");
CHECK_INTERFACE(ICamera, data, reply);
sp<IGraphicBufferProducer> st =
interface_cast<IGraphicBufferProducer>(data.readStrongBinder());
reply->writeInt32(setPreviewTarget(st));
return NO_ERROR;
} break;
case SET_PREVIEW_CALLBACK_FLAG: {
ALOGV("SET_PREVIEW_CALLBACK_TYPE");
CHECK_INTERFACE(ICamera, data, reply);
int callback_flag = data.readInt32();
setPreviewCallbackFlag(callback_flag);
return NO_ERROR;
} break;
case SET_PREVIEW_CALLBACK_TARGET: {
ALOGV("SET_PREVIEW_CALLBACK_TARGET");
CHECK_INTERFACE(ICamera, data, reply);
sp<IGraphicBufferProducer> cp =
interface_cast<IGraphicBufferProducer>(data.readStrongBinder());
reply->writeInt32(setPreviewCallbackTarget(cp));
return NO_ERROR;
}
case START_PREVIEW: {
ALOGV("START_PREVIEW");
CHECK_INTERFACE(ICamera, data, reply);
reply->writeInt32(startPreview());
return NO_ERROR;
} break;
case START_RECORDING: {
ALOGV("START_RECORDING");
CHECK_INTERFACE(ICamera, data, reply);
reply->writeInt32(startRecording());
return NO_ERROR;
} break;
case STOP_PREVIEW: {
ALOGV("STOP_PREVIEW");
CHECK_INTERFACE(ICamera, data, reply);
stopPreview();
return NO_ERROR;
} break;
case STOP_RECORDING: {
ALOGV("STOP_RECORDING");
CHECK_INTERFACE(ICamera, data, reply);
stopRecording();
return NO_ERROR;
} break;
case RELEASE_RECORDING_FRAME: {
ALOGV("RELEASE_RECORDING_FRAME");
CHECK_INTERFACE(ICamera, data, reply);
sp<IMemory> mem = interface_cast<IMemory>(data.readStrongBinder());
releaseRecordingFrame(mem);
return NO_ERROR;
} break;
case STORE_META_DATA_IN_BUFFERS: {
ALOGV("STORE_META_DATA_IN_BUFFERS");
CHECK_INTERFACE(ICamera, data, reply);
bool enabled = data.readInt32();
reply->writeInt32(storeMetaDataInBuffers(enabled));
return NO_ERROR;
} break;
case PREVIEW_ENABLED: {
ALOGV("PREVIEW_ENABLED");
CHECK_INTERFACE(ICamera, data, reply);
reply->writeInt32(previewEnabled());
return NO_ERROR;
} break;
case RECORDING_ENABLED: {
ALOGV("RECORDING_ENABLED");
CHECK_INTERFACE(ICamera, data, reply);
reply->writeInt32(recordingEnabled());
return NO_ERROR;
} break;
case AUTO_FOCUS: {
ALOGV("AUTO_FOCUS");
CHECK_INTERFACE(ICamera, data, reply);
reply->writeInt32(autoFocus());
return NO_ERROR;
} break;
case CANCEL_AUTO_FOCUS: {
ALOGV("CANCEL_AUTO_FOCUS");
CHECK_INTERFACE(ICamera, data, reply);
reply->writeInt32(cancelAutoFocus());
return NO_ERROR;
} break;
case TAKE_PICTURE: {
ALOGV("TAKE_PICTURE");
CHECK_INTERFACE(ICamera, data, reply);
int msgType = data.readInt32();
reply->writeInt32(takePicture(msgType));
return NO_ERROR;
} break;
case SET_PARAMETERS: {
ALOGV("SET_PARAMETERS");
CHECK_INTERFACE(ICamera, data, reply);
String8 params(data.readString8());
reply->writeInt32(setParameters(params));
return NO_ERROR;
} break;
case GET_PARAMETERS: {
ALOGV("GET_PARAMETERS");
CHECK_INTERFACE(ICamera, data, reply);
reply->writeString8(getParameters());
return NO_ERROR;
} break;
case SEND_COMMAND: {
ALOGV("SEND_COMMAND");
CHECK_INTERFACE(ICamera, data, reply);
int command = data.readInt32();
int arg1 = data.readInt32();
int arg2 = data.readInt32();
reply->writeInt32(sendCommand(command, arg1, arg2));
return NO_ERROR;
} break;
case CONNECT: {
CHECK_INTERFACE(ICamera, data, reply);
sp<ICameraClient> cameraClient = interface_cast<ICameraClient>(data.readStrongBinder());
reply->writeInt32(connect(cameraClient));
return NO_ERROR;
} break;
case LOCK: {
CHECK_INTERFACE(ICamera, data, reply);
reply->writeInt32(lock());
return NO_ERROR;
} break;
case UNLOCK: {
CHECK_INTERFACE(ICamera, data, reply);
reply->writeInt32(unlock());
return NO_ERROR;
} break;
default:
return BBinder::onTransact(code, data, reply, flags);
}
}

ICameraService.cpp



接下来或执行到BnCameraService的onTransact()方法，主要就是switch_case，上面传入的是CONNECT



接下来看一下CameraService中的connect函数都干了啥



到connectHelperLocked()函数中





这里的client创建成功后会赋值给device，而device就是之前连接过程中的传入参数，到这里Camera的连接过程就基本完成了。

第一时间获得博客更新提醒，以及更多android干货，源码分析，欢迎关注我的微信公众号，扫一扫下方二维码或者长按识别二维码，即可关注。



如果你觉得好，随手点赞，也是对笔者的肯定，也可以分享此公众号给你更多的人，原创不易