2. 程式人生 > >Android Camera原理之CameraDeviceCallbacks回撥模組

Android Camera原理之CameraDeviceCallbacks回撥模組

阿新 • • 發佈：2019-07-22

在講解《Android Camera原理之openCamera模組(二)》一文的時候提到了CameraDeviceCallbacks回撥，當時沒有詳細展開，本文我們詳細展開講解一下。
CameraDeviceCallbacks生成過程：
《Android Camera程序間通訊類總結》中2.ICameraDeviceCallbacks.aidl詳細總結了CameraDeviceCallbacks的生成過程。
frameworks/av/camera/ndk/impl/ACameraDevice.h中回撥介面如下。這個CameraDeviceCallbacks是openCamera的時候設定到camera service端的，後續HAL層有camera響應的話會呼叫ACameraDevice.h

中的ServiceCallback介面來實現回撥。我們需要從流程上搞清楚這些回撥是在什麼場景下觸發的，明白了這些，才真正明白camera capture的流程。

    // Callbacks from camera service
    class ServiceCallback : public hardware::camera2::BnCameraDeviceCallbacks {
      public:
        explicit ServiceCallback(CameraDevice* device) : mDevice(device) {}
        binder::Status onDeviceError(int32_t errorCode,
                           const CaptureResultExtras& resultExtras) override;
        binder::Status onDeviceIdle() override;
        binder::Status onCaptureStarted(const CaptureResultExtras& resultExtras,
                              int64_t timestamp) override;
        binder::Status onResultReceived(const CameraMetadata& metadata,
                              const CaptureResultExtras& resultExtras,
                              const std::vector<PhysicalCaptureResultInfo>& physicalResultInfos) override;
        binder::Status onPrepared(int streamId) override;
        binder::Status onRequestQueueEmpty() override;
        binder::Status onRepeatingRequestError(int64_t lastFrameNumber,
                int32_t stoppedSequenceId) override;
      private:
        const wp<CameraDevice> mDevice;
    };

1.onDeviceError

onDeviceError回撥流程.jpg

  • connectHelper
    在openCamera執行的時候會檢查當前camera device是否正常。
  • binderDied
    在camera service 死亡 的時候，死亡回撥中會通知上層當前的camera device可能有問題。

還有一個呼叫的地方是Camera3Device::notifyError--->從HAL傳遞上來的，關於當前device是否正常的資訊，如果device存在問題執行回撥--->listener->notifyError(errorCode, resultExtras);

void Camera3Device::notifyError(const camera3_error_msg_t &msg,
        sp<NotificationListener> listener) {
    ATRACE_CALL();
    // Map camera HAL error codes to ICameraDeviceCallback error codes
    // Index into this with the HAL error code
    static const int32_t halErrorMap[CAMERA3_MSG_NUM_ERRORS] = {
        // 0 = Unused error code
        hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_INVALID_ERROR,
        // 1 = CAMERA3_MSG_ERROR_DEVICE
        hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_DEVICE,
        // 2 = CAMERA3_MSG_ERROR_REQUEST
        hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_REQUEST,
        // 3 = CAMERA3_MSG_ERROR_RESULT
        hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_RESULT,
        // 4 = CAMERA3_MSG_ERROR_BUFFER
        hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_BUFFER
    };

    int32_t errorCode =
            ((msg.error_code >= 0) &&
                    (msg.error_code < CAMERA3_MSG_NUM_ERRORS)) ?
            halErrorMap[msg.error_code] :
            hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_INVALID_ERROR;

    int streamId = 0;
    if (msg.error_stream != NULL) {
        Camera3Stream *stream =
                Camera3Stream::cast(msg.error_stream);
        streamId = stream->getId();
    }
    ALOGV("Camera %s: %s: HAL error, frame %d, stream %d: %d",
            mId.string(), __FUNCTION__, msg.frame_number,
            streamId, msg.error_code);

    CaptureResultExtras resultExtras;
    switch (errorCode) {
        case hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_DEVICE:
            // SET_ERR calls notifyError
            SET_ERR("Camera HAL reported serious device error");
            break;
        case hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_REQUEST:
        case hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_RESULT:
        case hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_BUFFER:
            {
                Mutex::Autolock l(mInFlightLock);
                ssize_t idx = mInFlightMap.indexOfKey(msg.frame_number);
                if (idx >= 0) {
                    InFlightRequest &r = mInFlightMap.editValueAt(idx);
                    r.requestStatus = msg.error_code;
                    resultExtras = r.resultExtras;
                    if (hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_RESULT == errorCode
                            ||  hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_REQUEST ==
                            errorCode) {
                        r.skipResultMetadata = true;
                    }
                    if (hardware::camera2::ICameraDeviceCallbacks::ERROR_CAMERA_RESULT ==
                            errorCode) {
                        // In case of missing result check whether the buffers
                        // returned. If they returned, then remove inflight
                        // request.
                        removeInFlightRequestIfReadyLocked(idx);
                    }
                } else {
                    resultExtras.frameNumber = msg.frame_number;
                    ALOGE("Camera %s: %s: cannot find in-flight request on "
                            "frame %" PRId64 " error", mId.string(), __FUNCTION__,
                            resultExtras.frameNumber);
                }
            }
            resultExtras.errorStreamId = streamId;
            if (listener != NULL) {
                listener->notifyError(errorCode, resultExtras);
            } else {
                ALOGE("Camera %s: %s: no listener available", mId.string(), __FUNCTION__);
            }
            break;
        default:
            // SET_ERR calls notifyError
            SET_ERR("Unknown error message from HAL: %d", msg.error_code);
            break;
    }
}

