Camera: Add device ver. 1 preview test cases

Test cases enabling/disabling preview using version 1
camera devices are needed. Test case is also available
for "setPreviewWindow".

BUG: 32022758
Test: compile and run the gtest binary on device
Change-Id: I234881fe940309dbb6ac11bfee7d01cc76d09f59

camera/provider/2.4/vts/functional/Android.bp

@@ -28,6 +28,8 @@ cc_test {
         "android.hardware.camera.device@3.2",
         "android.hardware.camera.device@1.0",
         "libcamera_metadata",
+        "libbinder",
+        "libgui",
         "libui"
     ],
     static_libs: ["VtsHalHidlTargetTestBase"],

camera/provider/2.4/vts/functional/VtsHalCameraProviderV2_4TargetTest.cpp

@@ -21,6 +21,10 @@
 #include <android/log.h>
 #include <ui/GraphicBuffer.h>
 #include <VtsHalHidlTargetTestBase.h>
+#include <gui/BufferQueue.h>
+#include <gui/Surface.h>
+#include <gui/CpuConsumer.h>
+#include <binder/MemoryHeapBase.h>
 #include <regex>
 #include "system/camera_metadata.h"
 #include <hardware/gralloc.h>
@@ -30,6 +34,7 @@
 #include <condition_variable>
 #include <chrono>
 #include <inttypes.h>
+#include <utils/Errors.h>
 
 using ::android::hardware::Return;
 using ::android::hardware::Void;
@@ -38,7 +43,13 @@ using ::android::hardware::hidl_string;
 using ::android::hardware::hidl_vec;
 using ::android::sp;
 using ::android::GraphicBuffer;
+using ::android::IGraphicBufferProducer;
+using ::android::IGraphicBufferConsumer;
+using ::android::BufferQueue;
+using ::android::CpuConsumer;
+using ::android::Surface;
 using ::android::hardware::graphics::common::V1_0::PixelFormat;
+using ::android::hardware::graphics::allocator::V2_0::ProducerUsage;
 using ::android::hardware::camera::common::V1_0::Status;
 using ::android::hardware::camera::common::V1_0::CameraDeviceStatus;
 using ::android::hardware::camera::common::V1_0::TorchMode;
@@ -69,6 +80,7 @@ using ::android::hardware::camera::device::V1_0::NotifyCallbackMsg;
 using ::android::hardware::camera::device::V1_0::DataCallbackMsg;
 using ::android::hardware::camera::device::V1_0::CameraFrameMetadata;
 using ::android::hardware::camera::device::V1_0::ICameraDevicePreviewCallback;
+using ::android::hardware::camera::device::V1_0::FrameCallbackFlag;
 
 const char kCameraPassthroughServiceName[] = "legacy/0";
 const uint32_t kMaxPreviewWidth = 1920;
@@ -120,6 +132,27 @@ namespace {
         }
         return 0;
     }
+
+    Status mapToStatus(::android::status_t s)  {
+        switch(s) {
+            case ::android::OK:
+                return Status::OK ;
+            case ::android::BAD_VALUE:
+                return Status::ILLEGAL_ARGUMENT ;
+            case -EBUSY:
+                return Status::CAMERA_IN_USE;
+            case -EUSERS:
+                return Status::MAX_CAMERAS_IN_USE;
+            case ::android::UNKNOWN_TRANSACTION:
+                return Status::METHOD_NOT_SUPPORTED;
+            case ::android::INVALID_OPERATION:
+                return Status::OPERATION_NOT_SUPPORTED;
+            case ::android::DEAD_OBJECT:
+                return Status::CAMERA_DISCONNECTED;
+        }
+        ALOGW("Unexpected HAL status code %d", s);
+        return Status::OPERATION_NOT_SUPPORTED;
+    }
 }
 
 // Test environment for camera
@@ -154,6 +187,233 @@ void CameraHidlEnvironment::TearDown() {
     ALOGI("TearDown CameraHidlEnvironment");
 }
 
