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

Commit 3022a11c authored by Android (Google) Code Review's avatar Android (Google) Code Review
Browse files

Merge change 1239 into donut 

* changes:
  Modify camera framework to use new streamlined binder interface. This is the second half of bug 1837832. Modifies the camera client and camera service to use the new binder interface. Removes the old binder interface. There will be one more part to this change to surface the undefined callbacks to the Java layer so that partners can implement new features without having to touch the stack.
parents 82e61c94 d6289b1b

camera/libcameraservice/CameraService.cpp

+8 −8
Original line number Diff line number Diff line
@@ -915,24 +915,24 @@ String8 CameraService::Client::getParameters() const 
void CameraService::Client::postAutoFocus(bool focused)

{

    LOGV("postAutoFocus");

    mCameraClient->autoFocusCallback(focused);

    mCameraClient->notifyCallback(CAMERA_MSG_FOCUS, (int32_t)focused, 0);

}



void CameraService::Client::postShutter()

{

    mCameraClient->shutterCallback();

    mCameraClient->notifyCallback(CAMERA_MSG_SHUTTER, 0, 0);

}



void CameraService::Client::postRaw(const sp<IMemory>& mem)

{

    LOGD("postRaw");

    mCameraClient->rawCallback(mem);

    mCameraClient->dataCallback(CAMERA_MSG_RAW_IMAGE, mem);

}



void CameraService::Client::postJpeg(const sp<IMemory>& mem)

{

    LOGD("postJpeg");

    mCameraClient->jpegCallback(mem);

    mCameraClient->dataCallback(CAMERA_MSG_COMPRESSED_IMAGE, mem);

}



void CameraService::Client::copyFrameAndPostCopiedFrame(sp<IMemoryHeap> heap, size_t offset, size_t size)
@@ -960,7 +960,7 @@ void CameraService::Client::copyFrameAndPostCopiedFrame(sp<IMemoryHeap> heap, si 
        LOGE("failed to allocate space for frame callback");

        return;

    }

    mCameraClient->previewCallback(frame);

    mCameraClient->dataCallback(CAMERA_MSG_PREVIEW_FRAME, frame);

}



void CameraService::Client::postRecordingFrame(const sp<IMemory>& frame)
@@ -970,7 +970,7 @@ void CameraService::Client::postRecordingFrame(const sp<IMemory>& frame) 
        LOGW("frame is a null pointer");

        return;

    }

    mCameraClient->recordingCallback(frame);

    mCameraClient->dataCallback(CAMERA_MSG_VIDEO_FRAME, frame);

}



void CameraService::Client::postPreviewFrame(const sp<IMemory>& mem)
@@ -1004,7 +1004,7 @@ void CameraService::Client::postPreviewFrame(const sp<IMemory>& mem) 
        copyFrameAndPostCopiedFrame(heap, offset, size);

    } else {

        LOGV("frame is directly sent out without copying");

        mCameraClient->previewCallback(mem);

        mCameraClient->dataCallback(CAMERA_MSG_PREVIEW_FRAME, mem);

    }



    // Is this is one-shot only?
@@ -1018,7 +1018,7 @@ void CameraService::Client::postPreviewFrame(const sp<IMemory>& mem) 


void CameraService::Client::postError(status_t error)

{

    mCameraClient->errorCallback(error);

    mCameraClient->notifyCallback(CAMERA_MSG_ERROR, error, 0);

}



status_t CameraService::dump(int fd, const Vector<String16>& args)

include/ui/Camera.h