2.onDeviceIdle

onDeviceIdle回撥流程.jpg


openCamera執行之後開始呼叫到onDeviceIdle回撥。這兒的呼叫過程需要講講Camera3Device::initializeCommonLocked

 

status_t Camera3Device::initializeCommonLocked() {
    /** Start up status tracker thread */
    mStatusTracker = new StatusTracker(this);
    status_t res = mStatusTracker->run(String8::format("C3Dev-%s-Status", mId.string()).string());
    if (res != OK) {
        SET_ERR_L("Unable to start status tracking thread: %s (%d)",
                strerror(-res), res);
        mInterface->close();
        mStatusTracker.clear();
        return res;
    }
//......
}

StatusTracker是C++中定義的執行緒，和java層有點類似，執行緒執行run會自動呼叫到threadLoop()，這應該很好理解。

class StatusTracker: public Thread {
  public:
    explicit StatusTracker(wp<Camera3Device> parent);
    ~StatusTracker();
    virtual void requestExit();
  protected:
    virtual bool threadLoop();
}

接下來這個threadLoop()會一直執行，如果在執行過程中發現當前的mStateTransitions[表示裝置狀態]處於IDLE，這時候回撥到上層。

    // Notify parent for all intermediate transitions
    if (mStateTransitions.size() > 0 && parent.get()) {
        for (size_t i = 0; i < mStateTransitions.size(); i++) {
            bool idle = (mStateTransitions[i] == IDLE);
            ALOGV("Camera device is now %s", idle ? "idle" : "active");
            parent->notifyStatus(idle);
        }
    }

3.onCaptureStarted

這個回撥函式表示camera device已經準備好，可以開始呼叫camera獲取capture frame資料了。回撥的開始是camera HAL層獲取底層camera device driver通知表示當前device已經準備好。通知的函式在Camera3Device::notify

  • Camera3Device::notify
    底層msg通知當前camera 開門準備好了，可以隨時準備拍照了。
void Camera3Device::notify(const camera3_notify_msg *msg) {
    ATRACE_CALL();
    sp<NotificationListener> listener;
    {
        Mutex::Autolock l(mOutputLock);
        listener = mListener.promote();
    }

    if (msg == NULL) {
        SET_ERR("HAL sent NULL notify message!");
        return;
    }

    switch (msg->type) {
        case CAMERA3_MSG_ERROR: {
            notifyError(msg->message.error, listener);
            break;
        }
        case CAMERA3_MSG_SHUTTER: {
            notifyShutter(msg->message.shutter, listener);
            break;
        }
        default:
            SET_ERR("Unknown notify message from HAL: %d",
                    msg->type);
    }
}
  • Camera3Device::notifyShutter
    ---> CameraDeviceClient::notifyShutter
    此時回撥到上層通知開發者當前的device shutter準備好了。
void CameraDeviceClient::notifyShutter(const CaptureResultExtras& resultExtras,
        nsecs_t timestamp) {
    // Thread safe. Don't bother locking.
    sp<hardware::camera2::ICameraDeviceCallbacks> remoteCb = getRemoteCallback();
    if (remoteCb != 0) {
        remoteCb->onCaptureStarted(resultExtras, timestamp);
    }
    Camera2ClientBase::notifyShutter(resultExtras, timestamp);
}