+struct PreviewWindowCb : public ICameraDevicePreviewCallback {
+    PreviewWindowCb(sp<ANativeWindow> anw) : mPreviewWidth(0),
+            mPreviewHeight(0), mFormat(0), mPreviewUsage(0),
+            mPreviewSwapInterval(-1), mCrop{-1, -1, -1, -1}, mAnw(anw) {}
+
+    using dequeueBuffer_cb =
+            std::function<void(Status status, uint64_t bufferId,
+                    const hidl_handle& buffer, uint32_t stride)>;
+    Return<void> dequeueBuffer(dequeueBuffer_cb _hidl_cb) override;
+
+    Return<Status> enqueueBuffer(uint64_t bufferId) override;
+
+    Return<Status> cancelBuffer(uint64_t bufferId) override;
+
+    Return<Status> setBufferCount(uint32_t count) override;
+
+    Return<Status> setBuffersGeometry(uint32_t w,
+            uint32_t h, PixelFormat format) override;
+
+    Return<Status> setCrop(int32_t left, int32_t top,
+            int32_t right, int32_t bottom) override;
+
+    Return<Status> setUsage(ProducerUsage usage) override;
+
+    Return<Status> setSwapInterval(int32_t interval) override;
+
+    using getMinUndequeuedBufferCount_cb =
+            std::function<void(Status status, uint32_t count)>;
+    Return<void> getMinUndequeuedBufferCount(
+            getMinUndequeuedBufferCount_cb _hidl_cb) override;
+
+    Return<Status> setTimestamp(int64_t timestamp) override;
+
+ private:
+    struct BufferHasher {
+        size_t operator()(const buffer_handle_t& buf) const {
+            if (buf == nullptr)
+                return 0;
+
+            size_t result = 1;
+            result = 31 * result + buf->numFds;
+            result = 31 * result + buf->numInts;
+            int length = buf->numFds + buf->numInts;
+            for (int i = 0; i < length; i++) {
+                result = 31 * result + buf->data[i];
+            }
+            return result;
+        }
+    };
+
+    struct BufferComparator {
+        bool operator()(const buffer_handle_t& buf1,
+                const buffer_handle_t& buf2) const {
+            if ((buf1->numFds == buf2->numFds) &&
+                    (buf1->numInts == buf2->numInts)) {
+                int length = buf1->numFds + buf1->numInts;
+                for (int i = 0; i < length; i++) {
+                    if (buf1->data[i] != buf2->data[i]) {
+                        return false;
+                    }
+                }
+                return true;
+            }
+            return false;
+        }
+    };
+
+    std::pair<bool, uint64_t> getBufferId(ANativeWindowBuffer* anb);
+    void cleanupCirculatingBuffers();
+
+    std::mutex mBufferIdMapLock; // protecting mBufferIdMap and mNextBufferId
+    typedef std::unordered_map<const buffer_handle_t, uint64_t,
+            BufferHasher, BufferComparator> BufferIdMap;
+
+    BufferIdMap mBufferIdMap; // stream ID -> per stream buffer ID map
+    std::unordered_map<uint64_t, ANativeWindowBuffer*> mReversedBufMap;
+    uint64_t mNextBufferId = 1;
+
+    uint32_t mPreviewWidth, mPreviewHeight;
+    int mFormat, mPreviewUsage;
+    int32_t mPreviewSwapInterval;
+    android_native_rect_t mCrop;
+    sp<ANativeWindow> mAnw;     //Native window reference
+};
+
+std::pair<bool, uint64_t> PreviewWindowCb::getBufferId(
+        ANativeWindowBuffer* anb) {
+    std::lock_guard<std::mutex> lock(mBufferIdMapLock);
+
+    buffer_handle_t& buf = anb->handle;
+    auto it = mBufferIdMap.find(buf);
+    if (it == mBufferIdMap.end()) {
+        uint64_t bufId = mNextBufferId++;
+        mBufferIdMap[buf] = bufId;
+        mReversedBufMap[bufId] = anb;
+        return std::make_pair(true, bufId);
+    } else {
+        return std::make_pair(false, it->second);
+    }
+}
+
+void PreviewWindowCb::cleanupCirculatingBuffers() {
+    std::lock_guard<std::mutex> lock(mBufferIdMapLock);
+    mBufferIdMap.clear();
+    mReversedBufMap.clear();
+}
+
+Return<void> PreviewWindowCb::dequeueBuffer(dequeueBuffer_cb _hidl_cb) {
+    ANativeWindowBuffer* anb;
+    auto rc = native_window_dequeue_buffer_and_wait(mAnw.get(), &anb);
+    uint64_t bufferId = 0;
+    uint32_t stride = 0;
+    hidl_handle buf = nullptr;
+    if (rc == ::android::OK) {
+        auto pair = getBufferId(anb);
+        buf = (pair.first) ? anb->handle : nullptr;
+        bufferId = pair.second;
+        stride = anb->stride;
+    }
+
+    _hidl_cb(mapToStatus(rc), bufferId, buf, stride);
+    return Void();
+}
+
+Return<Status> PreviewWindowCb::enqueueBuffer(uint64_t bufferId) {
+    if (mReversedBufMap.count(bufferId) == 0) {
+        ALOGE("%s: bufferId %" PRIu64 " not found", __FUNCTION__, bufferId);
+        return Status::ILLEGAL_ARGUMENT;
+    }
+    return mapToStatus(mAnw->queueBuffer(mAnw.get(),
+            mReversedBufMap.at(bufferId), -1));
+}
+
+Return<Status> PreviewWindowCb::cancelBuffer(uint64_t bufferId) {
+    if (mReversedBufMap.count(bufferId) == 0) {
+        ALOGE("%s: bufferId %" PRIu64 " not found", __FUNCTION__, bufferId);
+        return Status::ILLEGAL_ARGUMENT;
+    }
+    return mapToStatus(mAnw->cancelBuffer(mAnw.get(),
+            mReversedBufMap.at(bufferId), -1));
+}
+
+Return<Status> PreviewWindowCb::setBufferCount(uint32_t count) {
+    if (mAnw.get() != nullptr) {
+        // WAR for b/27039775
+        native_window_api_disconnect(mAnw.get(), NATIVE_WINDOW_API_CAMERA);
+        native_window_api_connect(mAnw.get(), NATIVE_WINDOW_API_CAMERA);
+        if (mPreviewWidth != 0) {
+            native_window_set_buffers_dimensions(mAnw.get(),
+                    mPreviewWidth, mPreviewHeight);
+            native_window_set_buffers_format(mAnw.get(), mFormat);
+        }
+        if (mPreviewUsage != 0) {
+            native_window_set_usage(mAnw.get(), mPreviewUsage);
+        }
+        if (mPreviewSwapInterval >= 0) {
+            mAnw->setSwapInterval(mAnw.get(), mPreviewSwapInterval);
+        }
+        if (mCrop.left >= 0) {
+            native_window_set_crop(mAnw.get(), &(mCrop));
+        }
+    }
+
+    auto rc = native_window_set_buffer_count(mAnw.get(), count);
+    if (rc == ::android::OK) {
+        cleanupCirculatingBuffers();
+    }
+
+    return mapToStatus(rc);
+}
+
+Return<Status> PreviewWindowCb::setBuffersGeometry(uint32_t w, uint32_t h,
+        PixelFormat format) {
+    auto rc = native_window_set_buffers_dimensions(mAnw.get(), w, h);
+    if (rc == ::android::OK) {
+        mPreviewWidth = w;
+        mPreviewHeight = h;
+        rc = native_window_set_buffers_format(mAnw.get(),
+                static_cast<int>(format));
+        if (rc == ::android::OK) {
+            mFormat = static_cast<int>(format);
+        }
+    }
+
+    return mapToStatus(rc);
+}
+
+Return<Status> PreviewWindowCb::setCrop(int32_t left, int32_t top,
+        int32_t right, int32_t bottom) {
+    android_native_rect_t crop = { left, top, right, bottom };
+    auto rc = native_window_set_crop(mAnw.get(), &crop);
+    if (rc == ::android::OK) {
+        mCrop = crop;
+    }
+    return mapToStatus(rc);
+}
+
+Return<Status> PreviewWindowCb::setUsage(ProducerUsage usage) {
+    auto rc = native_window_set_usage(mAnw.get(), static_cast<int>(usage));
+    if (rc == ::android::OK) {
+        mPreviewUsage =  static_cast<int>(usage);
+    }
+    return mapToStatus(rc);
+}
+
+Return<Status> PreviewWindowCb::setSwapInterval(int32_t interval) {
+    auto rc = mAnw->setSwapInterval(mAnw.get(), interval);
+    if (rc == ::android::OK) {
+        mPreviewSwapInterval = interval;
+    }
+    return mapToStatus(rc);
+}
+
+Return<void> PreviewWindowCb::getMinUndequeuedBufferCount(
+        getMinUndequeuedBufferCount_cb _hidl_cb) {
+    int count = 0;
+    auto rc = mAnw->query(mAnw.get(),
+            NATIVE_WINDOW_MIN_UNDEQUEUED_BUFFERS, &count);
+    _hidl_cb(mapToStatus(rc), count);
+    return Void();
+}
+
+Return<Status> PreviewWindowCb::setTimestamp(int64_t timestamp) {
+    return mapToStatus(native_window_set_buffers_timestamp(mAnw.get(),
+            timestamp));
+}
+
 // The main test class for camera HIDL HAL.
 class CameraHidlTest : public ::testing::VtsHalHidlTargetTestBase {
 public:
@@ -265,6 +525,9 @@ protected:
     std::mutex mTorchLock;                     // Synchronize access to torch status
     std::condition_variable mTorchCond;        // Condition variable for torch status
     TorchModeStatus mTorchStatus;              // Current torch status
+
+    // Holds camera registered buffers
+    std::unordered_map<uint32_t, sp<::android::MemoryHeapBase> > mMemoryPool;
 };
 
 Return<void> CameraHidlTest::Camera1DeviceCb::notifyCallback(
@@ -274,13 +537,34 @@ Return<void> CameraHidlTest::Camera1DeviceCb::notifyCallback(
 }
 
 Return<uint32_t> CameraHidlTest::Camera1DeviceCb::registerMemory(
-        const hidl_handle& descriptor __unused, uint32_t bufferSize __unused,
-        uint32_t bufferCount __unused) {
-    return 0;
+        const hidl_handle& descriptor, uint32_t bufferSize,
+        uint32_t bufferCount) {
+    if (descriptor->numFds != 1) {
+        ALOGE("%s: camera memory descriptor has numFds %d (expect 1)",
+                __FUNCTION__, descriptor->numFds);
+        return 0;
+    }
+    if (descriptor->data[0] < 0) {
+        ALOGE("%s: camera memory descriptor has FD %d (expect >= 0)",
+                __FUNCTION__, descriptor->data[0]);
+        return 0;
+    }
+
+    sp<::android::MemoryHeapBase> pool = new ::android::MemoryHeapBase(
+            descriptor->data[0], bufferSize*bufferCount, 0, 0);
+    mParent->mMemoryPool.emplace(pool->getHeapID(), pool);
+
+    return pool->getHeapID();
 }
 
 Return<void> CameraHidlTest::Camera1DeviceCb::unregisterMemory(
         uint32_t memId __unused) {
+    if (mParent->mMemoryPool.count(memId) == 0) {
+        ALOGE("%s: memory pool ID %d not found", __FUNCTION__, memId);
+        return Void();
+    }
+
+    mParent->mMemoryPool.erase(memId);
     return Void();
 }
 
@@ -566,6 +850,149 @@ TEST_F(CameraHidlTest, getCameraInfo) {
     }
 }
 
