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

Commit a976df84 authored by Eino-Ville Talvala's avatar Eino-Ville Talvala
Browse files

Camera: Remove all camera HALv1 code 

- Delete all HALv1-related files and methods
- Adjust callpaths to not try to construct HALv1 instances
- Adjust checks to provide correct errors for incorrect camera IDs.
  Previously, incorrect camera IDs were handled by the legacy camera path,
  by accident, so some adjustments were needed to return correct errors in
  the HALv3-only world.

Test: atest CtsCameraTestCases
Bug: 136024295
Change-Id: I54541fb8aa714dd96a008244952b8ebc088c8e0f
parent ba75bf77

camera/Camera.cpp

+0 −57
Original line number Diff line number Diff line
@@ -77,63 +77,6 @@ sp<Camera> Camera::connect(int cameraId, const String16& clientPackageName, 
    return CameraBaseT::connect(cameraId, clientPackageName, clientUid, clientPid);

}



status_t Camera::connectLegacy(int cameraId, int halVersion,

        const String16& clientPackageName,

        int clientUid,

        sp<Camera>& camera)

{

    ALOGV("%s: connect legacy camera device", __FUNCTION__);

    sp<Camera> c = new Camera(cameraId);

    sp<::android::hardware::ICameraClient> cl = c;

    status_t status = NO_ERROR;

    const sp<::android::hardware::ICameraService>& cs = CameraBaseT::getCameraService();



    binder::Status ret;

    if (cs != nullptr) {

        ret = cs.get()->connectLegacy(cl, cameraId, halVersion, clientPackageName,

                clientUid, /*out*/&(c->mCamera));

    }

    if (ret.isOk() && c->mCamera != nullptr) {

        IInterface::asBinder(c->mCamera)->linkToDeath(c);

        c->mStatus = NO_ERROR;

        camera = c;

    } else {

        switch(ret.serviceSpecificErrorCode()) {

            case hardware::ICameraService::ERROR_DISCONNECTED:

                status = -ENODEV;

                break;

            case hardware::ICameraService::ERROR_CAMERA_IN_USE:

                status = -EBUSY;

                break;

            case hardware::ICameraService::ERROR_INVALID_OPERATION:

                status = -EINVAL;

                break;

            case hardware::ICameraService::ERROR_MAX_CAMERAS_IN_USE:

                status = -EUSERS;

                break;

            case hardware::ICameraService::ERROR_ILLEGAL_ARGUMENT:

                status = BAD_VALUE;

                break;

            case hardware::ICameraService::ERROR_DEPRECATED_HAL:

                status = -EOPNOTSUPP;

                break;

            case hardware::ICameraService::ERROR_DISABLED:

                status = -EACCES;

                break;

            case hardware::ICameraService::ERROR_PERMISSION_DENIED:

                status = PERMISSION_DENIED;

                break;

            default:

                status = -EINVAL;

                ALOGW("An error occurred while connecting to camera %d: %s", cameraId,

                        (cs != nullptr) ? "Service not available" : ret.toString8().string());

                break;

        }

        c.clear();

    }

    return status;

}



status_t Camera::reconnect()