+18 −8
Original line number Diff line number Diff line
@@ -63,6 +63,23 @@ namespace android { 
#define FRAME_CALLBACK_FLAG_CAMERA                   0x05

#define FRAME_CALLBACK_FLAG_BARCODE_SCANNER          0x07



// msgType in notifyCallback function

enum {

    CAMERA_MSG_ERROR,

    CAMERA_MSG_SHUTTER,

    CAMERA_MSG_FOCUS,

    CAMERA_MSG_ZOOM

};



// msgType in dataCallback function

enum {

    CAMERA_MSG_PREVIEW_FRAME,

    CAMERA_MSG_VIDEO_FRAME,

    CAMERA_MSG_POSTVIEW_FRAME,

    CAMERA_MSG_RAW_IMAGE,

    CAMERA_MSG_COMPRESSED_IMAGE

};



class ICameraService;

class ICamera;

class Surface;
@@ -136,15 +153,8 @@ public: 
            void        setAutoFocusCallback(autofocus_callback cb, void *cookie);



    // ICameraClient interface

    virtual void        shutterCallback();

    virtual void        rawCallback(const sp<IMemory>& picture);

    virtual void        jpegCallback(const sp<IMemory>& picture);

    virtual void        previewCallback(const sp<IMemory>& frame);

    virtual void        errorCallback(status_t error);

    virtual void        autoFocusCallback(bool focused);

    virtual void        recordingCallback(const sp<IMemory>& frame);

    virtual void        notifyCallback(int32_t msgType, int32_t ext, int32_t ext2);

    virtual void        dataCallback(int32_t msgType, const sp<IMemory>& frame);

    virtual void        dataCallback(int32_t msgType, const sp<IMemory>& dataPtr);



    sp<ICamera>         remote();

include/ui/ICameraClient.h

+0 −24
Original line number Diff line number Diff line
@@ -29,30 +29,6 @@ class ICameraClient: public IInterface 
public:

    DECLARE_META_INTERFACE(CameraClient);



    // msgType in notifyCallback function

    enum {

        ERROR,

        SHUTTER,

        FOCUSED,

        ZOOM

    } notify_callback_message_type;



    // msgType in dataCallback function

    enum {

        PREVIEW,

        RECORD,

        POSTVIEW,

        RAW,

        COMPRESSED

    } data_callback_message_type;



    virtual void            shutterCallback() = 0;

    virtual void            rawCallback(const sp<IMemory>& picture) = 0;

    virtual void            jpegCallback(const sp<IMemory>& picture) = 0;

    virtual void            previewCallback(const sp<IMemory>& frame) = 0;

    virtual void            errorCallback(status_t error) = 0;

    virtual void            autoFocusCallback(bool focused) = 0;

    virtual void            recordingCallback(const sp<IMemory>& frame) = 0;

    virtual void            notifyCallback(int32_t msgType, int32_t ext1, int32_t ext2) = 0;

    virtual void            dataCallback(int32_t msgType, const sp<IMemory>& data) = 0;

libs/ui/Camera.cpp

+54 −64
Original line number Diff line number Diff line
@@ -337,76 +337,66 @@ void Camera::setErrorCallback(error_callback cb, void *cookie) 
    mErrorCallbackCookie = cookie;

}



void Camera::autoFocusCallback(bool focused)

// callback from camera service

void Camera::notifyCallback(int32_t msgType, int32_t ext1, int32_t ext2)