+// Check whether preview window can be configured
+TEST_F(CameraHidlTest, setPreviewWindow) {
+    CameraHidlEnvironment* env = CameraHidlEnvironment::Instance();
+    hidl_vec<hidl_string> cameraDeviceNames = getCameraDeviceNames();
+
+    for (const auto& name : cameraDeviceNames) {
+        if (getCameraDeviceVersion(name) == CAMERA_DEVICE_API_VERSION_1_0) {
+            ::android::sp<::android::hardware::camera::device::V1_0::ICameraDevice> device1;
+            ALOGI("getCameraCharacteristics: Testing camera device %s", name.c_str());
+            env->mProvider->getCameraDeviceInterface_V1_x(
+                name,
+                [&](auto status, const auto& device) {
+                    ALOGI("getCameraDeviceInterface_V1_x returns status:%d", (int)status);
+                    ASSERT_EQ(Status::OK, status);
+                    ASSERT_NE(device, nullptr);
+                    device1 = device;
+                });
+
+            sp<Camera1DeviceCb> deviceCb = new Camera1DeviceCb(this);
+            ASSERT_EQ(Status::OK, device1->open(deviceCb));
+
+            ASSERT_EQ(Status::OK, device1->setPreviewWindow(nullptr));
+            sp<IGraphicBufferProducer> producer;
+            sp<IGraphicBufferConsumer> consumer;
+            BufferQueue::createBufferQueue(&producer, &consumer);
+            sp<Surface> surface = new Surface(producer);
+            sp<ANativeWindow> window(surface);
+
+            sp<ICameraDevicePreviewCallback> previewCb = new PreviewWindowCb(
+                    window);
+            ASSERT_EQ(Status::OK, device1->setPreviewWindow(previewCb));
+
+            device1->close();
+        }
+    }
+}
+
+// Verify that setting preview window fails in case device is not open
+TEST_F(CameraHidlTest, setPreviewWindowInvalid) {
+    CameraHidlEnvironment* env = CameraHidlEnvironment::Instance();
+    hidl_vec<hidl_string> cameraDeviceNames = getCameraDeviceNames();
+
+    for (const auto& name : cameraDeviceNames) {
+        if (getCameraDeviceVersion(name) == CAMERA_DEVICE_API_VERSION_1_0) {
+            ::android::sp<::android::hardware::camera::device::V1_0::ICameraDevice> device1;
+            ALOGI("getCameraCharacteristics: Testing camera device %s", name.c_str());
+            env->mProvider->getCameraDeviceInterface_V1_x(
+                name,
+                [&](auto status, const auto& device) {
+                    ALOGI("getCameraDeviceInterface_V1_x returns status:%d", (int)status);
+                    ASSERT_EQ(Status::OK, status);
+                    ASSERT_NE(device, nullptr);
+                    device1 = device;
+                });
+
+            ASSERT_EQ(Status::OPERATION_NOT_SUPPORTED,
+                    device1->setPreviewWindow(nullptr));
+        }
+    }
+}
+
+// Start and stop preview checking whether it gets enabled inbetween.
+TEST_F(CameraHidlTest, startStopPreview) {
+    CameraHidlEnvironment* env = CameraHidlEnvironment::Instance();
+    hidl_vec<hidl_string> cameraDeviceNames = getCameraDeviceNames();
+
+    for (const auto& name : cameraDeviceNames) {
+        if (getCameraDeviceVersion(name) == CAMERA_DEVICE_API_VERSION_1_0) {
+            ::android::sp<::android::hardware::camera::device::V1_0::ICameraDevice> device1;
+            ALOGI("getCameraCharacteristics: Testing camera device %s", name.c_str());
+            env->mProvider->getCameraDeviceInterface_V1_x(
+                name,
+                [&](auto status, const auto& device) {
+                    ALOGI("getCameraDeviceInterface_V1_x returns status:%d", (int)status);
+                    ASSERT_EQ(Status::OK, status);
+                    ASSERT_NE(device, nullptr);
+                    device1 = device;
+                });
+
+            sp<Camera1DeviceCb> deviceCb = new Camera1DeviceCb(this);
+            ASSERT_EQ(Status::OK, device1->open(deviceCb));
+
+            sp<IGraphicBufferProducer> producer;
+            sp<IGraphicBufferConsumer> consumer;
+            BufferQueue::createBufferQueue(&producer, &consumer);
+            sp<CpuConsumer> cpuConsumer = new CpuConsumer(consumer, 1);
+            sp<Surface> surface = new Surface(producer);
+            sp<ANativeWindow> window(surface);
+
+            sp<PreviewWindowCb> previewCb = new PreviewWindowCb(
+                    window);
+            ASSERT_EQ(Status::OK, device1->setPreviewWindow(previewCb));
+            ASSERT_EQ(Status::OK, device1->startPreview());
+            ASSERT_TRUE(device1->previewEnabled());
+            device1->stopPreview();
+
+            device1->close();
+        }
+    }
+}
+
+// Start preview without active preview window. Preview should start as soon
+// as a valid active window gets configured.
+TEST_F(CameraHidlTest, startStopPreviewDelayed) {
+    CameraHidlEnvironment* env = CameraHidlEnvironment::Instance();
+    hidl_vec<hidl_string> cameraDeviceNames = getCameraDeviceNames();
+
+    for (const auto& name : cameraDeviceNames) {
+        if (getCameraDeviceVersion(name) == CAMERA_DEVICE_API_VERSION_1_0) {
+            ::android::sp<::android::hardware::camera::device::V1_0::ICameraDevice> device1;
+            ALOGI("getCameraCharacteristics: Testing camera device %s", name.c_str());
+            env->mProvider->getCameraDeviceInterface_V1_x(
+                name,
+                [&](auto status, const auto& device) {
+                    ALOGI("getCameraDeviceInterface_V1_x returns status:%d", (int)status);
+                    ASSERT_EQ(Status::OK, status);
+                    ASSERT_NE(device, nullptr);
+                    device1 = device;
+                });
+
+            sp<Camera1DeviceCb> deviceCb = new Camera1DeviceCb(this);
+            ASSERT_EQ(Status::OK, device1->open(deviceCb));
+            ASSERT_EQ(Status::OK, device1->setPreviewWindow(nullptr));
+            ASSERT_EQ(Status::OK, device1->startPreview());
+
+            sp<IGraphicBufferProducer> producer;
+            sp<IGraphicBufferConsumer> consumer;
+            BufferQueue::createBufferQueue(&producer, &consumer);
+            sp<CpuConsumer> cpuConsumer = new CpuConsumer(consumer, 1);
+            sp<Surface> surface = new Surface(producer);
+            sp<ANativeWindow> window(surface);
+            sp<PreviewWindowCb> previewCb = new PreviewWindowCb(window);
+
+            //Preview should get enabled now
+            ASSERT_EQ(Status::OK, device1->setPreviewWindow(previewCb));
+            ASSERT_TRUE(device1->previewEnabled());
+            device1->stopPreview();
+
+            device1->close();
+        }
+    }
+}
+
 // Verify that the static camera characteristics can be retrieved
 // successfully.
 TEST_F(CameraHidlTest, getCameraCharacteristics) {