1 /* 2 * Copyright (C) 2018 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #ifndef ANDROID_FRAMEWORKS_AIDL_CAMERADEVICECALLBACKS_H 18 #define ANDROID_FRAMEWORKS_AIDL_CAMERADEVICECALLBACKS_H 19 20 #include <mutex> 21 #include <thread> 22 23 #include <android/frameworks/cameraservice/common/2.0/types.h> 24 #include <android/frameworks/cameraservice/service/2.0/types.h> 25 #include <android/frameworks/cameraservice/device/2.0/ICameraDeviceCallback.h> 26 #include <android/frameworks/cameraservice/device/2.0/types.h> 27 #include <android/hardware/camera2/BnCameraDeviceCallbacks.h> 28 #include <media/stagefright/foundation/ALooper.h> 29 #include <media/stagefright/foundation/AHandler.h> 30 #include <media/stagefright/foundation/AMessage.h> 31 #include <fmq/MessageQueue.h> 32 #include <hidl/MQDescriptor.h> 33 #include <hidl/Status.h> 34 #include <CameraService.h> 35 #include <hidl/CameraHybridInterface.h> 36 37 namespace android { 38 namespace frameworks { 39 namespace cameraservice { 40 namespace device { 41 namespace V2_0 { 42 namespace implementation { 43 44 using camerahybrid::H2BConverter; 45 using HCameraDeviceCallback = cameraservice::device::V2_0::ICameraDeviceCallback; 46 using HPhysicalCaptureResultInfo = cameraservice::device::V2_0::PhysicalCaptureResultInfo; 47 using android::frameworks::cameraservice::device::V2_0::FmqSizeOrMetadata; 48 49 using hardware::camera2::BnCameraDeviceCallbacks; 50 using hardware::camera2::ICameraDeviceCallbacks; 51 using hardware::camera2::impl::CaptureResultExtras; 52 using hardware::camera2::impl::CameraMetadataNative; 53 using hardware::camera2::impl::PhysicalCaptureResultInfo; 54 using hardware::kSynchronizedReadWrite; 55 using hardware::MessageQueue; 56 using CaptureResultMetadataQueue = MessageQueue<uint8_t, kSynchronizedReadWrite>; 57 using CameraMetadataInfo = android::hardware::camera2::CameraMetadataInfo; 58 59 struct H2BCameraDeviceCallbacks : 60 public H2BConverter<HCameraDeviceCallback, ICameraDeviceCallbacks, BnCameraDeviceCallbacks> { 61 H2BCameraDeviceCallbacks(const sp<HalInterface>& base); 62 63 ~H2BCameraDeviceCallbacks(); 64 65 bool initializeLooper(int vndkVersion); 66 67 virtual binder::Status onDeviceError(int32_t errorCode, 68 const CaptureResultExtras& resultExtras) override; 69 70 virtual binder::Status onDeviceIdle() override; 71 72 virtual binder::Status onCaptureStarted(const CaptureResultExtras& resultExtras, 73 int64_t timestamp) override; 74 75 virtual binder::Status onResultReceived( 76 const CameraMetadataInfo &, 77 const CaptureResultExtras& resultExtras, 78 const std::vector<PhysicalCaptureResultInfo>& physicalCaptureResultInfos) override; 79 80 virtual binder::Status onPrepared(int32_t streamId) override; 81 82 virtual binder::Status onRepeatingRequestError(int64_t lastFrameNumber, 83 int32_t repeatingRequestId) override; 84 85 virtual binder::Status onRequestQueueEmpty() override; 86 setCaptureResultMetadataQueueH2BCameraDeviceCallbacks87 void setCaptureResultMetadataQueue(std::shared_ptr<CaptureResultMetadataQueue> metadataQueue) { 88 mCaptureResultMetadataQueue = metadataQueue; 89 } 90 onClientSharedAccessPriorityChangedH2BCameraDeviceCallbacks91 virtual binder::Status onClientSharedAccessPriorityChanged(bool /*primaryClient*/) { 92 return binder::Status::ok(); 93 } 94 95 private: 96 // Wrapper struct so that parameters to onResultReceived callback may be 97 // sent through an AMessage. 98 struct ResultWrapper : public RefBase { 99 CameraMetadataNative mResult; 100 CaptureResultExtras mResultExtras; 101 std::vector<PhysicalCaptureResultInfo> mPhysicalCaptureResultInfos; ResultWrapperH2BCameraDeviceCallbacks::ResultWrapper102 ResultWrapper(CameraMetadataNative &result, 103 const CaptureResultExtras resultExtras, 104 const std::vector<PhysicalCaptureResultInfo> &physicalCaptureResultInfos) : 105 // TODO: make this std::movable 106 mResult(result), mResultExtras(resultExtras), mPhysicalCaptureResultInfos(physicalCaptureResultInfos) { } 107 }; 108 109 struct CallbackHandler : public AHandler { 110 public: 111 void onMessageReceived(const sp<AMessage> &msg) override; CallbackHandlerH2BCameraDeviceCallbacks::CallbackHandler112 CallbackHandler(H2BCameraDeviceCallbacks *converter, int vndkVersion) : 113 mConverter(converter), mVndkVersion(vndkVersion) { } 114 private: 115 void processResultMessage(sp<ResultWrapper> &resultWrapper); 116 wp<H2BCameraDeviceCallbacks> mConverter = nullptr; 117 int mVndkVersion = -1; 118 Mutex mMetadataQueueLock; 119 }; 120 121 void convertResultMetadataToHidl(const camera_metadata *rawMetadata, 122 FmqSizeOrMetadata *resultMetadata); 123 enum { 124 kWhatResultReceived, 125 }; 126 127 static const char *kResultKey; 128 129 std::shared_ptr<CaptureResultMetadataQueue> mCaptureResultMetadataQueue = nullptr; 130 sp<CallbackHandler> mHandler = nullptr; 131 sp<ALooper> mCbLooper = nullptr; 132 }; 133 134 } // implementation 135 } // V2_0 136 } // device 137 } // cameraservice 138 } // frameworks 139 } // android 140 #endif // ANDROID_FRAMEWORKS_AIDL_CAMERADEVICECALLBACKS_H 141