4.onResultReceived

預覽的時候這個函式很重要，表示抓取的幀資料不斷地返回，camera device正在不斷消耗capture frame。

  • CameraDeviceClient::initializeImpl--->CameraDeviceClient初始化執行的時候會啟動FrameProcessorBase執行緒。
    FrameProcessorBase繼承一個執行緒，執行run之後，它的threadLoop開始啟動。
template<typename TProviderPtr>
status_t CameraDeviceClient::initializeImpl(TProviderPtr providerPtr, const String8& monitorTags) {
//......
    String8 threadName;
    mFrameProcessor = new FrameProcessorBase(mDevice);
    threadName = String8::format("CDU-%s-FrameProc", mCameraIdStr.string());
    mFrameProcessor->run(threadName.string());

    mFrameProcessor->registerListener(FRAME_PROCESSOR_LISTENER_MIN_ID,
                                      FRAME_PROCESSOR_LISTENER_MAX_ID,
                                      /*listener*/this,
                                      /*sendPartials*/true);
//......
}
  • FrameProcessorBase::threadLoop
    此時會不斷到Camera HAL層取請求，是否有新的frame資料，如果有的話，處理capture frame資料。
bool FrameProcessorBase::threadLoop() {
    status_t res;

    sp<CameraDeviceBase> device;
    {
        device = mDevice.promote();
        if (device == 0) return false;
    }

    res = device->waitForNextFrame(kWaitDuration);
    if (res == OK) {
        processNewFrames(device);
    } else if (res != TIMED_OUT) {
        ALOGE("FrameProcessorBase: Error waiting for new "
                "frames: %s (%d)", strerror(-res), res);
    }

    return true;
}
  • FrameProcessorBase::processNewFrames
    ---> FrameProcessorBase::processSingleFrame
    --->FrameProcessorBase::processListeners
    --->CameraDeviceClient::onResultAvailable
    通過CameraDeviceClient::onResultAvailable函式回撥到上層，然後在回撥到CameraCaptureSession.CaptureCallback--->onCaptureProgressed告知開發者當前正在不斷捕獲capture frame資料。
/** Device-related methods */
void CameraDeviceClient::onResultAvailable(const CaptureResult& result) {
    ATRACE_CALL();
    ALOGV("%s", __FUNCTION__);

    // Thread-safe. No lock necessary.
    sp<hardware::camera2::ICameraDeviceCallbacks> remoteCb = mRemoteCallback;
    if (remoteCb != NULL) {
        remoteCb->onResultReceived(result.mMetadata, result.mResultExtras,
                result.mPhysicalMetadatas);
    }
}

5.onPrepared

CameraCaptureSession中有兩個介面：這個函式主要是用來給surface預分配記憶體，但是為了加速預覽顯示的速度。

    public abstract void prepare(@NonNull Surface surface) throws CameraAccessException;

    public abstract void prepare(int maxCount, @NonNull Surface surface)
            throws CameraAccessException;

而CameraDeviceCallbacks->onPrepared回撥就是在執行CameraCaptureSession->prepare之後回撥執行的。如果向HAL申請camera device 記憶體分配成功，才會觸發這個回撥。

6.onRequestQueueEmpty

onRequestQueueEmpty回撥是當前camera device的非預覽流佇列為空，開始準備capture 下一張圖片了，只是一箇中間狀態。這兒不太重要，我列個呼叫流程就行了。

  • Camera3Device::RequestThread::threadLoop
bool Camera3Device::RequestThread::threadLoop() {
//......
    // Wait for the next batch of requests.
    waitForNextRequestBatch();
//......
}
  • Camera3Device::RequestThread::waitForNextRequestBatch
void Camera3Device::RequestThread::waitForNextRequestBatch() {
//......
    NextRequest nextRequest;
    nextRequest.captureRequest = waitForNextRequestLocked();
    if (nextRequest.captureRequest == nullptr) {
        return;
    }

    nextRequest.halRequest = camera3_capture_request_t();
    nextRequest.submitted = false;
    mNextRequests.add(nextRequest);

    // Wait for additional requests
    const size_t batchSize = nextRequest.captureRequest->mBatchSize;

    for (size_t i = 1; i < batchSize; i++) {
        NextRequest additionalRequest;
        additionalRequest.captureRequest = waitForNextRequestLocked();
        if (additionalRequest.captureRequest == nullptr) {
            break;
        }

        additionalRequest.halRequest = camera3_capture_request_t();
        additionalRequest.submitted = false;
        mNextRequests.add(additionalRequest);
    }
//......
}
  • Camera3Device::RequestThread::waitForNextRequestLocked
