Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit c3e9d6f7 authored by Yin-Chia Yeh's avatar Yin-Chia Yeh
Browse files

Camera: expose external camera to API1 

- Cleanup legacy camera_module_t callbacks
- Order API1 compatible cameras by their ID: numeric strings first
- Dynamically updating number of cameras when device is
  added/removed
- Make sure the following methods are always called without holding
  mServiceLock
    - onDeviceStatusChange
    - updateStatus
    - addStates/removeStates
- Centralized all addState/removeState calls in onDeviceStatusChange
- Passing api1CameraId (number) and cameraDeviceId (string) to various
  client classes.
- Allow FOV information to not present for external camera
- Update API1 preview/video size logic to exclude < ~30fps sizes

Bug: 64874137
Change-Id: Ied6b7141fdad30e3d1c3fcacc5b69ca350fdeb24
parent 98c15702

services/camera/libcameraservice/CameraFlashlight.cpp

+15 −17
Original line number Diff line number Diff line
@@ -32,13 +32,15 @@ 


namespace android {



using hardware::camera::common::V1_0::TorchModeStatus;



/////////////////////////////////////////////////////////////////////

// CameraFlashlight implementation begins

// used by camera service to control flashflight.

/////////////////////////////////////////////////////////////////////



CameraFlashlight::CameraFlashlight(sp<CameraProviderManager> providerManager,

        camera_module_callbacks_t* callbacks) :

        CameraProviderManager::StatusListener* callbacks) :

        mProviderManager(providerManager),

        mCallbacks(callbacks),

        mFlashlightMapInitialized(false) {
@@ -59,7 +61,7 @@ status_t CameraFlashlight::createFlashlightControl(const String8& cameraId) { 
    } else {

        // Only HAL1 devices do not support setTorchMode

        mFlashControl =

                new CameraHardwareInterfaceFlashControl(mProviderManager, *mCallbacks);

                new CameraHardwareInterfaceFlashControl(mProviderManager, mCallbacks);

    }



    return OK;
@@ -119,7 +121,8 @@ status_t CameraFlashlight::setTorchMode(const String8& cameraId, bool enabled) { 
}



int CameraFlashlight::getNumberOfCameras() {

    return mProviderManager->getAPI1CompatibleCameraCount();

    size_t len = mProviderManager->getAPI1CompatibleCameraDeviceIds().size();

    return static_cast<int>(len);

}



status_t CameraFlashlight::findFlashUnits() {
@@ -221,9 +224,8 @@ status_t CameraFlashlight::prepareDeviceOpen(const String8& cameraId) { 
            int numCameras = getNumberOfCameras();

            for (int i = 0; i < numCameras; i++) {

                if (hasFlashUnitLocked(String8::format("%d", i))) {

                    mCallbacks->torch_mode_status_change(mCallbacks,

                            String8::format("%d", i).string(),

                            TORCH_MODE_STATUS_NOT_AVAILABLE);

                    mCallbacks->onTorchStatusChanged(

                            String8::format("%d", i), TorchModeStatus::NOT_AVAILABLE);

                }

            }

        }
@@ -266,9 +268,8 @@ status_t CameraFlashlight::deviceClosed(const String8& cameraId) { 
        int numCameras = getNumberOfCameras();

        for (int i = 0; i < numCameras; i++) {

            if (hasFlashUnitLocked(String8::format("%d", i))) {

                mCallbacks->torch_mode_status_change(mCallbacks,

                        String8::format("%d", i).string(),

                        TORCH_MODE_STATUS_AVAILABLE_OFF);

                mCallbacks->onTorchStatusChanged(

                        String8::format("%d", i), TorchModeStatus::AVAILABLE_OFF);

            }

        }

    }
@@ -315,9 +316,9 @@ status_t ProviderFlashControl::setTorchMode(const String8& cameraId, bool enable 


CameraHardwareInterfaceFlashControl::CameraHardwareInterfaceFlashControl(

        sp<CameraProviderManager> manager,

        const camera_module_callbacks_t& callbacks) :

        CameraProviderManager::StatusListener* callbacks) :

        mProviderManager(manager),

        mCallbacks(&callbacks),

        mCallbacks(callbacks),

        mTorchEnabled(false) {

}
@@ -333,8 +334,7 @@ CameraHardwareInterfaceFlashControl::~CameraHardwareInterfaceFlashControl() { 
        if (mCallbacks) {

            ALOGV("%s: notify the framework that torch was turned off",

                    __FUNCTION__);

            mCallbacks->torch_mode_status_change(mCallbacks,

                    mCameraId.string(), TORCH_MODE_STATUS_AVAILABLE_OFF);

            mCallbacks->onTorchStatusChanged(mCameraId, TorchModeStatus::AVAILABLE_OFF);

        }

    }

}
@@ -368,8 +368,7 @@ status_t CameraHardwareInterfaceFlashControl::setTorchMode( 
        // disabling the torch mode of currently opened device

        disconnectCameraDevice();

        mTorchEnabled = false;

        mCallbacks->torch_mode_status_change(mCallbacks,

            cameraId.string(), TORCH_MODE_STATUS_AVAILABLE_OFF);

        mCallbacks->onTorchStatusChanged(cameraId, TorchModeStatus::AVAILABLE_OFF);

        return OK;

    }
@@ -379,8 +378,7 @@ status_t CameraHardwareInterfaceFlashControl::setTorchMode( 
    }



    mTorchEnabled = true;

    mCallbacks->torch_mode_status_change(mCallbacks,

            cameraId.string(), TORCH_MODE_STATUS_AVAILABLE_ON);

    mCallbacks->onTorchStatusChanged(cameraId, TorchModeStatus::AVAILABLE_ON);

    return OK;

}

