universal7885: Remove LineageOS hardware samsung deps

And track it with vendorsetup.sh

universal7885-common/libshims/camera/Android.bp

@@ -0,0 +1,35 @@
+/*
+* Copyright (c) 2022 Eureka Team.
+*      https://github.com/eurekadevelopment
+*
+* This program is free software; you can redistribute it and/or modify
+* it under the terms of the GNU General Public License as published by
+* the Free Software Foundation; either version 2 of the License, or
+* (at your option) any later version.
+*/
+
+cc_library_shared {
+    name: "libcorrectcamera",
+    defaults: ["hidl_defaults"],
+    proprietary: true,
+    srcs: [
+        "CorrectCameraID.cpp",
+    ],
+    shared_libs: [
+        "libhidlbase",
+        "libhardware",
+        "camera.device@3.2-impl",
+        "libcamera_metadata",
+        "android.hardware.camera.device@3.2",
+        "android.hardware.camera.provider@2.4",
+        "android.hardware.graphics.mapper@2.0",
+        "android.hardware.graphics.mapper@3.0",
+        "android.hardware.graphics.mapper@4.0",
+        "liblog",
+        "libutils",
+        "libcutils",
+    ],
+    static_libs: [
+        "android.hardware.camera.common@1.0-helper",
+    ],
+}

universal7885-common/libshims/camera/CamDevice_3_2.h

