Camera: use gralloc mapper for handle import

Bug: 37540361
Test: marlin, smoke test GCA
Change-Id: I9d58d9c6af20b37c016f036bce2dcf55817c59aa

1 files changed, 51 insertions, 99 deletions

diff --git a/camera/common/1.0/default/HandleImporter.cpp b/camera/common/1.0/default/HandleImporter.cpp
index e22f26f3d1..fd8b943dc3 100644
--- a/camera/common/1.0/default/HandleImporter.cpp
+++ b/camera/common/1.0/default/HandleImporter.cpp
@@ -25,33 +25,27 @@ namespace common {
 namespace V1_0 {
 namespace helper {
 
-HandleImporter HandleImporter::sHandleImporter;
+using MapperError = android::hardware::graphics::mapper::V2_0::Error;
 
-HandleImporter& HandleImporter::getInstance() {
-    sHandleImporter.initialize();
-    return sHandleImporter;
-}
+HandleImporter::HandleImporter() : mInitialized(false) {}
 
-bool HandleImporter::initialize() {
-    // allow only one client
+void HandleImporter::initializeLocked() {
     if (mInitialized) {
-        return false;
+        return;
     }
 
-    if (!openGralloc()) {
-        return false;
+    mMapper = IMapper::getService();
+    if (mMapper == nullptr) {
+        ALOGE("%s: cannnot acccess graphics mapper HAL!", __FUNCTION__);
+        return;
     }
 
     mInitialized = true;
-    return true;
+    return;
 }
 
 void HandleImporter::cleanup() {
-    if (!mInitialized) {
-        return;
-    }
-
-    closeGralloc();
+    mMapper.clear();
     mInitialized = false;
 }
 
@@ -64,12 +58,37 @@ bool HandleImporter::importBuffer(buffer_handle_t& handle) {
         return true;
     }
 
-    buffer_handle_t clone = cloneBuffer(handle);
-    if (!clone) {
+    Mutex::Autolock lock(mLock);
+    if (!mInitialized) {
+        initializeLocked();
+    }
+
+    if (mMapper == nullptr) {
+        ALOGE("%s: mMapper is null!", __FUNCTION__);
         return false;
     }
 
-    handle = clone;
+    MapperError error;
+    buffer_handle_t importedHandle;
+    auto ret = mMapper->importBuffer(
+        hidl_handle(handle),
+        [&](const auto& tmpError, const auto& tmpBufferHandle) {
+            error = tmpError;
+            importedHandle = static_cast<buffer_handle_t>(tmpBufferHandle);
+        });
+
+    if (!ret.isOk()) {
+        ALOGE("%s: mapper importBuffer failed: %s",
+                __FUNCTION__, ret.description().c_str());
+        return false;
+    }
+
+    if (error != MapperError::NONE) {
+        return false;
+    }
+
+    handle = importedHandle;
+
     return true;
 }
 
@@ -78,10 +97,20 @@ void HandleImporter::freeBuffer(buffer_handle_t handle) {
         return;
     }
 
-    releaseBuffer(handle);
+    Mutex::Autolock lock(mLock);
+    if (mMapper == nullptr) {
+        ALOGE("%s: mMapper is null!", __FUNCTION__);
+        return;
+    }
+
+    auto ret = mMapper->freeBuffer(const_cast<native_handle_t*>(handle));
+    if (!ret.isOk()) {
+        ALOGE("%s: mapper freeBuffer failed: %s",
+                __FUNCTION__, ret.description().c_str());
+    }
 }
 
-bool HandleImporter::importFence(const native_handle_t* handle, int& fd) {
+bool HandleImporter::importFence(const native_handle_t* handle, int& fd) const {
     if (handle == nullptr || handle->numFds == 0) {
         fd = -1;
     } else if (handle->numFds == 1) {
@@ -99,89 +128,12 @@ bool HandleImporter::importFence(const native_handle_t* handle, int& fd) {
     return true;
 }
 
-void HandleImporter::closeFence(int fd) {
+void HandleImporter::closeFence(int fd) const {
     if (fd >= 0) {
         close(fd);
     }
 }
 
-bool HandleImporter::openGralloc() {
-    const hw_module_t* module;
-    int err = hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module);
-    if (err) {
-        ALOGE("failed to get gralloc module");
-        return false;
-    }
-
-    uint8_t major = (module->module_api_version >> 8) & 0xff;
-    if (major > 1) {
-        ALOGE("unknown gralloc module major version %d", major);
-        return false;
-    }
-
-    if (major == 1) {
-        err = gralloc1_open(module, &mDevice);
-        if (err) {
-            ALOGE("failed to open gralloc1 device");
-            return false;
-        }
-
-        mRetain = reinterpret_cast<GRALLOC1_PFN_RETAIN>(
-                mDevice->getFunction(mDevice, GRALLOC1_FUNCTION_RETAIN));
-        mRelease = reinterpret_cast<GRALLOC1_PFN_RELEASE>(
-                mDevice->getFunction(mDevice, GRALLOC1_FUNCTION_RELEASE));
-        if (!mRetain || !mRelease) {
-            ALOGE("invalid gralloc1 device");
-            gralloc1_close(mDevice);
-            return false;
-        }
-    } else {
-        mModule = reinterpret_cast<const gralloc_module_t*>(module);
-    }
-
-    return true;
-}
-
-void HandleImporter::closeGralloc() {
-    if (mDevice) {
-        gralloc1_close(mDevice);
-    }
-}
-
-buffer_handle_t HandleImporter::cloneBuffer(buffer_handle_t handle) {
-    native_handle_t* clone = native_handle_clone(handle);
-    if (!clone) {
-        ALOGE("failed to clone buffer %p", handle);
-        return nullptr;
-    }
-
-    bool err;
-    if (mDevice) {
-        err = (mRetain(mDevice, clone) != GRALLOC1_ERROR_NONE);
-    } else {
-        err = (mModule->registerBuffer(mModule, clone) != 0);
-    }
-
-    if (err) {
-        ALOGE("failed to retain/register buffer %p", clone);
-        native_handle_close(clone);
-        native_handle_delete(clone);
-        return nullptr;
-    }
-
-    return clone;
-}
-
-void HandleImporter::releaseBuffer(buffer_handle_t handle) {
-    if (mDevice) {
-        mRelease(mDevice, handle);
-    } else {
-        mModule->unregisterBuffer(mModule, handle);
-    }
-    native_handle_close(handle);
-    native_handle_delete(const_cast<native_handle_t*>(handle));
-}
-
 } // namespace helper
 } // namespace V1_0
 } // namespace common