{

    ALOGV("reconnect");

camera/aidl/android/hardware/ICameraService.aidl

+1 −15
Original line number Diff line number Diff line
@@ -69,7 +69,7 @@ interface ICameraService 


    /**

     * Default UID/PID values for non-privileged callers of

     * connect(), connectDevice(), and connectLegacy()

     * connect() and connectDevice()

     */

    const int USE_CALLING_UID = -1;

    const int USE_CALLING_PID = -1;
@@ -92,20 +92,6 @@ interface ICameraService 
            @nullable String featureId,

            int clientUid);



    /**

     * halVersion constant for connectLegacy

     */

    const int CAMERA_HAL_API_VERSION_UNSPECIFIED = -1;



    /**

     * Open a camera device in legacy mode, if supported by the camera module HAL.

     */

    ICamera connectLegacy(ICameraClient client,

            int cameraId,

            int halVersion,

            String opPackageName,

            int clientUid);



    /**

     * Add listener for changes to camera device and flashlight state.

     *

camera/include/camera/Camera.h

+0 −4
Original line number Diff line number Diff line
@@ -84,10 +84,6 @@ public: 
                                const String16& clientPackageName,

                                int clientUid, int clientPid);



    static  status_t  connectLegacy(int cameraId, int halVersion,

                                     const String16& clientPackageName,

                                     int clientUid, sp<Camera>& camera);



            virtual     ~Camera();



            status_t    reconnect();

services/camera/libcameraservice/Android.bp

+0 −3
Original line number Diff line number Diff line
@@ -30,7 +30,6 @@ cc_library_shared { 
        "common/CameraProviderManager.cpp",

        "common/DepthPhotoProcessor.cpp",

        "common/FrameProcessorBase.cpp",

        "api1/CameraClient.cpp",

        "api1/Camera2Client.cpp",

        "api1/client2/Parameters.cpp",

        "api1/client2/FrameProcessor.cpp",
@@ -46,7 +45,6 @@ cc_library_shared { 
        "api2/DepthCompositeStream.cpp",

        "api2/HeicEncoderInfoManager.cpp",

        "api2/HeicCompositeStream.cpp",

        "device1/CameraHardwareInterface.cpp",

        "device3/BufferUtils.cpp",

        "device3/Camera3Device.cpp",

        "device3/Camera3OfflineSession.cpp",
@@ -122,7 +120,6 @@ cc_library_shared { 
        "android.hardware.camera.provider@2.4",

        "android.hardware.camera.provider@2.5",

        "android.hardware.camera.provider@2.6",

        "android.hardware.camera.device@1.0",

        "android.hardware.camera.device@3.2",

        "android.hardware.camera.device@3.3",

        "android.hardware.camera.device@3.4",

services/camera/libcameraservice/CameraFlashlight.cpp

+2 −270
Original line number Diff line number Diff line
@@ -59,9 +59,8 @@ status_t CameraFlashlight::createFlashlightControl(const String8& cameraId) { 
    if (mProviderManager->supportSetTorchMode(cameraId.string())) {

        mFlashControl = new ProviderFlashControl(mProviderManager);

    } else {

        // Only HAL1 devices do not support setTorchMode

        mFlashControl =

                new CameraHardwareInterfaceFlashControl(mProviderManager, mCallbacks);

        ALOGE("Flashlight control not supported by this device!");

        return NO_INIT;

    }



    return OK;
@@ -309,271 +308,4 @@ status_t ProviderFlashControl::setTorchMode(const String8& cameraId, bool enable 
}

// ProviderFlashControl implementation ends



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

// CameraHardwareInterfaceFlashControl implementation begins

// Flash control for camera module <= v2.3 and camera HAL v1

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



CameraHardwareInterfaceFlashControl::CameraHardwareInterfaceFlashControl(

        sp<CameraProviderManager> manager,

        CameraProviderManager::StatusListener* callbacks) :

        mProviderManager(manager),

        mCallbacks(callbacks),

        mTorchEnabled(false) {

}



CameraHardwareInterfaceFlashControl::~CameraHardwareInterfaceFlashControl() {

    disconnectCameraDevice();



    mSurface.clear();

    mSurfaceTexture.clear();

    mProducer.clear();

    mConsumer.clear();



    if (mTorchEnabled) {

        if (mCallbacks) {

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

                    __FUNCTION__);

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

        }

    }

}



status_t CameraHardwareInterfaceFlashControl::setTorchMode(

        const String8& cameraId, bool enabled) {

    Mutex::Autolock l(mLock);



    // pre-check

    status_t res;

    if (enabled) {

        bool hasFlash = false;

        // Check if it has a flash unit and leave camera device open.

        res = hasFlashUnitLocked(cameraId, &hasFlash, /*keepDeviceOpen*/true);

        // invalid camera?

        if (res) {

            // hasFlashUnitLocked() returns BAD_INDEX if mDevice is connected to

            // another camera device.

            return res == BAD_INDEX ? BAD_INDEX : -EINVAL;

        }

        // no flash unit?

        if (!hasFlash) {

            // Disconnect camera device if it has no flash.

            disconnectCameraDevice();

            return -ENOSYS;

        }

    } else if (mDevice == NULL || cameraId != mCameraId) {

        // disabling the torch mode of an un-opened or different device.

        return OK;

    } else {

        // disabling the torch mode of currently opened device

        disconnectCameraDevice();

        mTorchEnabled = false;

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

        return OK;

    }



    res = startPreviewAndTorch();

    if (res) {

        return res;

    }



    mTorchEnabled = true;

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

    return OK;

}



status_t CameraHardwareInterfaceFlashControl::hasFlashUnit(

        const String8& cameraId, bool *hasFlash) {

    Mutex::Autolock l(mLock);

    // Close device after checking if it has a flash unit.

    return hasFlashUnitLocked(cameraId, hasFlash, /*keepDeviceOpen*/false);

}



status_t CameraHardwareInterfaceFlashControl::hasFlashUnitLocked(

        const String8& cameraId, bool *hasFlash, bool keepDeviceOpen) {

    bool closeCameraDevice = false;



    if (!hasFlash) {

        return BAD_VALUE;

    }



    status_t res;

    if (mDevice == NULL) {

        // Connect to camera device to query if it has a flash unit.

        res = connectCameraDevice(cameraId);

        if (res) {

            return res;

        }

        // Close camera device only when it is just opened and the caller doesn't want to keep

        // the camera device open.

        closeCameraDevice = !keepDeviceOpen;

    }



    if (cameraId != mCameraId) {

        return BAD_INDEX;

    }



    const char *flashMode =

            mParameters.get(CameraParameters::KEY_SUPPORTED_FLASH_MODES);

    if (flashMode && strstr(flashMode, CameraParameters::FLASH_MODE_TORCH)) {

        *hasFlash = true;

    } else {

        *hasFlash = false;

    }



    if (closeCameraDevice) {

        res = disconnectCameraDevice();

        if (res != OK) {

            ALOGE("%s: Failed to disconnect camera device. %s (%d)", __FUNCTION__,

                    strerror(-res), res);

            return res;

        }

    }



    return OK;

}