services/camera/libcameraservice/CameraFlashlight.h

+4 −5
Original line number Diff line number Diff line
@@ -19,7 +19,6 @@ 


#include <gui/GLConsumer.h>

#include <gui/Surface.h>

#include <hardware/camera_common.h>

#include <utils/KeyedVector.h>

#include <utils/SortedVector.h>

#include "common/CameraProviderManager.h"
@@ -55,7 +54,7 @@ class FlashControlBase : public virtual VirtualLightRefBase { 
class CameraFlashlight : public virtual VirtualLightRefBase {

    public:

        CameraFlashlight(sp<CameraProviderManager> providerManager,

                camera_module_callbacks_t* callbacks);

                CameraProviderManager::StatusListener* callbacks);

        virtual ~CameraFlashlight();



        // Find all flash units. This must be called before other methods. All
@@ -99,7 +98,7 @@ class CameraFlashlight : public virtual VirtualLightRefBase { 


        sp<CameraProviderManager> mProviderManager;



        const camera_module_callbacks_t *mCallbacks;

        CameraProviderManager::StatusListener* mCallbacks;

        SortedVector<String8> mOpenedCameraIds;



        // camera id -> if it has a flash unit
@@ -134,7 +133,7 @@ class CameraHardwareInterfaceFlashControl : public FlashControlBase { 
    public:

        CameraHardwareInterfaceFlashControl(

                sp<CameraProviderManager> manager,

                const camera_module_callbacks_t& callbacks);

                CameraProviderManager::StatusListener* callbacks);

        virtual ~CameraHardwareInterfaceFlashControl();



        // FlashControlBase
@@ -166,7 +165,7 @@ class CameraHardwareInterfaceFlashControl : public FlashControlBase { 
        status_t hasFlashUnitLocked(const String8& cameraId, bool *hasFlash, bool keepDeviceOpen);



        sp<CameraProviderManager> mProviderManager;

        const camera_module_callbacks_t *mCallbacks;

        CameraProviderManager::StatusListener* mCallbacks;

        sp<CameraHardwareInterface> mDevice;

        String8 mCameraId;

        CameraParameters mParameters;

services/camera/libcameraservice/CameraService.cpp

+93 −138
Original line number Diff line number Diff line
@@ -107,79 +107,13 @@ static void setLogLevel(int level) { 


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



extern "C" {

static void camera_device_status_change(

        const struct camera_module_callbacks* callbacks,

        int camera_id,

        int new_status) {

    sp<CameraService> cs = const_cast<CameraService*>(

            static_cast<const CameraService*>(callbacks));

    String8 id = String8::format("%d", camera_id);



    CameraDeviceStatus newStatus{CameraDeviceStatus::NOT_PRESENT};

    switch (new_status) {

        case CAMERA_DEVICE_STATUS_NOT_PRESENT:

            newStatus = CameraDeviceStatus::NOT_PRESENT;

            break;

        case CAMERA_DEVICE_STATUS_PRESENT:

            newStatus = CameraDeviceStatus::PRESENT;

            break;

        case CAMERA_DEVICE_STATUS_ENUMERATING:

            newStatus = CameraDeviceStatus::ENUMERATING;

            break;

        default:

            ALOGW("Unknown device status change to %d", new_status);

            break;

    }

    cs->onDeviceStatusChanged(id, newStatus);

}



static void torch_mode_status_change(

        const struct camera_module_callbacks* callbacks,

        const char* camera_id,

        int new_status) {

    if (!callbacks || !camera_id) {

        ALOGE("%s invalid parameters. callbacks %p, camera_id %p", __FUNCTION__,

                callbacks, camera_id);

    }

    sp<CameraService> cs = const_cast<CameraService*>(

                                static_cast<const CameraService*>(callbacks));



    TorchModeStatus status;

    switch (new_status) {

        case TORCH_MODE_STATUS_NOT_AVAILABLE:

            status = TorchModeStatus::NOT_AVAILABLE;

            break;

        case TORCH_MODE_STATUS_AVAILABLE_OFF:

            status = TorchModeStatus::AVAILABLE_OFF;

            break;

        case TORCH_MODE_STATUS_AVAILABLE_ON:

            status = TorchModeStatus::AVAILABLE_ON;

            break;

        default:

            ALOGE("Unknown torch status %d", new_status);

            return;

    }



    cs->onTorchStatusChanged(

        String8(camera_id),

        status);

}

} // extern "C"



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



static const String16 sManageCameraPermission("android.permission.MANAGE_CAMERA");



CameraService::CameraService() :

        mEventLog(DEFAULT_EVENT_LOG_LENGTH),

        mNumberOfCameras(0), mNumberOfNormalCameras(0),

        mNumberOfCameras(0),

        mSoundRef(0), mInitialized(false) {

    ALOGI("CameraService started (pid=%d)", getpid());



    this->camera_device_status_change = android::camera_device_status_change;

    this->torch_mode_status_change = android::torch_mode_status_change;



    mServiceLockWrapper = std::make_shared<WaitableMutexWrapper>(&mServiceLock);

}
@@ -209,6 +143,9 @@ void CameraService::onFirstRef() 


status_t CameraService::enumerateProviders() {

    status_t res;



    std::vector<std::string> deviceIds;

    {

        Mutex::Autolock l(mServiceLock);



        if (nullptr == mCameraProviderManager.get()) {
@@ -221,9 +158,6 @@ status_t CameraService::enumerateProviders() { 
            }

        }



    mNumberOfCameras = mCameraProviderManager->getCameraCount();

    mNumberOfNormalCameras =

            mCameraProviderManager->getAPI1CompatibleCameraCount();



        // Setup vendor tags before we call get_camera_info the first time

        // because HAL might need to setup static vendor keys in get_camera_info
@@ -239,22 +173,12 @@ status_t CameraService::enumerateProviders() { 
            ALOGE("Failed to enumerate flash units: %s (%d)", strerror(-res), res);

        }



    for (auto& cameraId : mCameraProviderManager->getCameraDeviceIds()) {

        String8 id8 = String8(cameraId.c_str());

        bool cameraFound = false;

        {



            Mutex::Autolock lock(mCameraStatesLock);

            auto iter = mCameraStates.find(id8);

            if (iter != mCameraStates.end()) {

                cameraFound = true;

            }

        deviceIds = mCameraProviderManager->getCameraDeviceIds();

    }



        if (!cameraFound) {

            addStates(id8);

        }



    for (auto& cameraId : deviceIds) {

        String8 id8 = String8(cameraId.c_str());

        onDeviceStatusChanged(id8, CameraDeviceStatus::PRESENT);

    }
@@ -291,6 +215,13 @@ void CameraService::onNewProviderRegistered() { 
    enumerateProviders();

}



void CameraService::updateCameraNumAndIds() {

    Mutex::Autolock l(mServiceLock);

    mNumberOfCameras = mCameraProviderManager->getCameraCount();

    mNormalDeviceIds =

            mCameraProviderManager->getAPI1CompatibleCameraDeviceIds();

}



void CameraService::addStates(const String8 id) {

    std::string cameraId(id.c_str());

    hardware::camera::common::V1_0::CameraResourceCost cost;
@@ -313,10 +244,13 @@ void CameraService::addStates(const String8 id) { 
    if (mFlashlight->hasFlashUnit(id)) {

        mTorchStatusMap.add(id, TorchModeStatus::AVAILABLE_OFF);

    }



    updateCameraNumAndIds();

    logDeviceAdded(id, "Device added");

}



void CameraService::removeStates(const String8 id) {

    updateCameraNumAndIds();

    if (mFlashlight->hasFlashUnit(id)) {

        mTorchStatusMap.removeItem(id);

    }
@@ -361,15 +295,16 @@ void CameraService::onDeviceStatusChanged(const String8& id, 
    if (newStatus == StatusInternal::NOT_PRESENT) {

        logDeviceRemoved(id, String8::format("Device status changed from %d to %d", oldStatus,

                newStatus));

        sp<BasicClient> clientToDisconnect;

        {

            // Don't do this in updateStatus to avoid deadlock over mServiceLock

            Mutex::Autolock lock(mServiceLock);



        // Set the device status to NOT_PRESENT, clients will no longer be able to connect

        // to this device until the status changes

        updateStatus(StatusInternal::NOT_PRESENT, id);



        sp<BasicClient> clientToDisconnect;

        {

            // Don't do this in updateStatus to avoid deadlock over mServiceLock

            Mutex::Autolock lock(mServiceLock);



            // Remove cached shim parameters

            state->setShimParams(CameraParameters());
@@ -472,7 +407,7 @@ Status CameraService::getNumberOfCameras(int32_t type, int32_t* numCameras) { 
    Mutex::Autolock l(mServiceLock);

    switch (type) {

        case CAMERA_TYPE_BACKWARD_COMPATIBLE:

            *numCameras = mNumberOfNormalCameras;

            *numCameras = static_cast<int>(mNormalDeviceIds.size());

            break;

        case CAMERA_TYPE_ALL:

            *numCameras = mNumberOfCameras;
@@ -502,7 +437,8 @@ Status CameraService::getCameraInfo(int cameraId, 
    }



    Status ret = Status::ok();

    status_t err = mCameraProviderManager->getCameraInfo(std::to_string(cameraId), cameraInfo);

    status_t err = mCameraProviderManager->getCameraInfo(

            cameraIdIntToStrLocked(cameraId), cameraInfo);

    if (err != OK) {

        ret = STATUS_ERROR_FMT(ERROR_INVALID_OPERATION,

                "Error retrieving camera info from device %d: %s (%d)", cameraId,
@@ -512,13 +448,19 @@ Status CameraService::getCameraInfo(int cameraId, 
    return ret;

}



int CameraService::cameraIdToInt(const String8& cameraId) {

    int id;

    bool success = base::ParseInt(cameraId.string(), &id, 0);

    if (!success) {

        return -1;

std::string CameraService::cameraIdIntToStrLocked(int cameraIdInt) {

    if (cameraIdInt < 0 || cameraIdInt >= static_cast<int>(mNormalDeviceIds.size())) {

        ALOGE("%s: input id %d invalid: valid range  (0, %zu)",

                __FUNCTION__, cameraIdInt, mNormalDeviceIds.size());

        return std::string{};

    }



    return mNormalDeviceIds[cameraIdInt];

}

    return id;



String8 CameraService::cameraIdIntToStr(int cameraIdInt) {

    Mutex::Autolock lock(mServiceLock);

    return String8(cameraIdIntToStrLocked(cameraIdInt).c_str());

}



Status CameraService::getCameraCharacteristics(const String16& cameraId,
@@ -635,8 +577,8 @@ Status CameraService::filterGetInfoErrorCode(status_t err) { 


Status CameraService::makeClient(const sp<CameraService>& cameraService,

        const sp<IInterface>& cameraCb, const String16& packageName, const String8& cameraId,

        int facing, int clientPid, uid_t clientUid, int servicePid, bool legacyMode,

        int halVersion, int deviceVersion, apiLevel effectiveApiLevel,

        int api1CameraId, int facing, int clientPid, uid_t clientUid, int servicePid,

        bool legacyMode, int halVersion, int deviceVersion, apiLevel effectiveApiLevel,

        /*out*/sp<BasicClient>* client) {



    if (halVersion < 0 || halVersion == deviceVersion) {
@@ -646,8 +588,9 @@ Status CameraService::makeClient(const sp<CameraService>& cameraService, 
          case CAMERA_DEVICE_API_VERSION_1_0:

            if (effectiveApiLevel == API_1) {  // Camera1 API route

                sp<ICameraClient> tmp = static_cast<ICameraClient*>(cameraCb.get());

                *client = new CameraClient(cameraService, tmp, packageName, cameraIdToInt(cameraId),

                        facing, clientPid, clientUid, getpid(), legacyMode);

                *client = new CameraClient(cameraService, tmp, packageName,

                        api1CameraId, facing, clientPid, clientUid,

                        getpid(), legacyMode);

            } else { // Camera2 API route

                ALOGW("Camera using old HAL version: %d", deviceVersion);

                return STATUS_ERROR_FMT(ERROR_DEPRECATED_HAL,
@@ -662,8 +605,10 @@ Status CameraService::makeClient(const sp<CameraService>& cameraService, 
          case CAMERA_DEVICE_API_VERSION_3_4:

            if (effectiveApiLevel == API_1) { // Camera1 API route

                sp<ICameraClient> tmp = static_cast<ICameraClient*>(cameraCb.get());

                *client = new Camera2Client(cameraService, tmp, packageName, cameraIdToInt(cameraId),

                        facing, clientPid, clientUid, servicePid, legacyMode);

                *client = new Camera2Client(cameraService, tmp, packageName,

                        cameraId, api1CameraId,

                        facing, clientPid, clientUid,

                        servicePid, legacyMode);

            } else { // Camera2 API route

                sp<hardware::camera2::ICameraDeviceCallbacks> tmp =

                        static_cast<hardware::camera2::ICameraDeviceCallbacks*>(cameraCb.get());
@@ -685,8 +630,9 @@ Status CameraService::makeClient(const sp<CameraService>& cameraService, 
            halVersion == CAMERA_DEVICE_API_VERSION_1_0) {

            // Only support higher HAL version device opened as HAL1.0 device.

            sp<ICameraClient> tmp = static_cast<ICameraClient*>(cameraCb.get());

            *client = new CameraClient(cameraService, tmp, packageName, cameraIdToInt(cameraId),

                    facing, clientPid, clientUid, servicePid, legacyMode);

            *client = new CameraClient(cameraService, tmp, packageName,

                    api1CameraId, 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"
@@ -782,7 +728,8 @@ Status CameraService::initializeShimMetadata(int cameraId) { 
    Status ret = Status::ok();

    sp<Client> tmp = nullptr;

    if (!(ret = connectHelper<ICameraClient,Client>(

            sp<ICameraClient>{nullptr}, id, static_cast<int>(CAMERA_HAL_API_VERSION_UNSPECIFIED),

            sp<ICameraClient>{nullptr}, id, cameraId,

            static_cast<int>(CAMERA_HAL_API_VERSION_UNSPECIFIED),

            internalPackageName, uid, USE_CALLING_PID,

            API_1, /*legacyMode*/ false, /*shimUpdateOnly*/ true,

            /*out*/ tmp)
@@ -1235,7 +1182,7 @@ status_t CameraService::handleEvictionsLocked(const String8& cameraId, int clien 


Status CameraService::connect(

        const sp<ICameraClient>& cameraClient,

        int cameraId,

        int api1CameraId,

        const String16& clientPackageName,

        int clientUid,

        int clientPid,
@@ -1244,9 +1191,10 @@ Status CameraService::connect( 


    ATRACE_CALL();

    Status ret = Status::ok();

    String8 id = String8::format("%d", cameraId);



    String8 id = cameraIdIntToStr(api1CameraId);

    sp<Client> client = nullptr;

    ret = connectHelper<ICameraClient,Client>(cameraClient, id,

    ret = connectHelper<ICameraClient,Client>(cameraClient, id, api1CameraId,

            CAMERA_HAL_API_VERSION_UNSPECIFIED, clientPackageName, clientUid, clientPid, API_1,

            /*legacyMode*/ false, /*shimUpdateOnly*/ false,

            /*out*/client);
@@ -1263,18 +1211,18 @@ Status CameraService::connect( 


Status CameraService::connectLegacy(

        const sp<ICameraClient>& cameraClient,

        int cameraId, int halVersion,

        int api1CameraId, int halVersion,

        const String16& clientPackageName,

        int clientUid,

        /*out*/

        sp<ICamera>* device) {



    ATRACE_CALL();

    String8 id = String8::format("%d", cameraId);

    String8 id = cameraIdIntToStr(api1CameraId);



    Status ret = Status::ok();

    sp<Client> client = nullptr;

    ret = connectHelper<ICameraClient,Client>(cameraClient, id, halVersion,

    ret = connectHelper<ICameraClient,Client>(cameraClient, id, api1CameraId, halVersion,

            clientPackageName, clientUid, USE_CALLING_PID, API_1,

            /*legacyMode*/ true, /*shimUpdateOnly*/ false,

            /*out*/client);
@@ -1302,6 +1250,7 @@ Status CameraService::connectDevice( 
    String8 id = String8(cameraId);

    sp<CameraDeviceClient> client = nullptr;

    ret = connectHelper<hardware::camera2::ICameraDeviceCallbacks,CameraDeviceClient>(cameraCb, id,

            /*api1CameraId*/-1,

            CAMERA_HAL_API_VERSION_UNSPECIFIED, clientPackageName,

            clientUid, USE_CALLING_PID, API_2,

            /*legacyMode*/ false, /*shimUpdateOnly*/ false,
@@ -1319,8 +1268,8 @@ Status CameraService::connectDevice( 


template<class CALLBACK, class CLIENT>

Status CameraService::connectHelper(const sp<CALLBACK>& cameraCb, const String8& cameraId,

        int halVersion, const String16& clientPackageName, int clientUid, int clientPid,

        apiLevel effectiveApiLevel, bool legacyMode, bool shimUpdateOnly,

        int api1CameraId, int halVersion, const String16& clientPackageName, int clientUid,

        int clientPid, apiLevel effectiveApiLevel, bool legacyMode, bool shimUpdateOnly,

        /*out*/sp<CLIENT>& device) {

    binder::Status ret = binder::Status::ok();
@@ -1403,8 +1352,10 @@ Status CameraService::connectHelper(const sp<CALLBACK>& cameraCb, const String8& 
        }



        sp<BasicClient> tmp = nullptr;

        if(!(ret = makeClient(this, cameraCb, clientPackageName, cameraId, facing, clientPid,

                clientUid, getpid(), legacyMode, halVersion, deviceVersion, effectiveApiLevel,

        if(!(ret = makeClient(this, cameraCb, clientPackageName,

                cameraId, api1CameraId, facing,

                clientPid, clientUid, getpid(), legacyMode,

                halVersion, deviceVersion, effectiveApiLevel,

                /*out*/&tmp)).isOk()) {

            return ret;

        }
@@ -2112,7 +2063,8 @@ void CameraService::playSound(sound_kind kind) { 
CameraService::Client::Client(const sp<CameraService>& cameraService,

        const sp<ICameraClient>& cameraClient,

        const String16& clientPackageName,

        const String8& cameraIdStr, int cameraFacing,

        const String8& cameraIdStr,

        int api1CameraId, int cameraFacing,

        int clientPid, uid_t clientUid,

        int servicePid) :

        CameraService::BasicClient(cameraService,
@@ -2121,7 +2073,7 @@ CameraService::Client::Client(const sp<CameraService>& cameraService, 
                cameraIdStr, cameraFacing,

                clientPid, clientUid,

                servicePid),

        mCameraId(CameraService::cameraIdToInt(cameraIdStr))

        mCameraId(api1CameraId)

{

    int callingPid = getCallingPid();

    LOG1("Client::Client E (pid %d, id %d)", callingPid, mCameraId);
@@ -2676,7 +2628,10 @@ status_t CameraService::dump(int fd, const Vector<String16>& args) { 
    }

    dprintf(fd, "\n== Service global info: ==\n\n");

    dprintf(fd, "Number of camera devices: %d\n", mNumberOfCameras);

    dprintf(fd, "Number of normal camera devices: %d\n", mNumberOfNormalCameras);

    dprintf(fd, "Number of normal camera devices: %zu\n", mNormalDeviceIds.size());

    for (size_t i = 0; i < mNormalDeviceIds.size(); i++) {

        dprintf(fd, "    Device %zu maps to \"%s\"\n", i, mNormalDeviceIds[i].c_str());

    }

    String8 activeClientString = mActiveClientManager.toString();

    dprintf(fd, "Active Camera Clients:\n%s", activeClientString.string());

    dprintf(fd, "Allowed user IDs: %s\n", toString(mAllowedUsers).string());

services/camera/libcameraservice/CameraService.h

+22 −8
Original line number Diff line number Diff line
@@ -62,7 +62,6 @@ class CameraService : 
    public BinderService<CameraService>,

    public virtual ::android::hardware::BnCameraService,

    public virtual IBinder::DeathRecipient,

    public camera_module_callbacks_t,

    public virtual CameraProviderManager::StatusListener

{

    friend class BinderService<CameraService>;
@@ -333,6 +332,7 @@ public: 
                const sp<hardware::ICameraClient>& cameraClient,

                const String16& clientPackageName,

                const String8& cameraIdStr,

                int api1CameraId,

                int cameraFacing,

                int clientPid,

                uid_t clientUid,
@@ -551,7 +551,8 @@ private: 
    // Eumerate all camera providers in the system

    status_t enumerateProviders();



    // Add a new camera to camera and torch state lists or remove an unplugged one

    // Add/remove a new camera to camera and torch state lists or remove an unplugged one

    // Caller must not hold mServiceLock

    void addStates(const String8 id);

    void removeStates(const String8 id);
@@ -578,7 +579,7 @@ private: 
    // Single implementation shared between the various connect calls

    template<class CALLBACK, class CLIENT>

    binder::Status connectHelper(const sp<CALLBACK>& cameraCb, const String8& cameraId,

            int halVersion, const String16& clientPackageName,

            int api1CameraId, int halVersion, const String16& clientPackageName,

            int clientUid, int clientPid,

            apiLevel effectiveApiLevel, bool legacyMode, bool shimUpdateOnly,

            /*out*/sp<CLIENT>& device);
@@ -640,9 +641,16 @@ private: 
    void finishConnectLocked(const sp<BasicClient>& client, const DescriptorPtr& desc);



    /**

     * Returns the integer corresponding to the given camera ID string, or -1 on failure.

     * Returns the underlying camera Id string mapped to a camera id int

     * Empty string is returned when the cameraIdInt is invalid.

     */

    static int cameraIdToInt(const String8& cameraId);

    String8 cameraIdIntToStr(int cameraIdInt);



    /**

     * Returns the underlying camera Id string mapped to a camera id int

     * Empty string is returned when the cameraIdInt is invalid.

     */

    std::string cameraIdIntToStrLocked(int cameraIdInt);



    /**

     * Remove a single client corresponding to the given camera id from the list of active clients.
@@ -710,8 +718,14 @@ private: 
     */

    void dumpEventLog(int fd);



    /**

     * This method will acquire mServiceLock

     */

    void updateCameraNumAndIds();



    int                 mNumberOfCameras;

    int                 mNumberOfNormalCameras;



    std::vector<std::string> mNormalDeviceIds;



    // sounds

    MediaPlayer*        newMediaPlayer(const char *file);
@@ -821,8 +835,8 @@ private: 


    static binder::Status makeClient(const sp<CameraService>& cameraService,

            const sp<IInterface>& cameraCb, const String16& packageName, const String8& cameraId,

            int facing, int clientPid, uid_t clientUid, int servicePid, bool legacyMode,

            int halVersion, int deviceVersion, apiLevel effectiveApiLevel,

            int api1CameraId, int facing, int clientPid, uid_t clientUid, int servicePid,

            bool legacyMode, int halVersion, int deviceVersion, apiLevel effectiveApiLevel,

            /*out*/sp<BasicClient>* client);



    status_t checkCameraAccess(const String16& opPackageName);

services/camera/libcameraservice/api1/Camera2Client.cpp

+4 −3
Original line number Diff line number Diff line
@@ -49,16 +49,17 @@ static int getCallingPid() { 
Camera2Client::Camera2Client(const sp<CameraService>& cameraService,

        const sp<hardware::ICameraClient>& cameraClient,

        const String16& clientPackageName,

        int cameraId,

        const String8& cameraDeviceId,

        int api1CameraId,

        int cameraFacing,

        int clientPid,

        uid_t clientUid,

        int servicePid,

        bool legacyMode):

        Camera2ClientBase(cameraService, cameraClient, clientPackageName,

                String8::format("%d", cameraId), cameraFacing,

                cameraDeviceId, api1CameraId, cameraFacing,

                clientPid, clientUid, servicePid),

        mParameters(cameraId, cameraFacing)

        mParameters(api1CameraId, cameraFacing)

{

    ATRACE_CALL();