@@ -0,0 +1,164 @@
+/*
+ * Copyright (C) 2016 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ANDROID_HARDWARE_CAM_DEVICE_V3_2_CAMERADEVICE_H
+#define ANDROID_HARDWARE_CAM_DEVICE_V3_2_CAMERADEVICE_H
+
+#include "CameraDeviceSession.h"
+#include "CameraMetadata.h"
+#include "CameraModule.h"
+#include "utils/Mutex.h"
+
+#include <android/hardware/camera/device/3.2/ICameraDevice.h>
+#include <hidl/MQDescriptor.h>
+#include <hidl/Status.h>
+
+namespace android {
+namespace hardware {
+namespace camera {
+namespace device {
+namespace V3_2 {
+namespace implementation {
+
+using ::android::Mutex;
+using ::android::sp;
+using ::android::hardware::hidl_string;
+using ::android::hardware::hidl_vec;
+using ::android::hardware::Return;
+using ::android::hardware::Void;
+using ::android::hardware::camera::common::V1_0::CameraResourceCost;
+using ::android::hardware::camera::common::V1_0::Status;
+using ::android::hardware::camera::common::V1_0::TorchMode;
+using ::android::hardware::camera::common::V1_0::helper::CameraModule;
+using ::android::hardware::camera::device::V3_2::ICameraDevice;
+using ::android::hardware::camera::device::V3_2::ICameraDeviceCallback;
+using ::android::hardware::camera::device::V3_2::ICameraDeviceSession;
+using ::android::hardware::camera::device::V3_2::RequestTemplate;
+
+/*
+ * The camera device HAL implementation is opened lazily (via the open call)
+ */
+struct CameraDevice : public virtual RefBase {
+  // Called by provider HAL. Provider HAL must ensure the uniqueness of
+  // CameraDevice object per cameraId, or there could be multiple CameraDevice
+  // trying to access the same physical camera.
+  // Also, provider will have to keep track of all CameraDevice objects in
+  // order to notify CameraDevice when the underlying camera is detached
+  CameraDevice(sp<CameraModule> module, const std::string &cameraId,
+               const SortedVector<std::pair<std::string, std::string>>
+                   &cameraDeviceNames);
+  virtual ~CameraDevice();
+
+  // Retrieve the HIDL interface, split into its own class to avoid inheritance
+  // issues when dealing with minor version revs and simultaneous implementation
+  // and interface inheritance
+  virtual sp<ICameraDevice> getInterface() {
+    return new TrampolineDeviceInterface_3_2(this);
+  }
+
+  // Caller must use this method to check if CameraDevice ctor failed
+  bool isInitFailed() { return mInitFail; }
+  // Used by provider HAL to signal external camera disconnected
+  void setConnectionStatus(bool connected);
+
+  /* Methods from ::android::hardware::camera::device::V3_2::ICameraDevice
+   * follow. */
+  // The following method can be called without opening the actual camera device
+  Return<void> getResourceCost(ICameraDevice::getResourceCost_cb _hidl_cb);
+  Return<void>
+  getCameraCharacteristics(ICameraDevice::getCameraCharacteristics_cb _hidl_cb);
+  Return<void>
+  getEurekaCharacteristics(ICameraDevice::getCameraCharacteristics_cb _hidl_cb);
+  Return<Status> setTorchMode(TorchMode mode);
+
+  // Open the device HAL and also return a default capture session
+  Return<void> open(const sp<ICameraDeviceCallback> &callback,
+                    ICameraDevice::open_cb _hidl_cb);
+  Return<void> nuke(const sp<ICameraDeviceCallback> &callback,
+                    ICameraDevice::open_cb _hidl_cb);
+
+  // Forward the dump call to the opened session, or do nothing
+  Return<void> dumpState(const ::android::hardware::hidl_handle &fd);
+  /* End of Methods from
+   * ::android::hardware::camera::device::V3_2::ICameraDevice */
+
+protected:
+  // Overridden by child implementations for returning different versions of
+  // CameraDeviceSession
+  virtual sp<CameraDeviceSession>
+  createSession(camera3_device_t *, const camera_metadata_t *deviceInfo,
+                const sp<ICameraDeviceCallback> &);
+
+  const sp<CameraModule> mModule;
+  const std::string mCameraId;
+  // const after ctor
+  int mCameraIdInt;
+  int mDeviceVersion;
+  bool mInitFail = false;
+  // Set by provider (when external camera is connected/disconnected)
+  bool mDisconnected;
+  wp<CameraDeviceSession> mSession = nullptr;
+
+  const SortedVector<std::pair<std::string, std::string>> &mCameraDeviceNames;
+
+  // gating access to mSession and mDisconnected
+  mutable Mutex mLock;
+
+  // convert conventional HAL status to HIDL Status
+  static Status getHidlStatus(int);
+
+  Status initStatus() const;
+
+private:
+  struct TrampolineDeviceInterface_3_2 : public ICameraDevice {
+    TrampolineDeviceInterface_3_2(sp<CameraDevice> parent) : mParent(parent) {}
+
+    virtual Return<void>
+    getResourceCost(V3_2::ICameraDevice::getResourceCost_cb _hidl_cb) override {
+      return mParent->getResourceCost(_hidl_cb);
+    }
+
+    virtual Return<void> getCameraCharacteristics(
+        V3_2::ICameraDevice::getCameraCharacteristics_cb _hidl_cb) override {
+      return mParent->getCameraCharacteristics(_hidl_cb);
+    }
+
+    virtual Return<Status> setTorchMode(TorchMode mode) override {
+      return mParent->setTorchMode(mode);
+    }
+
+    virtual Return<void> open(const sp<V3_2::ICameraDeviceCallback> &callback,
+                              V3_2::ICameraDevice::open_cb _hidl_cb) override {
+      return mParent->open(callback, _hidl_cb);
+    }
+
+    virtual Return<void> dumpState(const hidl_handle &fd) override {
+      return mParent->dumpState(fd);
+    }
+
+  private:
+    sp<CameraDevice> mParent;
+  };
+};
+
+} // namespace implementation
+} // namespace V3_2
+} // namespace device
+} // namespace camera
+} // namespace hardware
+} // namespace android
+
+#endif // ANDROID_HARDWARE_CAM_DEVICE_V3_2_CAMERADEVICE_H

universal7885-common/libshims/camera/CorrectCameraID.cpp

