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

Commit fa1df1c6 authored by Android (Google) Code Review's avatar Android (Google) Code Review Committed by The Android Open Source Project
Browse files

am 3022a11: Merge change 1239 into donut 

Merge commit '3022a11c4c41afa9d39b4d0d9abd7e6bcb6b8472'

* commit '3022a11c4c41afa9d39b4d0d9abd7e6bcb6b8472':
  Modify camera framework to use new streamlined binder interface.
parents bbb94372 5e7366f8

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);