sp<Camera3Device::CaptureRequest>
        Camera3Device::RequestThread::waitForNextRequestLocked() {
//......
    if (nextRequest == NULL) {
        // Don't have a repeating request already in hand, so queue
        // must have an entry now.
        RequestList::iterator firstRequest =
                mRequestQueue.begin();
        nextRequest = *firstRequest;
        mRequestQueue.erase(firstRequest);
        if (mRequestQueue.empty() && !nextRequest->mRepeating) {
            sp<NotificationListener> listener = mListener.promote();
            if (listener != NULL) {
                listener->notifyRequestQueueEmpty();
            }
        }
    }
//......
}
  • CameraDeviceClient::notifyRequestQueueEmpty這兒會直接回調到上層。
void CameraDeviceClient::notifyRequestQueueEmpty() {
    // Thread safe. Don't bother locking.
    sp<hardware::camera2::ICameraDeviceCallbacks> remoteCb = getRemoteCallback();
    if (remoteCb != 0) {
        remoteCb->onRequestQueueEmpty();
    }
}

7.onRepeatingRequestError

Camera3Device.h中定義了一個RequestThread執行緒，用來管理capture request和HAL device之間的連線。

    /**
     * Thread for managing capture request submission to HAL device.
     */
    class RequestThread : public Thread {
//......
      protected:
        virtual bool threadLoop();
    }

RequestThread啟動的地方在Camera3Device::initializeCommonLocked中。

    /** Start up request queue thread */
    mRequestThread = new RequestThread(this, mStatusTracker, mInterface, sessionParamKeys);
    res = mRequestThread->run(String8::format("C3Dev-%s-ReqQueue", mId.string()).string());
    if (res != OK) {
        SET_ERR_L("Unable to start request queue thread: %s (%d)",
                strerror(-res), res);
        mInterface->close();
        mRequestThread.clear();
        return res;
    }

執行緒核心的執行邏輯都在threadLoop函式中--->bool Camera3Device::RequestThread::threadLoop()

bool Camera3Device::RequestThread::threadLoop() {
//......
    // Prepare a batch of HAL requests and output buffers.
    res = prepareHalRequests();
    if (res == TIMED_OUT) {
        // Not a fatal error if getting output buffers time out.
        cleanUpFailedRequests(/*sendRequestError*/ true);
        // Check if any stream is abandoned.
        checkAndStopRepeatingRequest();
        return true;
    } else if (res != OK) {
        cleanUpFailedRequests(/*sendRequestError*/ false);
        return false;
    }
//......
}

請求HAL 層的device，如果請求超時，此時的預覽是無法進行下去的。執行checkAndStopRepeatingRequest();

void Camera3Device::RequestThread::checkAndStopRepeatingRequest() {
//......
    if (listener != NULL && surfaceAbandoned) {
        listener->notifyRepeatingRequestError(lastFrameNumber);
    }
}

最終呼叫到CameraDeviceClient::notifyRepeatingRequestError，然後直接回調到上層，通知開發者當前的capture request請求失敗了。

void CameraDeviceClient::notifyRepeatingRequestError(long lastFrameNumber) {
    sp<hardware::camera2::ICameraDeviceCallbacks> remoteCb = getRemoteCallback();

    if (remoteCb != 0) {
        remoteCb->onRepeatingRequestError(lastFrameNumber, mStreamingRequestId);
    }

    Mutex::Autolock idLock(mStreamingRequestIdLock);
    mStreamingRequestId = REQUEST_ID_NONE;
}

相關推薦

Android Camera原理之CameraDeviceCallbacks回撥模組

在講解《Android Camera原理之openCamera模組(二)》一文的時候提到了CameraDeviceCallback

Android Camera原理之setRepeatingRequest與capture模組

Camera操作過程中最重要的四個步驟： CameraManager-->openCamera --->

Android Camera原理之createCaptureSession模組

《Android Camera架構》 《Android Camera程序間通訊類總結》 《Android Camera模組解析之拍

Android Camera原理之openCamera模組(一)

我們平時開發，知道怎麼排程api，怎麼調起camera，怎麼呼叫camera的例項來操作camera就可以了，但是這些排程的背後都

Android Camera原理之camera service類與介面關係

camera service主要是指 frameworks/av/services/camera/下面的程式碼，最近在看這一塊的程

