Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit d65d944b authored by Jayant Chowdhary's avatar Jayant Chowdhary
Browse files

Fix AIDL lazy camera HAL startup. 



AServiceManager_getService() won't start a service if it isn't already
running.

Bug: 285546208

Test: Vendor testing
Test: Kill camera provider process, make sure it comes up again and
      cameraserver adds it

Change-Id: I1bfd2c2af29afa795caa074d4de38a8d2119ee12
Signed-off-by: default avatarJayant Chowdhary <jchowdhary@google.com>
parent cf2c1e74

camera/camera_platform.aconfig

+7 −0
Original line number Diff line number Diff line
@@ -20,3 +20,10 @@ flag { 
     description: "Flash brightness level control in manual flash mode"

     bug: "238348881"

}



flag {

     namespace: "camera_platform"

     name: "lazy_aidl_wait_for_service"

     description: "Use waitForService instead of getService with lazy AIDL HALs"

     bug: "285546208"

}

services/camera/libcameraservice/common/CameraProviderManager.cpp

+31 −10
Original line number Diff line number Diff line
@@ -35,6 +35,7 @@ 
#include <android/binder_manager.h>

#include <android/hidl/manager/1.2/IServiceManager.h>

#include <hidl/ServiceManagement.h>

#include <com_android_internal_camera_flags.h>

#include <functional>

#include <camera_metadata_hidden.h>

#include <android-base/parseint.h>
@@ -57,6 +58,8 @@ using namespace camera3::SessionConfigurationUtils; 
using std::literals::chrono_literals::operator""s;

using hardware::camera2::utils::CameraIdAndSessionConfiguration;



namespace flags = com::android::internal::camera::flags;



