android sse 人脸识别,基于Android Camera2之openCamera 流程
簡介
frameworks\base\core\java\android\hardware\camera2
Camera2在Android 5.0上首次出現，主要重新定義了一套Camera 的使用接口API，設計思想出現了變化，具體的可自行搜索，此處主要介紹下Camera2的常見類以及使用流程。
CameraCaptureSession 類 會話類，即用戶發起操作Camera設備的動作類，如錄像拍照等
CaptureRequest類 請求類，用戶對Camera發起請求的抽象封裝類
CameraDevice類 Camera抽象類，類似于Camaera的一個客戶端
CameraCharacteristics類 相機參數類，比如相機支持哪些特性，如分辨率集合等
除此之外這些類中還會存在內部類，內部類的作用是Camera Framework 層完成配置異步返回結果的抽象類
以上幾個主要的類都在base/core下面，在對外發布API的時候App均可使用
frameworks\base\media
ImageReader類 相機采集回來的數據承載類，即相機的YUV元數據承載類
在APP層使用相機拍照 錄制視頻 等過程中上述主要類均離不開，本系列主要圍繞關鍵類，介紹其關鍵流程，本文主要介紹openCamera流程
1： openCamera 基本流程
Framework層流程也是針對上訴幾個關鍵步驟進行分析的，我們逐個往下分析
首先看下App層在openCamera的時候Framework層發生了什么，做了什么
frameworks\base\core\java\android\hardware\camera2\CameraManager.java
@RequiresPermission(android.Manifest.permission.CAMERA)
public void openCamera(@NonNull String cameraId,
@NonNull final CameraDevice.StateCallback callback, @Nullable Handler handler)
throws CameraAccessException {
openCameraForUid(cameraId, callback, handler, USE_CALLING_UID);
}
檢查參數
public void openCameraForUid(@NonNull String cameraId,
@NonNull final CameraDevice.StateCallback callback, @Nullable Handler handler,
int clientUid)
throws CameraAccessException {
if(TdDeviceManager.disallowOp(TdDeviceManager.DISABLED_CAMERA)) {
throw new IllegalArgumentException("camera is disabled by MDM");
}
if (cameraId == null) {
throw new IllegalArgumentException("cameraId was null");
} else if (callback == null) {
throw new IllegalArgumentException("callback was null");
} else if (handler == null) {
if (Looper.myLooper() != null) {
handler = new Handler();
} else {
throw new IllegalArgumentException(
"Handler argument is null, but no looper exists in the calling thread");
}
}
openCameraDeviceUserAsync(cameraId, callback, handler, clientUid);
}
關鍵方法
/**
* Helper for opening a connection to a camera with the given ID.
*
* @param cameraId The unique identifier of the camera device to open
* @param callback The callback for the camera. Must not be null.
* @param handler The handler to invoke the callback on. Must not be null.
* @param uid The UID of the application actually opening the camera.
* Must be USE_CALLING_UID unless the caller is a service
* that is trusted to open the device on behalf of an
* application and to forward the real UID.
*
* @throws CameraAccessException if the camera is disabled by device policy,
* too many camera devices are already open, or the cameraId does not match
* any currently available camera device.
*
* @throws SecurityException if the application does not have permission to
* access the camera
* @throws IllegalArgumentException if callback or handler is null.
* @return A handle to the newly-created camera device.
*
* @see #getCameraIdList
* @see android.app.admin.DevicePolicyManager#setCameraDisabled
*/
private CameraDevice openCameraDeviceUserAsync(String cameraId,
CameraDevice.StateCallback callback, Handler handler, final int uid)
throws CameraAccessException {
CameraCharacteristics characteristics = getCameraCharacteristics(cameraId);
CameraDevice device = null;
synchronized (mLock) {
ICameraDeviceUser cameraUser = null;
android.hardware.camera2.impl.CameraDeviceImpl deviceImpl =
new android.hardware.camera2.impl.CameraDeviceImpl(
cameraId,
callback,
handler,
characteristics,
mContext.getApplicationInfo().targetSdkVersion);
ICameraDeviceCallbacks callbacks = deviceImpl.getCallbacks();
try {
if (supportsCamera2ApiLocked(cameraId)) {
// Use cameraservice's cameradeviceclient implementation for HAL3.2+ devices
//[HSM]
if(!HwSystemManager.allowOp(HwSystemManager.PERMISSION_CAMERA)) {
ServiceSpecificException e = new ServiceSpecificException(ICameraService.ERROR_DISABLED);
throwAsPublicException(e);
}
Log.i(TAG, "open camera: " + cameraId + ", package name: " + mContext.getOpPackageName());
HwSystemManager.notifyBackgroundMgr(mContext.getOpPackageName(),
Binder.getCallingPid(),
Binder.getCallingUid(),
HwSystemManager.CAMARA_SERVICE_NOTIFY,
HwSystemManager.BACKGROUND_POLICY_OPEN);
ICameraService cameraService = CameraManagerGlobal.get().getCameraService();
if (cameraService == null) {
throw new ServiceSpecificException(
ICameraService.ERROR_DISCONNECTED,
"Camera service is currently unavailable");
}
cameraUser = cameraService.connectDevice(callbacks, cameraId,
mContext.getOpPackageName(), uid);
} else {
// Use legacy camera implementation for HAL1 devices
int id;
try {
id = Integer.parseInt(cameraId);
} catch (NumberFormatException e) {
throw new IllegalArgumentException("Expected cameraId to be numeric, but it was: "
+ cameraId);
}
Log.i(TAG, "Using legacy camera HAL.");
cameraUser = CameraDeviceUserShim.connectBinderShim(callbacks, id);
}
} catch (ServiceSpecificException e) {
if (e.errorCode == ICameraService.ERROR_DEPRECATED_HAL) {
throw new AssertionError("Should've gone down the shim path");
} else if (e.errorCode == ICameraService.ERROR_CAMERA_IN_USE ||
e.errorCode == ICameraService.ERROR_MAX_CAMERAS_IN_USE ||
e.errorCode == ICameraService.ERROR_DISABLED ||
e.errorCode == ICameraService.ERROR_DISCONNECTED ||
e.errorCode == ICameraService.ERROR_INVALID_OPERATION) {
// Received one of the known connection errors
// The remote camera device cannot be connected to, so
// set the local camera to the startup error state
deviceImpl.setRemoteFailure(e);
if (e.errorCode == ICameraService.ERROR_DISABLED ||
e.errorCode == ICameraService.ERROR_DISCONNECTED ||
e.errorCode == ICameraService.ERROR_CAMERA_IN_USE) {
// Per API docs, these failures call onError and throw
throwAsPublicException(e);
}
} else {
// Unexpected failure - rethrow
throwAsPublicException(e);
}
} catch (RemoteException e) {
// Camera service died - act as if it's a CAMERA_DISCONNECTED case
ServiceSpecificException sse = new ServiceSpecificException(
ICameraService.ERROR_DISCONNECTED,
"Camera service is currently unavailable");
deviceImpl.setRemoteFailure(sse);
throwAsPublicException(sse);
}
// TODO: factor out callback to be non-nested, then move setter to constructor
// For now, calling setRemoteDevice will fire initial
// onOpened/onUnconfigured callbacks.
// This function call may post onDisconnected and throw CAMERA_DISCONNECTED if
// cameraUser dies during setup.
deviceImpl.setRemoteDevice(cameraUser);
device = deviceImpl;
}
return device;
}
關鍵部分代碼如上，主要干了什么了？
1：創建了Camera Client 即 deviceImpl，此對象也就是返回APP進程中的對象
android.hardware.camera2.impl.CameraDeviceImpl deviceImpl =new android.hardware.camera2.impl.CameraDeviceImpl(cameraId, callback,handler,characteristics,mContext.getApplicationInfo().targetSdkVersion);
2：將第一步創建的Client 和Framework 的Camera Service 聯系起來，并且注冊了一個回調，在物理Camera實際有什么狀態時，及時通知到App層
cameraUser = cameraService.connectDevice(callbacks, cameraId,
mContext.getOpPackageName(), uid);
3:將deviceImpl 和ICameraDeviceUser cameraUser聯系起來，即App用戶提過deviceImpl下發指令，deviceImpl 通過cameraUser 操作Framework層的 Camera，并且將Framework層的Camera的客戶端返回給高層
deviceImpl.setRemoteDevice(cameraUser);
2：openCamera關鍵步驟
關鍵步驟1：
在CameraManager openCamera的時候就創建了給APP 用的Client，此Client初始化的參數關注下即可，主要是傳了camera 的id(哪個攝像頭)，攝像頭的回調接口callback，此接口在Camera創建完成就返回給APP進程了，handler是App處理相機打卡回調的接收者，此處關鍵就是Framework 返回App的是CameraDeviceImpl 對象，但是實際接口返回的要求是一個CameraDevice對象，如下：
/**
* The method called when a camera device has finished opening.
*
*
At this point, the camera device is ready to use, and
* {@link CameraDevice#createCaptureSession} can be called to set up the first capture
* session.
*
* @param camera the camera device that has become opened
*/
public abstract void onOpened(@NonNull CameraDevice camera); // Must implement
關鍵步驟2：
此步驟是打開Camera的最關鍵的一步，首先是獲取Framework層的Camera Service，即
ICameraService cameraService
ICameraService cameraService = CameraManagerGlobal.get().getCameraService();
然后就通過 cameraService
cameraUser = cameraService.connectDevice(callbacks, cameraId,
mContext.getOpPackageName(), uid);
主要傳了 callback(Cameraservice 回調App的接口)，Camera的id 進程號 和包名(下面代碼刪除了部分，主要說明此回調作用)
public class CameraDeviceCallbacks extends ICameraDeviceCallbacks.Stub {
@Override
public IBinder asBinder() {
return this;
}
@Override
public void onDeviceError(final int errorCode, CaptureResultExtras resultExtras) {
}
@Override
public void onRepeatingRequestError(long lastFrameNumber) {
}
@Override
public void onDeviceIdle() {
}
@Override
public void onCaptureStarted(final CaptureResultExtras resultExtras, final long timestamp) {
}
@Override
public void onResultReceived(CameraMetadataNative result,
}
@Override
public void onPrepared(int streamId) {
}
@Override
public void onRequestQueueEmpty() {
}
}
Callback對象，根據此對象定義可知是通過Binder傳遞過來的
通過Binder 調用Camera Service的connectDevice，Camera Service是Camera 進程初始化注冊到ServicesManager中的，服務的承載代碼即CameraService.cpp，因此查看下：
Status CameraService::connectDevice(
const sp<:camera2::icameradevicecallbacks>& cameraCb,
const String16& cameraId,
const String16& clientPackageName,
int clientUid,
/*out*/
sp<:camera2::icameradeviceuser>* device) {
ATRACE_CALL();
Status ret = Status::ok();
String8 id = String8(cameraId);
sp client = nullptr;
ret = connectHelper<:camera2::icameradevicecallbacks>(cameraCb, id,
CAMERA_HAL_API_VERSION_UNSPECIFIED, clientPackageName,
clientUid, USE_CALLING_PID, API_2,
/*legacyMode*/ false, /*shimUpdateOnly*/ false,
/*out*/client);
if(!ret.isOk()) {
logRejected(id, getCallingPid(), String8(clientPackageName),
ret.toString8());
return ret;
}
String8 pid = String8::format("%d", getCallingPid());
POWERPUSH(129, clientName8.string(), id.string(), pid.string());//define in LogPower.java, 129 stand for camera start now
*device = client;
//add for send msg to nfc
char needSendMsg[255];
property_get("ro.config.hw_camera_nfc_switch",needSendMsg,"");
ALOGI("NFC polling %s", needSendMsg);
if (0 == strcmp(needSendMsg, "true")) {
String8 isOpen = String8::format("false");
android::allowNfcPolling(isOpen);
}
ALOGI("%s(), exit.", __FUNCTION__);
return ret;
}
關鍵函數connectHelper
template
Status CameraService::connectHelper(const sp& cameraCb, const String8& cameraId,
int halVersion, const String16& clientPackageName, int clientUid, int clientPid,
apiLevel effectiveApiLevel, bool legacyMode, bool shimUpdateOnly,
/*out*/sp& device) {
binder::Status ret = binder::Status::ok();
String8 clientName8(clientPackageName);
int originalClientPid = 0;
ALOGI("CameraService::connect call (PID %d \"%s\", camera ID %s) for HAL version %s and "
"Camera API version %d", clientPid, clientName8.string(), cameraId.string(),
(halVersion == -1) ? "default" : std::to_string(halVersion).c_str(),
static_cast(effectiveApiLevel));
sp client = nullptr;
{
// Acquire mServiceLock and prevent other clients from connecting
std::unique_ptr lock =
AutoConditionLock::waitAndAcquire(mServiceLockWrapper, DEFAULT_CONNECT_TIMEOUT_NS);
if (lock == nullptr) {
ALOGE("CameraService::connect (PID %d) rejected (too many other clients connecting)."
, clientPid);
return STATUS_ERROR_FMT(ERROR_MAX_CAMERAS_IN_USE,
"Cannot open camera %s for \"%s\" (PID %d): Too many other clients connecting",
cameraId.string(), clientName8.string(), clientPid);
}
// Enforce client permissions and do basic sanity checks
if(!(ret = validateConnectLocked(cameraId, clientName8,
/*inout*/clientUid, /*inout*/clientPid, /*out*/originalClientPid)).isOk()) {
return ret;
}
// Check the shim parameters after acquiring lock, if they have already been updated and
// we were doing a shim update, return immediately
if (shimUpdateOnly) {
auto cameraState = getCameraState(cameraId);
if (cameraState != nullptr) {
if (!cameraState->getShimParams().isEmpty()) return ret;
}
}
status_t err;
sp clientTmp = nullptr;
std::shared_ptr<:clientdescriptor sp>>> partial;
if ((err = handleEvictionsLocked(cameraId, originalClientPid, effectiveApiLevel,
IInterface::asBinder(cameraCb), clientName8, /*out*/&clientTmp,
/*out*/&partial)) != NO_ERROR) {
switch (err) {
case -ENODEV:
return STATUS_ERROR_FMT(ERROR_DISCONNECTED,
"No camera device with ID \"%s\" currently available",
cameraId.string());
case -EBUSY:
return STATUS_ERROR_FMT(ERROR_CAMERA_IN_USE,
"Higher-priority client using camera, ID \"%s\" currently unavailable",
cameraId.string());
default:
return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION,
"Unexpected error %s (%d) opening camera \"%s\"",
strerror(-err), err, cameraId.string());
}
}
if (clientTmp.get() != nullptr) {
// Handle special case for API1 MediaRecorder where the existing client is returned
device = static_cast(clientTmp.get());
return ret;
}
// give flashlight a chance to close devices if necessary.
mFlashlight->prepareDeviceOpen(cameraId);
int facing = -1;
int deviceVersion = getDeviceVersion(cameraId, /*out*/&facing);
if (facing == -1) {
ALOGE("%s: Unable to get camera device \"%s\" facing", __FUNCTION__, cameraId.string());
return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION,
"Unable to get camera device \"%s\" facing", cameraId.string());
}
sp tmp = nullptr;
if(!(ret = makeClient(this, cameraCb, clientPackageName, cameraId, facing, clientPid,
clientUid, getpid(), legacyMode, halVersion, deviceVersion, effectiveApiLevel,
/*out*/&tmp)).isOk()) {
return ret;
}
client = static_cast(tmp.get());
ALOGI("%s(), make client for '%s'.", __FUNCTION__, String8{clientPackageName}.string());
LOG_ALWAYS_FATAL_IF(client.get() == nullptr, "%s: CameraService in invalid state",
__FUNCTION__);
err = client->initialize(mCameraProviderManager);
if (err != OK) {
ALOGE("%s: Could not initialize client from HAL.", __FUNCTION__);
// Errors could be from the HAL module open call or from AppOpsManager
switch(err) {
case BAD_VALUE:
return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT,
"Illegal argument to HAL module for camera \"%s\"", cameraId.string());
case -EBUSY:
return STATUS_ERROR_FMT(ERROR_CAMERA_IN_USE,
"Camera \"%s\" is already open", cameraId.string());
case -EUSERS:
return STATUS_ERROR_FMT(ERROR_MAX_CAMERAS_IN_USE,
"Too many cameras already open, cannot open camera \"%s\"",
cameraId.string());
case PERMISSION_DENIED:
return STATUS_ERROR_FMT(ERROR_PERMISSION_DENIED,
"No permission to open camera \"%s\"", cameraId.string());
case -EACCES:
return STATUS_ERROR_FMT(ERROR_DISABLED,
"Camera \"%s\" disabled by policy", cameraId.string());
case -ENODEV:
default:
return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION,
"Failed to initialize camera \"%s\": %s (%d)", cameraId.string(),
strerror(-err), err);
}
}
// Update shim paremeters for legacy clients
if (effectiveApiLevel == API_1) {
// Assume we have always received a Client subclass for API1
sp shimClient = reinterpret_cast(client.get());
String8 rawParams = shimClient->getParameters();
CameraParameters params(rawParams);
auto cameraState = getCameraState(cameraId);
if (cameraState != nullptr) {
cameraState->setShimParams(params);
} else {
ALOGE("%s: Cannot update shim parameters for camera %s, no such device exists.",
__FUNCTION__, cameraId.string());
}
}
if (shimUpdateOnly) {
// If only updating legacy shim parameters, immediately disconnect client
mServiceLock.unlock();
client->disconnect();
mServiceLock.lock();
} else {
// Otherwise, add client to active clients list
finishConnectLocked(client, partial);
}
} // lock is destroyed, allow further connect calls
device = client;
return ret;
}
關鍵函數makeClient
Status CameraService::makeClient(const sp& cameraService,
const sp& cameraCb, const String16& packageName, const String8& cameraId,
int facing, int clientPid, uid_t clientUid, int servicePid, bool legacyMode,
int halVersion, int deviceVersion, apiLevel effectiveApiLevel,
/*out*/sp* client) {
if (halVersion < 0 || halVersion == deviceVersion) {
// Default path: HAL version is unspecified by caller, create CameraClient
// based on device version reported by the HAL.
switch(deviceVersion) {
case CAMERA_DEVICE_API_VERSION_1_0:
if (effectiveApiLevel == API_1) { // Camera1 API route
sp tmp = static_cast(cameraCb.get());
*client = new CameraClient(cameraService, tmp, packageName, cameraIdToInt(cameraId),
facing, clientPid, clientUid, getpid(), legacyMode);
} else { // Camera2 API route
ALOGW("Camera using old HAL version: %d", deviceVersion);
return STATUS_ERROR_FMT(ERROR_DEPRECATED_HAL,
"Camera device \"%s\" HAL version %d does not support camera2 API",
cameraId.string(), deviceVersion);
}
break;
case CAMERA_DEVICE_API_VERSION_3_0:
case CAMERA_DEVICE_API_VERSION_3_1:
case CAMERA_DEVICE_API_VERSION_3_2:
case CAMERA_DEVICE_API_VERSION_3_3:
case CAMERA_DEVICE_API_VERSION_3_4:
if (effectiveApiLevel == API_1) { // Camera1 API route
sp tmp = static_cast(cameraCb.get());
*client = new Camera2Client(cameraService, tmp, packageName, cameraIdToInt(cameraId),
facing, clientPid, clientUid, servicePid, legacyMode);
} else { // Camera2 API route
sp<:camera2::icameradevicecallbacks> tmp =
static_cast<:camera2::icameradevicecallbacks>(cameraCb.get());
*client = new CameraDeviceClient(cameraService, tmp, packageName, cameraId,
facing, clientPid, clientUid, servicePid);
}
break;
default:
// Should not be reachable
ALOGE("Unknown camera device HAL version: %d", deviceVersion);
return STATUS_ERROR_FMT(ERROR_INVALID_OPERATION,
"Camera device \"%s\" has unknown HAL version %d",
cameraId.string(), deviceVersion);
}
} else {
// A particular HAL version is requested by caller. Create CameraClient
// based on the requested HAL version.
if (deviceVersion > CAMERA_DEVICE_API_VERSION_1_0 &&
halVersion == CAMERA_DEVICE_API_VERSION_1_0) {
// Only support higher HAL version device opened as HAL1.0 device.
sp tmp = static_cast(cameraCb.get());
*client = new CameraClient(cameraService, tmp, packageName, cameraIdToInt(cameraId),
facing, clientPid, clientUid, servicePid, legacyMode);
} else {
// Other combinations (e.g. HAL3.x open as HAL2.x) are not supported yet.
ALOGE("Invalid camera HAL version %x: HAL %x device can only be"
" opened as HAL %x device", halVersion, deviceVersion,
CAMERA_DEVICE_API_VERSION_1_0);
return STATUS_ERROR_FMT(ERROR_ILLEGAL_ARGUMENT,
"Camera device \"%s\" (HAL version %d) cannot be opened as HAL version %d",
cameraId.string(), deviceVersion, halVersion);
}
}
return Status::ok();
}
在此處有2 個關鍵步驟
步驟1：創建Camera 的客戶端 Client，根據調用出可知是 CameraDeviceClient，創建時同時傳入了一個Hal層回調的狀態對象，為ICameraDeviceCallbacks 分別對應上面2個函數
makeClient 函數 會根據傳入的HAL版本號halVersion 和設備版本號deviceVersion 進行初始化以及API的版本號，初始化了一個CamDeviceClien對象
查看構造函數發現初始化了父類Camera2ClientBase
CameraDeviceClient::CameraDeviceClient(const sp& cameraService,
const sp<:camera2::icameradevicecallbacks>& remoteCallback,
const String16& clientPackageName,
const String8& cameraId,
int cameraFacing,
int clientPid,
uid_t clientUid,
int servicePid) :
Camera2ClientBase(cameraService, remoteCallback, clientPackageName,
cameraId, cameraFacing, clientPid, clientUid, servicePid),
mInputStream(),
mStreamingRequestId(REQUEST_ID_NONE),
mRequestIdCounter(0) {
ATRACE_CALL();
ALOGI("CameraDeviceClient %s: Opened", cameraId.string());
}
繼續查看最終發現是初始化了一個 Camera3Device對象，這個就是java APP
在打開 Cmaera 時真正創建的Frameowok 層對象，屬于真正干活的
template
Camera2ClientBase::Camera2ClientBase(
const sp& cameraService,
const sp& remoteCallback,
const String16& clientPackageName,
const String8& cameraId,
int cameraFacing,
int clientPid,
uid_t clientUid,
int servicePid):
TClientBase(cameraService, remoteCallback, clientPackageName,
cameraId, cameraFacing, clientPid, clientUid, servicePid),
mSharedCameraCallbacks(remoteCallback),
mDeviceVersion(cameraService->getDeviceVersion(TClientBase::mCameraIdStr)),
mDeviceActive(false)
{
ALOGI("Camera %s: Opened. Client: %s (PID %d, UID %d)", cameraId.string(),
String8(clientPackageName).string(), clientPid, clientUid);
mInitialClientPid = clientPid;
mDevice = new Camera3Device(cameraId);
LOG_ALWAYS_FATAL_IF(mDevice == 0, "Device should never be NULL here.");
}
步驟二：
對此CameraDeviceClient 進行初始化，初始化的時候傳入了mCameraProviderManager，即
client = static_cast(tmp.get());
ALOGI("%s(), make client for '%s'.", __FUNCTION__, String8{clientPackageName}.string());
LOG_ALWAYS_FATAL_IF(client.get() == nullptr, "%s: CameraService in invalid state",
__FUNCTION__);
err = client->initialize(mCameraProviderManager);
sp mCameraProviderManager，此對象在CameraService 初始化的時候就構造出來了，主要工作之一也是連接HAI層
mCameraProviderManager 是CameraServics 構造函數初始化的時候賦值的
if (nullptr == mCameraProviderManager.get()) {
mCameraProviderManager = new CameraProviderManager();
res = mCameraProviderManager->initialize(this);
if (res != OK) {
ALOGE("%s: Unable to initialize camera provider manager: %s (%d)",
__FUNCTION__, strerror(-res), res);
return res;
}
}
3：通知APP層Camera狀態
frameworks\base\core\java\android\hardware\camera2\impl\CameraDeviceImpl.java
通知到APP Camera 已經打開，即在nataive 創建了CameraClient 完成之后CameraManager將native camera device設到java 的CameraDevice 之后即通知了APP，Camera創建好了
deviceImpl.setRemoteDevice(cameraUser);
device = deviceImpl;
/**
* Set remote device, which triggers initial onOpened/onUnconfigured callbacks
*
*
This function may post onDisconnected and throw CAMERA_DISCONNECTED if remoteDevice dies
* during setup.
*
*/
public void setRemoteDevice(ICameraDeviceUser remoteDevice) throws CameraAccessException {
synchronized(mInterfaceLock) {
// TODO: Move from decorator to direct binder-mediated exceptions
// If setRemoteFailure already called, do nothing
if (mInError) return;
mRemoteDevice = new ICameraDeviceUserWrapper(remoteDevice);
IBinder remoteDeviceBinder = remoteDevice.asBinder();
// For legacy camera device, remoteDevice is in the same process, and
// asBinder returns NULL.
if (remoteDeviceBinder != null) {
try {
remoteDeviceBinder.linkToDeath(this, /*flag*/ 0);
} catch (RemoteException e) {
CameraDeviceImpl.this.mDeviceHandler.post(mCallOnDisconnected);
throw new CameraAccessException(CameraAccessException.CAMERA_DISCONNECTED,
"The camera device has encountered a serious error");
}
}
mDeviceHandler.post(mCallOnOpened);
mDeviceHandler.post(mCallOnUnconfigured);
}
}
private final Runnable mCallOnOpened = new Runnable() {
@Override
public void run() {
StateCallbackKK sessionCallback = null;
synchronized(mInterfaceLock) {
if (mRemoteDevice == null) return; // Camera already closed
sessionCallback = mSessionStateCallback;
}
if (sessionCallback != null) {
sessionCallback.onOpened(CameraDeviceImpl.this);
}
mDeviceCallback.onOpened(CameraDeviceImpl.this);
}
};
此處是在App層定義了AIDL 接口，但是服務是native層的，為了雙方能通信，Aidl的調用客戶端是使用java 實現，服務端采用c++實現的，確保了binder通信正常，此處用到的Binder服務關鍵函數為
connectDevice，因此connectDevice 的通信方式再此跟蹤下：
frameworks\av\camera\aidl\android\hardware\ICameraService.aidl
/**
* Open a camera device through the new camera API
* Only supported for device HAL versions >= 3.2
*/
ICameraDeviceUser connectDevice(ICameraDeviceCallbacks callbacks,
String cameraId,
String opPackageName,
int clientUid);
aidl_java.png
aidl_java2.png
服務端實現此函數收到函數請求，如下：
class BpCameraService : public ::android::BpInterface {
public:
explicit BpCameraService(const ::android::sp<::android::ibinder>& _aidl_impl);
virtual ~BpCameraService() = default;
::android::binder::Status getNumberOfCameras(int32_t type, int32_t* _aidl_return) override;
::android::binder::Status getCameraInfo(int32_t cameraId, ::android::hardware::CameraInfo* _aidl_return) override;
::android::binder::Status connect(const ::android::sp<::android::hardware::icameraclient>& client, int32_t cameraId, const ::android::String16& opPackageName, int32_t cl
::android::binder::Status connectDevice(const ::android::sp<::android::hardware::camera2::icameradevicecallbacks>& callbacks, const ::android::String16& cameraId, const
::android::binder::Status connectLegacy(const ::android::sp<::android::hardware::icameraclient>& client, int32_t cameraId, int32_t halVersion, const ::android::String16&
::android::binder::Status addListener(const ::android::sp<::android::hardware::icameraservicelistener>& listener, ::std::vector<::android::hardware::camerastatus>* _aidl
::android::binder::Status removeListener(const ::android::sp<::android::hardware::icameraservicelistener>& listener) override;
::android::binder::Status getCameraCharacteristics(const ::android::String16& cameraId, ::android::hardware::camera2::impl::CameraMetadataNative* _aidl_return) override;
::android::binder::Status getCameraVendorTagDescriptor(::android::hardware::camera2::params::VendorTagDescriptor* _aidl_return) override;
::android::binder::Status getCameraVendorTagCache(::android::hardware::camera2::params::VendorTagDescriptorCache* _aidl_return) override;
::android::binder::Status getLegacyParameters(int32_t cameraId, ::android::String16* _aidl_return) override;
::android::binder::Status supportsCameraApi(const ::android::String16& cameraId, int32_t apiVersion, bool* _aidl_return) override;
::android::binder::Status setTorchMode(const ::android::String16& cameraId, bool enabled, const ::android::sp<::android::ibinder>& clientBinder) override;
::android::binder::Status notifySystemEvent(int32_t eventId, const ::std::vector& args) override;
}; // class BpCameraService
}
services2.png
Status CameraService::connectDevice(
const sp<:camera2::icameradevicecallbacks>& cameraCb,
const String16& cameraId,
const String16& clientPackageName,
int clientUid,
/*out*/
sp<:camera2::icameradeviceuser>* device) {
ATRACE_CALL();
Status ret = Status::ok();
String8 id = String8(cameraId);
sp client = nullptr;
ret = connectHelper<:camera2::icameradevicecallbacks>(cameraCb, id,
CAMERA_HAL_API_VERSION_UNSPECIFIED, clientPackageName,
clientUid, USE_CALLING_PID, API_2,
/*legacyMode*/ false, /*shimUpdateOnly*/ false,
/*out*/client);
if(!ret.isOk()) {
logRejected(id, getCallingPid(), String8(clientPackageName),
ret.toString8());
return ret;
}
String8 pid = String8::format("%d", getCallingPid());
POWERPUSH(129, clientName8.string(), id.string(), pid.string());//define in LogPower.java, 129 stand for camera start now
*device = client;
//add for send msg to nfc
char needSendMsg[255];
property_get("ro.config.hw_camera_nfc_switch",needSendMsg,"");
ALOGI("NFC polling %s", needSendMsg);
if (0 == strcmp(needSendMsg, "true")) {
String8 isOpen = String8::format("false");
android::allowNfcPolling(isOpen);
}
ALOGI("%s(), exit.", __FUNCTION__);
return ret;
}
簡單捋順下調用過程：
CameraManager.Java的connectDevice ? ICameraService.java(系統編譯)的onTransact-?
ICameraService.cpp(系統編譯)的BpCameraService::connectDevice()?ICameraService.cpp(系統編譯)的::android::status_t BnCameraService::onTransact-?
CameraService.cpp的CameraService::connectDevice()
APP 進程在打開之后就等待nataive 層運行結束，native層直到上節分析的創建成功
CameraDevice對象之后由CameraManager進行給java層的CameraDeviceIml 設置
setRemoteDevice，APP進程打開設備成功，得到了framework給到的CameraDeviceIml對象，可以后續通過此對Camera進行操作
總結
以上是生活随笔為你收集整理的android sse 人脸识别,基于Android Camera2之openCamera 流程的全部內容，希望文章能夠幫你解決所遇到的問題。
- 上一篇： mysql修改主从复制id_mysql主
- 下一篇： android listview高级,A