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

Commit 99f69fed authored by Eino-Ville Talvala's avatar Eino-Ville Talvala Committed by Android (Google) Code Review
Browse files

Merge changes from topic "remove-camera-halv1-support" 

* changes:
  Camera: Remove old recording path support
  Camera: Remove all camera HALv1 code
parents 8b202fab b8ed8efe

camera/Android.bp

+0 −1
Original line number Diff line number Diff line
@@ -38,7 +38,6 @@ cc_library_shared { 
        "ICamera.cpp",

        "ICameraClient.cpp",

        "ICameraRecordingProxy.cpp",

        "ICameraRecordingProxyListener.cpp",

        "camera2/CaptureRequest.cpp",

        "camera2/ConcurrentCamera.cpp",

        "camera2/OutputConfiguration.cpp",

camera/Camera.cpp

+1 −126
Original line number Diff line number Diff line
@@ -25,7 +25,6 @@ 
#include <binder/IMemory.h>



#include <Camera.h>

#include <ICameraRecordingProxyListener.h>

#include <android/hardware/ICameraService.h>

#include <android/hardware/ICamera.h>
@@ -77,63 +76,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");
@@ -214,10 +156,6 @@ void Camera::stopPreview() 
void Camera::stopRecording()

{

    ALOGV("stopRecording");

    {

        Mutex::Autolock _l(mLock);

        mRecordingProxyListener.clear();

    }

    sp <::android::hardware::ICamera> c = mCamera;

    if (c == 0) return;

    c->stopRecording();
@@ -325,12 +263,6 @@ void Camera::setListener(const sp<CameraListener>& listener) 
    mListener = listener;

}



void Camera::setRecordingProxyListener(const sp<ICameraRecordingProxyListener>& listener)

{

    Mutex::Autolock _l(mLock);

    mRecordingProxyListener = listener;

}



void Camera::setPreviewCallbackFlags(int flag)

{

    ALOGV("setPreviewCallbackFlags");
@@ -384,19 +316,6 @@ void Camera::dataCallback(int32_t msgType, const sp<IMemory>& dataPtr, 
// callback from camera service when timestamped frame is ready

void Camera::dataCallbackTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& dataPtr)

{

    // If recording proxy listener is registered, forward the frame and return.

    // The other listener (mListener) is ignored because the receiver needs to

    // call releaseRecordingFrame.

    sp<ICameraRecordingProxyListener> proxylistener;

    {

        Mutex::Autolock _l(mLock);

        proxylistener = mRecordingProxyListener;

    }

    if (proxylistener != NULL) {

        proxylistener->dataCallbackTimestamp(timestamp, msgType, dataPtr);

        return;

    }



    sp<CameraListener> listener;

    {

        Mutex::Autolock _l(mLock);
@@ -413,19 +332,6 @@ void Camera::dataCallbackTimestamp(nsecs_t timestamp, int32_t msgType, const sp< 


void Camera::recordingFrameHandleCallbackTimestamp(nsecs_t timestamp, native_handle_t* handle)

{

    // If recording proxy listener is registered, forward the frame and return.

    // The other listener (mListener) is ignored because the receiver needs to

    // call releaseRecordingFrameHandle.

    sp<ICameraRecordingProxyListener> proxylistener;

    {

        Mutex::Autolock _l(mLock);

        proxylistener = mRecordingProxyListener;

    }

    if (proxylistener != NULL) {

        proxylistener->recordingFrameHandleCallbackTimestamp(timestamp, handle);

        return;

    }



    sp<CameraListener> listener;

    {

        Mutex::Autolock _l(mLock);
@@ -444,19 +350,6 @@ void Camera::recordingFrameHandleCallbackTimestampBatch( 
        const std::vector<nsecs_t>& timestamps,

        const std::vector<native_handle_t*>& handles)

{

    // If recording proxy listener is registered, forward the frame and return.

    // The other listener (mListener) is ignored because the receiver needs to

    // call releaseRecordingFrameHandle.

    sp<ICameraRecordingProxyListener> proxylistener;

    {

        Mutex::Autolock _l(mLock);

        proxylistener = mRecordingProxyListener;

    }

    if (proxylistener != NULL) {

        proxylistener->recordingFrameHandleCallbackTimestampBatch(timestamps, handles);

        return;

    }



    sp<CameraListener> listener;

    {

        Mutex::Autolock _l(mLock);
@@ -476,10 +369,9 @@ sp<ICameraRecordingProxy> Camera::getRecordingProxy() { 
    return new RecordingProxy(this);

}



status_t Camera::RecordingProxy::startRecording(const sp<ICameraRecordingProxyListener>& listener)

status_t Camera::RecordingProxy::startRecording()

{

    ALOGV("RecordingProxy::startRecording");

    mCamera->setRecordingProxyListener(listener);

    mCamera->reconnect();

    return mCamera->startRecording();

}
@@ -490,23 +382,6 @@ void Camera::RecordingProxy::stopRecording() 
    mCamera->stopRecording();

}



void Camera::RecordingProxy::releaseRecordingFrame(const sp<IMemory>& mem)

{

    ALOGV("RecordingProxy::releaseRecordingFrame");

    mCamera->releaseRecordingFrame(mem);

}



void Camera::RecordingProxy::releaseRecordingFrameHandle(native_handle_t* handle) {

    ALOGV("RecordingProxy::releaseRecordingFrameHandle");

    mCamera->releaseRecordingFrameHandle(handle);

}



void Camera::RecordingProxy::releaseRecordingFrameHandleBatch(

        const std::vector<native_handle_t*>& handles) {

    ALOGV("RecordingProxy::releaseRecordingFrameHandleBatch");

    mCamera->releaseRecordingFrameHandleBatch(handles);

}



Camera::RecordingProxy::RecordingProxy(const sp<Camera>& camera)

{

    mCamera = camera;

camera/ICameraRecordingProxy.cpp

+3 −91
Original line number Diff line number Diff line
@@ -18,7 +18,6 @@ 
#define LOG_TAG "ICameraRecordingProxy"

#include <camera/CameraUtils.h>

#include <camera/ICameraRecordingProxy.h>

#include <camera/ICameraRecordingProxyListener.h>

#include <binder/IMemory.h>

#include <binder/Parcel.h>

#include <media/hardware/HardwareAPI.h>
@@ -29,10 +28,7 @@ namespace android { 


enum {

    START_RECORDING = IBinder::FIRST_CALL_TRANSACTION,

    STOP_RECORDING,

    RELEASE_RECORDING_FRAME,

    RELEASE_RECORDING_FRAME_HANDLE,

    RELEASE_RECORDING_FRAME_HANDLE_BATCH,

    STOP_RECORDING

};
@@ -44,12 +40,11 @@ public: 
    {

    }



    status_t startRecording(const sp<ICameraRecordingProxyListener>& listener)

    status_t startRecording()

    {

        ALOGV("startRecording");

        Parcel data, reply;

        data.writeInterfaceToken(ICameraRecordingProxy::getInterfaceDescriptor());

        data.writeStrongBinder(IInterface::asBinder(listener));

        remote()->transact(START_RECORDING, data, &reply);

        return reply.readInt32();

    }
@@ -61,46 +56,6 @@ public: 
        data.writeInterfaceToken(ICameraRecordingProxy::getInterfaceDescriptor());

        remote()->transact(STOP_RECORDING, data, &reply);

    }



    void releaseRecordingFrame(const sp<IMemory>& mem)

    {

        ALOGV("releaseRecordingFrame");

        Parcel data, reply;

        data.writeInterfaceToken(ICameraRecordingProxy::getInterfaceDescriptor());

        data.writeStrongBinder(IInterface::asBinder(mem));

        remote()->transact(RELEASE_RECORDING_FRAME, data, &reply);

    }



    void releaseRecordingFrameHandle(native_handle_t *handle) {

        ALOGV("releaseRecordingFrameHandle");

        Parcel data, reply;

        data.writeInterfaceToken(ICameraRecordingProxy::getInterfaceDescriptor());

        data.writeNativeHandle(handle);



        remote()->transact(RELEASE_RECORDING_FRAME_HANDLE, data, &reply);



        // Close the native handle because camera received a dup copy.

        native_handle_close(handle);

        native_handle_delete(handle);

    }



    void releaseRecordingFrameHandleBatch(const std::vector<native_handle_t*>& handles) {

        ALOGV("releaseRecordingFrameHandleBatch");

        Parcel data, reply;

        data.writeInterfaceToken(ICameraRecordingProxy::getInterfaceDescriptor());

        uint32_t n = handles.size();

        data.writeUint32(n);

        for (auto& handle : handles) {

            data.writeNativeHandle(handle);

        }

        remote()->transact(RELEASE_RECORDING_FRAME_HANDLE_BATCH, data, &reply);



        // Close the native handle because camera received a dup copy.

        for (auto& handle : handles) {

            native_handle_close(handle);

            native_handle_delete(handle);

        }

    }

};



IMPLEMENT_META_INTERFACE(CameraRecordingProxy, "android.hardware.ICameraRecordingProxy");
@@ -114,9 +69,7 @@ status_t BnCameraRecordingProxy::onTransact( 
        case START_RECORDING: {

            ALOGV("START_RECORDING");

            CHECK_INTERFACE(ICameraRecordingProxy, data, reply);

            sp<ICameraRecordingProxyListener> listener =

                interface_cast<ICameraRecordingProxyListener>(data.readStrongBinder());

            reply->writeInt32(startRecording(listener));

            reply->writeInt32(startRecording());

            return NO_ERROR;

        } break;

        case STOP_RECORDING: {
@@ -125,46 +78,6 @@ status_t BnCameraRecordingProxy::onTransact( 
            stopRecording();

            return NO_ERROR;

        } break;

        case RELEASE_RECORDING_FRAME: {

            ALOGV("RELEASE_RECORDING_FRAME");

            CHECK_INTERFACE(ICameraRecordingProxy, data, reply);

            sp<IMemory> mem = interface_cast<IMemory>(data.readStrongBinder());

            releaseRecordingFrame(mem);

            return NO_ERROR;

        } break;

        case RELEASE_RECORDING_FRAME_HANDLE: {

            ALOGV("RELEASE_RECORDING_FRAME_HANDLE");

            CHECK_INTERFACE(ICameraRecordingProxy, data, reply);



            // releaseRecordingFrameHandle will be responsble to close the native handle.

            releaseRecordingFrameHandle(data.readNativeHandle());

            return NO_ERROR;

        } break;

        case RELEASE_RECORDING_FRAME_HANDLE_BATCH: {

            ALOGV("RELEASE_RECORDING_FRAME_HANDLE_BATCH");

            CHECK_INTERFACE(ICameraRecordingProxy, data, reply);

            uint32_t n = 0;

            status_t res = data.readUint32(&n);

            if (res != OK) {

                ALOGE("%s: Failed to read batch size: %s (%d)", __FUNCTION__, strerror(-res), res);

                return BAD_VALUE;

            }

            std::vector<native_handle_t*> handles;

            handles.reserve(n);

            for (uint32_t i = 0; i < n; i++) {

                native_handle_t* handle = data.readNativeHandle();

                if (handle == nullptr) {

                    ALOGE("%s: Received a null native handle at handles[%d]",

                            __FUNCTION__, i);

                    return BAD_VALUE;

                }

                handles.push_back(handle);

            }



            // releaseRecordingFrameHandleBatch will be responsble to close the native handle.

            releaseRecordingFrameHandleBatch(handles);

            return NO_ERROR;

        } break;

        default:

            return BBinder::onTransact(code, data, reply, flags);

    }
@@ -173,4 +86,3 @@ status_t BnCameraRecordingProxy::onTransact( 
// ----------------------------------------------------------------------------



}; // namespace android

camera/ICameraRecordingProxyListener.cpp

deleted100644 → 0
+0 −180
Original line number Diff line number Diff line 
/*

 * Copyright (C) 2011 The Android Open Source Project

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *      http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



//#define LOG_NDEBUG 0

#define LOG_TAG "ICameraRecordingProxyListener"

#include <camera/CameraUtils.h>

#include <camera/ICameraRecordingProxyListener.h>

#include <binder/IMemory.h>

#include <binder/Parcel.h>

#include <media/hardware/HardwareAPI.h>

#include <utils/Log.h>



namespace android {



enum {

    DATA_CALLBACK_TIMESTAMP = IBinder::FIRST_CALL_TRANSACTION,

    RECORDING_FRAME_HANDLE_CALLBACK_TIMESTAMP,

    RECORDING_FRAME_HANDLE_CALLBACK_TIMESTAMP_BATCH

};



class BpCameraRecordingProxyListener: public BpInterface<ICameraRecordingProxyListener>

{

public:

    explicit BpCameraRecordingProxyListener(const sp<IBinder>& impl)

        : BpInterface<ICameraRecordingProxyListener>(impl)

    {

    }



    void dataCallbackTimestamp(nsecs_t timestamp, int32_t msgType, const sp<IMemory>& imageData)

    {

        ALOGV("dataCallback");

        Parcel data, reply;

        data.writeInterfaceToken(ICameraRecordingProxyListener::getInterfaceDescriptor());

        data.writeInt64(timestamp);

        data.writeInt32(msgType);

        data.writeStrongBinder(IInterface::asBinder(imageData));

        remote()->transact(DATA_CALLBACK_TIMESTAMP, data, &reply, IBinder::FLAG_ONEWAY);

    }



    void recordingFrameHandleCallbackTimestamp(nsecs_t timestamp, native_handle_t* handle) {

        ALOGV("recordingFrameHandleCallbackTimestamp");

        Parcel data, reply;

        data.writeInterfaceToken(ICameraRecordingProxyListener::getInterfaceDescriptor());

        data.writeInt64(timestamp);

        data.writeNativeHandle(handle);

        remote()->transact(RECORDING_FRAME_HANDLE_CALLBACK_TIMESTAMP, data, &reply,

                IBinder::FLAG_ONEWAY);



        // The native handle is dupped in ICameraClient so we need to free it here.

        native_handle_close(handle);

        native_handle_delete(handle);

    }



    void recordingFrameHandleCallbackTimestampBatch(

            const std::vector<nsecs_t>& timestamps,

            const std::vector<native_handle_t*>& handles) {

        ALOGV("recordingFrameHandleCallbackTimestampBatch");

        Parcel data, reply;

        data.writeInterfaceToken(ICameraRecordingProxyListener::getInterfaceDescriptor());



        uint32_t n = timestamps.size();

        if (n != handles.size()) {

            ALOGE("%s: size of timestamps(%zu) and handles(%zu) mismatch!",

                    __FUNCTION__, timestamps.size(), handles.size());

            return;

        }

        data.writeUint32(n);

        for (auto ts : timestamps) {

            data.writeInt64(ts);

        }

        for (auto& handle : handles) {

            data.writeNativeHandle(handle);

        }

        remote()->transact(RECORDING_FRAME_HANDLE_CALLBACK_TIMESTAMP_BATCH, data, &reply,

                IBinder::FLAG_ONEWAY);



        // The native handle is dupped in ICameraClient so we need to free it here.

        for (auto& handle : handles) {

            native_handle_close(handle);

            native_handle_delete(handle);

        }

    }

};



IMPLEMENT_META_INTERFACE(CameraRecordingProxyListener, "android.hardware.ICameraRecordingProxyListener");



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



status_t BnCameraRecordingProxyListener::onTransact(

    uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)

{

    switch(code) {

        case DATA_CALLBACK_TIMESTAMP: {

            ALOGV("DATA_CALLBACK_TIMESTAMP");

            CHECK_INTERFACE(ICameraRecordingProxyListener, data, reply);

            nsecs_t timestamp = data.readInt64();

            int32_t msgType = data.readInt32();

            sp<IMemory> imageData = interface_cast<IMemory>(data.readStrongBinder());

            dataCallbackTimestamp(timestamp, msgType, imageData);

            return NO_ERROR;

        } break;

        case RECORDING_FRAME_HANDLE_CALLBACK_TIMESTAMP: {

            ALOGV("RECORDING_FRAME_HANDLE_CALLBACK_TIMESTAMP");

            CHECK_INTERFACE(ICameraRecordingProxyListener, data, reply);

            nsecs_t timestamp;

            status_t res = data.readInt64(&timestamp);

            if (res != OK) {

                ALOGE("%s: Failed to read timestamp: %s (%d)", __FUNCTION__, strerror(-res), res);

                return BAD_VALUE;

            }



            native_handle_t* handle = data.readNativeHandle();

            if (handle == nullptr) {

                ALOGE("%s: Received a null native handle", __FUNCTION__);

                return BAD_VALUE;

            }

            // The native handle will be freed in

            // BpCameraRecordingProxy::releaseRecordingFrameHandle.

            recordingFrameHandleCallbackTimestamp(timestamp, handle);

            return NO_ERROR;

        } break;

        case RECORDING_FRAME_HANDLE_CALLBACK_TIMESTAMP_BATCH: {

            ALOGV("RECORDING_FRAME_HANDLE_CALLBACK_TIMESTAMP_BATCH");

            CHECK_INTERFACE(ICameraRecordingProxyListener, data, reply);

            uint32_t n = 0;

            status_t res = data.readUint32(&n);

            if (res != OK) {

                ALOGE("%s: Failed to read batch size: %s (%d)", __FUNCTION__, strerror(-res), res);

                return BAD_VALUE;

            }

            std::vector<nsecs_t> timestamps;

            std::vector<native_handle_t*> handles;

            timestamps.reserve(n);

            handles.reserve(n);

            for (uint32_t i = 0; i < n; i++) {

                nsecs_t t;

                res = data.readInt64(&t);

                if (res != OK) {

                    ALOGE("%s: Failed to read timestamp[%d]: %s (%d)",

                            __FUNCTION__, i, strerror(-res), res);

                    return BAD_VALUE;

                }

                timestamps.push_back(t);

            }

            for (uint32_t i = 0; i < n; i++) {

                native_handle_t* handle = data.readNativeHandle();

                if (handle == nullptr) {

                    ALOGE("%s: Received a null native handle at handles[%d]",

                            __FUNCTION__, i);

                    return BAD_VALUE;

                }

                handles.push_back(handle);

            }

            // The native handle will be freed in

            // BpCameraRecordingProxy::releaseRecordingFrameHandleBatch.

            recordingFrameHandleCallbackTimestampBatch(timestamps, handles);

            return NO_ERROR;

        } break;

        default:

            return BBinder::onTransact(code, data, reply, flags);

    }

}



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



}; // namespace android

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.

     *