Android Camera原理之cameraserver與cameraprovider是怎樣聯絡的

我們熟知的camera架構是下面這張圖： 底層是camera driver，和硬體強相關；camera driver上層是操作驅

Android Camera原理之camera provider啟動

1.camera provider程序介紹： cameraserver 736 1 274664 69564 binder_

Java執行緒之非同步回撥(Callback)

●介紹      有時候執行一個任務需要很長時間，單執行緒下執行緒會處於阻塞狀態。這個時候我們會考慮一種非阻塞的處理模式。非阻塞任務在任何程式語言裡都必不可少，Java也不例外。多執行緒就是一個很好的解決辦法。     

Rxjava解決android的請求介面的回撥地獄

Consumer consumer1 = new Consumer<HttpResult<List<User>>>() { @Override public void accept(HttpResult<List&

前端入門20-JavaScript進階之非同步回撥的執行時機

宣告 本系列文章內容全部梳理自以下幾個來源： 《JavaScript權威指南》 MDN web docs Github:smyhvae/web Github:goddyZhao/Translation/JavaScript 作為一個前端小白，入門跟著這幾個來源學習，感謝作者的分享，

layui之ajax--回撥函式

問題：一個簡單的AJAX提交表單操作，經常發生後臺資料儲存好了，前端layer彈出層沒有關閉，父頁面沒有重新整理，定位發現是回撥函式沒有執行！！！用Google Chrome瀏覽器這種現象較少，而Safari 和 firefox瀏覽器100%發生。 解決過程：困擾了很久，以

C#公眾平臺（二）—— 接收事件推送之關注回撥

在C#公眾平臺（一）—— 接入配置 寫了公眾平臺的基本配置，這篇文章講的是關注回撥事件。 基礎幫助類 接收事件推送文件 接入指南 /// <summary> /// WeChatEvent 的摘要說明 /// </summary>

android.database.ContentObserver#onChange(boolean, android.net.Uri) 多次回撥的妥協處理方案

android.database.ContentObserver#onChange(boolean, android.net.Uri) 在呼叫資料庫監聽的方法的時候發現，該方法會被多次觸發。比如，只是

[Android]RecyclerView基本使用+adapter回撥介面實現點選事件

一、概述 RrcyclerView是ListView的加強版，不僅可以輕鬆實現和ListView同樣的效果，還優化了ListView中存在的各種不同之處。 Android官方推薦我們使用RecyclerView。 二、基本用法 1.首先需要在專案的build.gradle中新增相

Android http請求使用介面回撥

Android中不支援在主執行緒發起http請求資料，我們需要把http請求放到子執行緒中處理。為了保證程式碼的執行順序，可以使用介面回撥的方式拿到請求到的資料並進行處理。 定義回撥介面 public interface OnConnectResult

React基礎知識之Ref回撥函式處理

程式碼地址請在github檢視，如果有新內容，我會定時更新，也歡迎您star,issue,共同進步 1.為DOM元素新增Ref react支援一個ref屬性，該屬性可以新增到任何的元件上。該ref屬性接收一個回撥函式，這個回撥函式在元件掛載或者解除安裝的時候

java之非同步回撥

非同步回撥我的理解： 1.使用了委託模式，呼叫方（ServiceA）持有被呼叫方（ServiceB）的引用，然後呼叫被呼叫方（ServiceB）的方法，被呼叫方方法（ServiceB）完成後，呼叫呼叫方（ServiceA）的回撥函式做一些事情 2.非同步回撥多是一些耗時的

ROS學習之 cpp回撥函式和輪轉(spin)

wiki連結: http://wiki.ros.org/roscpp/Overview/Callbacks%20and%20Spinning 資料(雲飛機器人實驗室的一篇小文): http://www.yfworld.com/?p=2318 這篇文章會幫助理解ros::s

JS非同步之：回撥/Promise/協程/Generator

本文是《深入掌握 ECMAScript 6 非同步程式設計》系列文章的第一篇。 非同步程式設計對 JavaScript 語言太重要。JavaScript 只有一根執行緒，如果沒有非同步程式設計，根本沒法用，非卡死不可。 以前，非同步程式設計的方法，大概有

iOS開發總結之block回撥以AFN為基礎封裝的網路請求操作類

1.#warning封裝網路請求類的好處 /**  *  1.專案存在問題,太依賴第三方框架。     2.為什麼要封裝網路請求:以後AFN升級,方法名改了,或者AFN淘汰了,直接改工具類就