@@ -0,0 +1,163 @@
+/*
+ * Copyright (c) 2022 Eureka Team.
+ *      https://github.com/eurekadevelopment
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ */
+
+#include "CamDevice_3_2.h"
+#include <include/convert.h>
+#include <log/log.h>
+
+namespace android {
+namespace hardware {
+namespace camera {
+namespace device {
+namespace V3_2 {
+namespace implementation {
+
+using ::android::hardware::camera::common::V1_0::Status;
+
+Return<void> CameraDevice::getCameraCharacteristics(
+    ICameraDevice::getCameraCharacteristics_cb _hidl_cb) {
+  Status status = initStatus();
+  CameraMetadata cameraCharacteristics;
+  if (status == Status::OK) {
+    // Module 2.1+ codepath.
+    struct camera_info info;
+    if (mCameraIdInt == 1)
+      mCameraIdInt = 2;
+    int ret = mModule->getCameraInfo(mCameraIdInt, &info);
+    if (ret == OK) {
+      convertToHidl(info.static_camera_characteristics, &cameraCharacteristics);
+    } else {
+      ALOGE("%s: get camera info failed!", __FUNCTION__);
+      status = Status::INTERNAL_ERROR;
+    }
+  }
+  _hidl_cb(status, cameraCharacteristics);
+  return Void();
+}
+
+Return<void> CameraDevice::getEurekaCharacteristics(
+    ICameraDevice::getCameraCharacteristics_cb _hidl_cb) {
+  return CameraDevice::getCameraCharacteristics(_hidl_cb);
+}
+
+Return<void> CameraDevice::open(const sp<ICameraDeviceCallback> &callback,
+                                ICameraDevice::open_cb _hidl_cb) {
+  Status status = initStatus();
+  sp<CameraDeviceSession> session = nullptr;
+
+  if (callback == nullptr) {
+    ALOGE("%s: cannot open camera %s. callback is null!", __FUNCTION__,
+          mCameraId.c_str());
+    _hidl_cb(Status::ILLEGAL_ARGUMENT, nullptr);
+    return Void();
+  }
+
+  if (status != Status::OK) {
+    // Provider will never pass initFailed device to client, so
+    // this must be a disconnected camera
+    ALOGE("%s: cannot open camera %s. camera is disconnected!", __FUNCTION__,
+          mCameraId.c_str());
+    _hidl_cb(Status::CAMERA_DISCONNECTED, nullptr);
+    return Void();
+  } else {
+    mLock.lock();
+
+    ALOGV("%s: Initializing device for camera %d", __FUNCTION__, mCameraIdInt);
+    session = mSession.promote();
+    if (session != nullptr && !session->isClosed()) {
+      ALOGE("%s: cannot open an already opened camera!", __FUNCTION__);
+      mLock.unlock();
+      _hidl_cb(Status::CAMERA_IN_USE, nullptr);
+      return Void();
+    }
+
+    /** Open HAL device */
+    status_t res;
+    camera3_device_t *device;
+
+    std::string mCameraID = mCameraId;
+    if (mCameraIdInt == 1)
+      mCameraIdInt = 2;
+    if (mCameraID == "1")
+      mCameraID = "2";
+
+    res = mModule->open(mCameraID.c_str(),
+                        reinterpret_cast<hw_device_t **>(&device));
+    if (res != OK) {
+      ALOGE("%s: cannot open camera %s!", __FUNCTION__, mCameraID.c_str());
+      mLock.unlock();
+      _hidl_cb(getHidlStatus(res), nullptr);
+      return Void();
+    }
+
+    /** Cross-check device version */
+    if (device->common.version < CAMERA_DEVICE_API_VERSION_3_2) {
+      ALOGE("%s: Could not open camera: "
+            "Camera device should be at least %x, reports %x instead",
+            __FUNCTION__, CAMERA_DEVICE_API_VERSION_3_2,
+            device->common.version);
+      device->common.close(&device->common);
+      mLock.unlock();
+      _hidl_cb(Status::ILLEGAL_ARGUMENT, nullptr);
+      return Void();
+    }
+
+    struct camera_info info;
+    res = mModule->getCameraInfo(mCameraIdInt, &info);
+    if (res != OK) {
+      ALOGE("%s: Could not open camera: getCameraInfo failed", __FUNCTION__);
+      device->common.close(&device->common);
+      mLock.unlock();
+      _hidl_cb(Status::ILLEGAL_ARGUMENT, nullptr);
+      return Void();
+    }
+
+    session =
+        createSession(device, info.static_camera_characteristics, callback);
+    if (session == nullptr) {
+      ALOGE("%s: camera device session allocation failed", __FUNCTION__);
+      mLock.unlock();
+      _hidl_cb(Status::INTERNAL_ERROR, nullptr);
+      return Void();
+    }
+    if (session->isInitFailed()) {
+      ALOGE("%s: camera device session init failed", __FUNCTION__);
+      session = nullptr;
+      mLock.unlock();
+      _hidl_cb(Status::INTERNAL_ERROR, nullptr);
+      return Void();
+    }
+    mSession = session;
+
+    IF_ALOGV() {
+      session->getInterface()->interfaceChain(
+          [](::android::hardware::hidl_vec<::android::hardware::hidl_string>
+                 interfaceChain) {
+            ALOGV("Session interface chain:");
+            for (const auto &iface : interfaceChain) {
+              ALOGV("  %s", iface.c_str());
+            }
+          });
+    }
+    mLock.unlock();
+  }
+  _hidl_cb(status, session->getInterface());
+  return Void();
+}
+Return<void> CameraDevice::nuke(const sp<ICameraDeviceCallback> &callback,
+                                ICameraDevice::open_cb _hidl_cb) {
+  return CameraDevice::open(callback, _hidl_cb);
+}
+} // namespace implementation
+} // namespace V3_2
+} // namespace device
+} // namespace camera
+} // namespace hardware
+} // namespace android