{

    switch(msgType) {

    case CAMERA_MSG_ERROR:

        LOGV("errorCallback");

        if (mErrorCallback) {

            mErrorCallback((status_t)ext1, mErrorCallbackCookie);

        }

        break;

    case CAMERA_MSG_FOCUS:

        LOGV("autoFocusCallback");

        if (mAutoFocusCallback) {

        mAutoFocusCallback(focused, mAutoFocusCallbackCookie);

            mAutoFocusCallback((bool)ext1, mAutoFocusCallbackCookie);

        }

}



void Camera::shutterCallback()

{

        break;

    case CAMERA_MSG_SHUTTER:

        LOGV("shutterCallback");

        if (mShutterCallback) {

            mShutterCallback(mShutterCallbackCookie);

        }

}



void Camera::rawCallback(const sp<IMemory>& picture)

{

    LOGV("rawCallback");

    if (mRawCallback) {

        mRawCallback(picture, mRawCallbackCookie);

    }

}



// callback from camera service when image is ready

void Camera::jpegCallback(const sp<IMemory>& picture)

{

    LOGV("jpegCallback");

    if (mJpegCallback) {

        mJpegCallback(picture, mJpegCallbackCookie);

        break;

    default:

        LOGV("notifyCallback(%d, %d, %d)", msgType, ext1, ext2);

        break;

    }

}



// callback from camera service when preview frame is ready

void Camera::previewCallback(const sp<IMemory>& frame)

// callback from camera service when frame or image is ready

void Camera::dataCallback(int32_t msgType, const sp<IMemory>& dataPtr)

{

    LOGV("frameCallback");

    switch(msgType) {

    case CAMERA_MSG_PREVIEW_FRAME:

        LOGV("previewCallback");

        if (mPreviewCallback) {

        mPreviewCallback(frame, mPreviewCallbackCookie);

            mPreviewCallback(dataPtr, mPreviewCallbackCookie);

        }

}



// callback from camera service when a recording frame is ready

void Camera::recordingCallback(const sp<IMemory>& frame)

{

        break;

    case CAMERA_MSG_VIDEO_FRAME:

        LOGV("recordingCallback");

        if (mRecordingCallback) {

        mRecordingCallback(frame, mRecordingCallbackCookie);

    }

            mRecordingCallback(dataPtr, mRecordingCallbackCookie);

        }



// callback from camera service when an error occurs in preview or takePicture

void Camera::errorCallback(status_t error)

{

    LOGV("errorCallback");

    if (mErrorCallback) {

        mErrorCallback(error, mErrorCallbackCookie);

        break;

    case CAMERA_MSG_RAW_IMAGE:

        LOGV("rawCallback");

        if (mRawCallback) {

            mRawCallback(dataPtr, mRawCallbackCookie);

        }

        break;

    case CAMERA_MSG_COMPRESSED_IMAGE:

        LOGV("jpegCallback");

        if (mJpegCallback) {

            mJpegCallback(dataPtr, mJpegCallbackCookie);

        }



// callback from camera service

void Camera::notifyCallback(int32_t msgType, int32_t ext1, int32_t ext2)

{

    LOGV("notifyCallback");

        break;

    default:

        LOGV("dataCallback(%d, %p)", msgType, dataPtr.get());

        break;

    }



// callback from camera service when image is ready

void Camera::dataCallback(int32_t msgType, const sp<IMemory>& frame)

{

    LOGV("dataCallback");

}



void Camera::binderDied(const wp<IBinder>& who) {

libs/ui/ICameraClient.cpp

+1 −125
Original line number Diff line number Diff line
@@ -25,14 +25,7 @@ 
namespace android {



enum {

    SHUTTER_CALLBACK = IBinder::FIRST_CALL_TRANSACTION,

    RAW_CALLBACK,

    JPEG_CALLBACK,

    PREVIEW_CALLBACK,

    ERROR_CALLBACK,

    AUTOFOCUS_CALLBACK,

    RECORDING_CALLBACK,

    NOTIFY_CALLBACK,

    NOTIFY_CALLBACK = IBinder::FIRST_CALL_TRANSACTION,

    DATA_CALLBACK,

};
@@ -44,75 +37,6 @@ public: 
    {

    }



    // callback to let the app know the shutter has closed, ideal for playing the shutter sound

    void shutterCallback()

    {

        LOGV("shutterCallback");

        Parcel data, reply;

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

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

    }



    // callback from camera service to app with picture data

    void rawCallback(const sp<IMemory>& picture)

    {

        LOGV("rawCallback");

        Parcel data, reply;

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

        data.writeStrongBinder(picture->asBinder());

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

    }



    // callback from camera service to app with picture data

    void jpegCallback(const sp<IMemory>& picture)

    {

        LOGV("jpegCallback");

        Parcel data, reply;

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

        data.writeStrongBinder(picture->asBinder());

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

    }



    // callback from camera service to app with preview frame data

    void previewCallback(const sp<IMemory>& frame)

    {

        LOGV("previewCallback");

        Parcel data, reply;

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

        data.writeStrongBinder(frame->asBinder());

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

    }



    // callback from camera service to app with recording frame data

    void recordingCallback(const sp<IMemory>& frame)

    {

        LOGV("recordingCallback");

        Parcel data, reply;

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

        data.writeStrongBinder(frame->asBinder());

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

    }



    // callback from camera service to app to report error

    void errorCallback(status_t error)

    {

        LOGV("errorCallback");

        Parcel data, reply;

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

        data.writeInt32(error);

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

    }



    // callback from camera service to app to report autofocus completion

    void autoFocusCallback(bool focused)

    {

        LOGV("autoFocusCallback");

        Parcel data, reply;

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

        data.writeInt32(focused);

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

    }



    // generic callback from camera service to app

    void notifyCallback(int32_t msgType, int32_t ext1, int32_t ext2)

    {
@@ -152,54 +76,6 @@ status_t BnCameraClient::onTransact( 
    uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)

{

    switch(code) {

        case SHUTTER_CALLBACK: {

            LOGV("SHUTTER_CALLBACK");

            CHECK_INTERFACE(ICameraClient, data, reply);

            shutterCallback();

            return NO_ERROR;

        } break;

        case RAW_CALLBACK: {

            LOGV("RAW_CALLBACK");

            CHECK_INTERFACE(ICameraClient, data, reply);

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

            rawCallback(picture);

            return NO_ERROR;

        } break;

        case JPEG_CALLBACK: {

            LOGV("JPEG_CALLBACK");

            CHECK_INTERFACE(ICameraClient, data, reply);

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

            jpegCallback(picture);

            return NO_ERROR;

        } break;

        case PREVIEW_CALLBACK: {

            LOGV("PREVIEW_CALLBACK");

            CHECK_INTERFACE(ICameraClient, data, reply);

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

            previewCallback(frame);

            return NO_ERROR;

        } break;

        case RECORDING_CALLBACK: {

            LOGV("RECORDING_CALLBACK");

            CHECK_INTERFACE(ICameraClient, data, reply);

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

            recordingCallback(frame);

            return NO_ERROR;

        } break;

        case ERROR_CALLBACK: {

            LOGV("ERROR_CALLBACK");

            CHECK_INTERFACE(ICameraClient, data, reply);

            status_t error = data.readInt32();

            errorCallback(error);

            return NO_ERROR;

        } break;

        case AUTOFOCUS_CALLBACK: {

            LOGV("AUTOFOCUS_CALLBACK");

            CHECK_INTERFACE(ICameraClient, data, reply);

            bool focused = (bool)data.readInt32();

            autoFocusCallback(focused);

            return NO_ERROR;

        } break;

        case NOTIFY_CALLBACK: {

            LOGV("NOTIFY_CALLBACK");

            CHECK_INTERFACE(ICameraClient, data, reply);