status_t CameraHardwareInterfaceFlashControl::startPreviewAndTorch() {

    status_t res = OK;

    res = mDevice->startPreview();

    if (res) {

        ALOGE("%s: start preview failed. %s (%d)", __FUNCTION__,

                strerror(-res), res);

        return res;

    }



    mParameters.set(CameraParameters::KEY_FLASH_MODE,

            CameraParameters::FLASH_MODE_TORCH);



    return mDevice->setParameters(mParameters);

}



status_t CameraHardwareInterfaceFlashControl::getSmallestSurfaceSize(

        int32_t *width, int32_t *height) {

    if (!width || !height) {

        return BAD_VALUE;

    }



    int32_t w = INT32_MAX;

    int32_t h = 1;

    Vector<Size> sizes;



    mParameters.getSupportedPreviewSizes(sizes);

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

        Size s = sizes[i];

        if (w * h > s.width * s.height) {

            w = s.width;

            h = s.height;

        }

    }



    if (w == INT32_MAX) {

        return NAME_NOT_FOUND;

    }



    *width = w;

    *height = h;



    return OK;

}



status_t CameraHardwareInterfaceFlashControl::initializePreviewWindow(

        const sp<CameraHardwareInterface>& device, int32_t width, int32_t height) {

    status_t res;

    BufferQueue::createBufferQueue(&mProducer, &mConsumer);



    mSurfaceTexture = new GLConsumer(mConsumer, 0, GLConsumer::TEXTURE_EXTERNAL,

            true, true);

    if (mSurfaceTexture == NULL) {

        return NO_MEMORY;

    }



    int32_t format = HAL_PIXEL_FORMAT_IMPLEMENTATION_DEFINED;

    res = mSurfaceTexture->setDefaultBufferSize(width, height);

    if (res) {

        return res;

    }

    res = mSurfaceTexture->setDefaultBufferFormat(format);

    if (res) {

        return res;

    }



    mSurface = new Surface(mProducer, /*useAsync*/ true);

    if (mSurface == NULL) {

        return NO_MEMORY;

    }



    res = native_window_api_connect(mSurface.get(), NATIVE_WINDOW_API_CAMERA);

    if (res) {

        ALOGE("%s: Unable to connect to native window", __FUNCTION__);

        return res;

    }



    return device->setPreviewWindow(mSurface);

}



status_t CameraHardwareInterfaceFlashControl::connectCameraDevice(

        const String8& cameraId) {

    sp<CameraHardwareInterface> device =

            new CameraHardwareInterface(cameraId.string());



    status_t res = device->initialize(mProviderManager);

    if (res) {

        ALOGE("%s: initializing camera %s failed", __FUNCTION__,

                cameraId.string());

        return res;

    }



    // need to set __get_memory in set_callbacks().

    device->setCallbacks(NULL, NULL, NULL, NULL, NULL);



    mParameters = device->getParameters();



    int32_t width, height;

    res = getSmallestSurfaceSize(&width, &height);

    if (res) {

        ALOGE("%s: failed to get smallest surface size for camera %s",

                __FUNCTION__, cameraId.string());

        return res;

    }



    res = initializePreviewWindow(device, width, height);

    if (res) {

        ALOGE("%s: failed to initialize preview window for camera %s",

                __FUNCTION__, cameraId.string());

        return res;

    }



    mCameraId = cameraId;

    mDevice = device;

    return OK;

}



status_t CameraHardwareInterfaceFlashControl::disconnectCameraDevice() {

    if (mDevice == NULL) {

        return OK;

    }



    if (mParameters.get(CameraParameters::KEY_FLASH_MODE)) {

        // There is a flash, turn if off.

        // (If there isn't one, leave the parameter null)

        mParameters.set(CameraParameters::KEY_FLASH_MODE,

                CameraParameters::FLASH_MODE_OFF);

        mDevice->setParameters(mParameters);

    }

    mDevice->stopPreview();

    status_t res = native_window_api_disconnect(mSurface.get(),

            NATIVE_WINDOW_API_CAMERA);

    if (res) {

        ALOGW("%s: native_window_api_disconnect failed: %s (%d)",

                __FUNCTION__, strerror(-res), res);

    }

    mDevice->setPreviewWindow(NULL);

    mDevice->release();

    mDevice = NULL;



    return OK;

}

// CameraHardwareInterfaceFlashControl implementation ends



}