namespace {

const bool kEnableLazyHal(property_get_bool("ro.camera.enableLazyHal", false));

const std::string kExternalProviderName = "external/0";
@@ -1918,9 +1921,15 @@ CameraProviderManager::isHiddenPhysicalCameraInternal(const std::string& cameraI 
status_t CameraProviderManager::tryToInitializeAidlProviderLocked(

        const std::string& providerName, const sp<ProviderInfo>& providerInfo) {

    using aidl::android::hardware::camera::provider::ICameraProvider;



    AIBinder *binder = nullptr;

    if (flags::lazy_aidl_wait_for_service()) {

        binder = AServiceManager_waitForService(providerName.c_str());

    } else {

        binder = AServiceManager_getService(providerName.c_str());

    }

    std::shared_ptr<ICameraProvider> interface =

            ICameraProvider::fromBinder(ndk::SpAIBinder(

                    AServiceManager_getService(providerName.c_str())));

            ICameraProvider::fromBinder(ndk::SpAIBinder(binder));



    if (interface == nullptr) {

        ALOGW("%s: AIDL Camera provider HAL '%s' is not actually available", __FUNCTION__,
@@ -1956,15 +1965,18 @@ status_t CameraProviderManager::addAidlProviderLocked(const std::string& newProv 
    bool providerPresent = false;

    bool preexisting =

            (mAidlProviderWithBinders.find(newProvider) != mAidlProviderWithBinders.end());



    // We need to use the extracted provider name here since 'newProvider' has

    // the fully qualified name of the provider service in case of AIDL. We want

    // just instance name.

    using aidl::android::hardware::camera::provider::ICameraProvider;

    std::string extractedProviderName =

    std::string providerNameUsed  =

            newProvider.substr(std::string(ICameraProvider::descriptor).size() + 1);

    if (flags::lazy_aidl_wait_for_service()) {

        // 'newProvider' has the fully qualified name of the provider service in case of AIDL.

        // ProviderInfo::mProviderName also has the fully qualified name - so we just compare them

        // here.

        providerNameUsed = newProvider;

    }



    for (const auto& providerInfo : mProviders) {

        if (providerInfo->mProviderName == extractedProviderName) {

        if (providerInfo->mProviderName == providerNameUsed) {

            ALOGW("%s: Camera provider HAL with name '%s' already registered",

                    __FUNCTION__, newProvider.c_str());

            // Do not add new instances for lazy HAL external provider or aidl
@@ -1981,7 +1993,7 @@ status_t CameraProviderManager::addAidlProviderLocked(const std::string& newProv 
    }



    sp<AidlProviderInfo> providerInfo =

            new AidlProviderInfo(extractedProviderName, providerInstance, this);

            new AidlProviderInfo(providerNameUsed, providerInstance, this);



    if (!providerPresent) {

        status_t res = tryToInitializeAidlProviderLocked(newProvider, providerInfo);
@@ -2061,6 +2073,9 @@ status_t CameraProviderManager::removeProvider(const std::string& provider) { 
            if (providerInfo->mProviderName == removedProviderName) {

                IPCTransport providerTransport = providerInfo->getIPCTransport();

                std::string removedAidlProviderName = getFullAidlProviderName(removedProviderName);

                if (flags::lazy_aidl_wait_for_service()) {

                    removedAidlProviderName = removedProviderName;

                }

                switch(providerTransport) {

                    case IPCTransport::HIDL:

                        return tryToInitializeHidlProviderLocked(removedProviderName, providerInfo);
@@ -2230,7 +2245,13 @@ void CameraProviderManager::ProviderInfo::removeAllDevices() { 
}



bool CameraProviderManager::ProviderInfo::isExternalLazyHAL() const {

    return kEnableLazyHal && (mProviderName == kExternalProviderName);

    std::string providerName = mProviderName;

    if (flags::lazy_aidl_wait_for_service() && getIPCTransport() == IPCTransport::AIDL) {

        using aidl::android::hardware::camera::provider::ICameraProvider;

        providerName =

                mProviderName.substr(std::string(ICameraProvider::descriptor).size() + 1);

    }

    return kEnableLazyHal && (providerName == kExternalProviderName);

}



status_t CameraProviderManager::ProviderInfo::dump(int fd, const Vector<String16>&) const {

services/camera/libcameraservice/common/CameraProviderManager.h

+1 −1
Original line number Diff line number Diff line
@@ -489,7 +489,7 @@ private: 
                CameraProviderManager *manager);

        ~ProviderInfo();



        virtual IPCTransport getIPCTransport() = 0;

        virtual IPCTransport getIPCTransport() const = 0;



        const std::string& getType() const;

services/camera/libcameraservice/common/aidl/AidlProviderInfo.cpp

+17 −5
Original line number Diff line number Diff line
@@ -17,6 +17,7 @@ 
#include "common/HalConversionsTemplated.h"

#include "common/CameraProviderInfoTemplated.h"



#include <com_android_internal_camera_flags.h>

#include <cutils/properties.h>



#include <aidlcommonsupport/NativeHandle.h>
@@ -34,6 +35,7 @@ const bool kEnableLazyHal(property_get_bool("ro.camera.enableLazyHal", false)); 


namespace android {



namespace flags = com::android::internal::camera::flags;

namespace SessionConfigurationUtils = ::android::camera3::SessionConfigurationUtils;



using namespace aidl::android::hardware;
@@ -99,7 +101,14 @@ AidlProviderInfo::AidlProviderInfo( 
status_t AidlProviderInfo::initializeAidlProvider(

        std::shared_ptr<ICameraProvider>& interface, int64_t currentDeviceState) {



    status_t res = parseProviderName(mProviderName, &mType, &mId);

    using aidl::android::hardware::camera::provider::ICameraProvider;

    std::string parsedProviderName = mProviderName;

    if (flags::lazy_aidl_wait_for_service()) {

        parsedProviderName =

                mProviderName.substr(std::string(ICameraProvider::descriptor).size() + 1);

    }



    status_t res = parseProviderName(parsedProviderName, &mType, &mId);

    if (res != OK) {

        ALOGE("%s: Invalid provider name, ignoring", __FUNCTION__);

        return BAD_VALUE;
@@ -274,10 +283,13 @@ const std::shared_ptr<ICameraProvider> AidlProviderInfo::startProviderInterface( 
        if (interface == nullptr) {

            ALOGV("Camera provider actually needs restart, calling getService(%s)",

                  mProviderName.c_str());

            interface =

                            ICameraProvider::fromBinder(

                                    ndk::SpAIBinder(

                                                AServiceManager_getService(mProviderName.c_str())));

            AIBinder * binder = nullptr;

            if (flags::lazy_aidl_wait_for_service()) {

                binder = AServiceManager_waitForService(mProviderName.c_str());

            } else {

                binder = AServiceManager_getService(mProviderName.c_str());

            }

            interface = ICameraProvider::fromBinder(ndk::SpAIBinder(binder));



            // Set all devices as ENUMERATING, provider should update status

            // to PRESENT after initializing.

services/camera/libcameraservice/common/aidl/AidlProviderInfo.h

+1 −1
Original line number Diff line number Diff line
@@ -49,7 +49,7 @@ struct AidlProviderInfo : public CameraProviderManager::ProviderInfo { 


    static void binderDied(void *cookie);



    virtual IPCTransport getIPCTransport() override {return IPCTransport::AIDL;}

    virtual IPCTransport getIPCTransport() const override {return IPCTransport::AIDL;}



    const std::shared_ptr<aidl::android::hardware::camera::provider::ICameraProvider>

    startProviderInterface();