universal7885-common/libshims/sensor/ASensorManager.cpp

@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2020 LineageOS Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include <ALooper.h>
+
+#define LOG_TAG "libshim_sensorndkbridge"
+#include <android-base/logging.h>
+
+using android::Mutex;
+
+static Mutex gLock;
+
+extern "C" ALooper *ALooper_forCamera() {
+  LOG(VERBOSE) << "ALooper_forCamera";
+  ALooper *sLooper = NULL;
+
+  Mutex::Autolock autoLock(gLock);
+  sLooper = new ALooper;
+
+  return sLooper;
+}
+
+extern "C" int ALooper_release_forCamera(ALooper *sLooper) {
+  if (sLooper != nullptr) {
+    Mutex::Autolock autoLock(gLock);
+    delete sLooper;
+  }
+
+  return 0;
+}
+
+extern "C" int ALooper_pollOnce_camera(ALooper *sLooper, int timeoutMillis,
+                                       int *outFd, int *outEvents,
+                                       void **outData) {
+  int res = sLooper->pollOnce(timeoutMillis, outFd, outEvents, outData);
+  LOG(VERBOSE) << "ALooper_pollOnce_camera => " << res;
+  return res;
+}

universal7885-common/libshims/sensor/Android.bp

@@ -0,0 +1,19 @@
+cc_library_shared {
+    name: "libshim_sensorndkbridge",
+
+    srcs: ["ASensorManager.cpp"],
+    shared_libs: [
+        "liblog",
+        "libsensorndkbridge",
+        "libutils",
+    ],
+    whole_static_libs: ["libbase"],
+    header_libs: ["libbase_headers"],
+    vendor: true,
+
+    include_dirs: [
+        "system/core/libutils/include",
+        "frameworks/hardware/interfaces/sensorservice/libsensorndkbridge",
+    ],
+
+}