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

Commit 20b97e9e authored by Treehugger Robot's avatar Treehugger Robot Committed by Gerrit Code Review
Browse files

Merge changes from topic "fix-b-149854039-dynamic-hal-modules" 

* changes:
  Plumb the notification about audio HAL services update to APM
  libaudiohal: Allow late registration of HIDL HAL services
  Allow for late audio module discovery in APM
parents 47daf67f 3de4f26b

media/libaudioclient/AudioSystem.cpp

+7 −0
Original line number Diff line number Diff line
@@ -783,6 +783,13 @@ const sp<IAudioPolicyService> AudioSystem::get_audio_policy_service() 


// ---------------------------------------------------------------------------



void AudioSystem::onNewAudioModulesAvailable()

{

    const sp<IAudioPolicyService>& aps = AudioSystem::get_audio_policy_service();

    if (aps == 0) return;

    aps->onNewAudioModulesAvailable();

}



status_t AudioSystem::setDeviceConnectionState(audio_devices_t device,

                                               audio_policy_dev_state_t state,

                                               const char *device_address,

media/libaudioclient/IAudioPolicyService.cpp

+16 −1
Original line number Diff line number Diff line
@@ -108,6 +108,7 @@ enum { 
    SET_PREFERRED_DEVICE_FOR_PRODUCT_STRATEGY,

    REMOVE_PREFERRED_DEVICE_FOR_PRODUCT_STRATEGY,

    GET_PREFERRED_DEVICE_FOR_PRODUCT_STRATEGY,

    AUDIO_MODULES_UPDATED,  // oneway

};



#define MAX_ITEMS_PER_LIST 1024
@@ -1336,6 +1337,13 @@ public: 
        }

        return static_cast<status_t>(reply.readInt32());

    }



    virtual void onNewAudioModulesAvailable()

    {

        Parcel data, reply;

        data.writeInterfaceToken(IAudioPolicyService::getInterfaceDescriptor());

        remote()->transact(AUDIO_MODULES_UPDATED, data, &reply, IBinder::FLAG_ONEWAY);

    }

};



IMPLEMENT_META_INTERFACE(AudioPolicyService, "android.media.IAudioPolicyService");
@@ -1401,7 +1409,8 @@ status_t BnAudioPolicyService::onTransact( 
        case SET_RTT_ENABLED:

        case SET_PREFERRED_DEVICE_FOR_PRODUCT_STRATEGY:

        case REMOVE_PREFERRED_DEVICE_FOR_PRODUCT_STRATEGY:

        case GET_PREFERRED_DEVICE_FOR_PRODUCT_STRATEGY: {

        case GET_PREFERRED_DEVICE_FOR_PRODUCT_STRATEGY:

        case AUDIO_MODULES_UPDATED: {

            if (!isServiceUid(IPCThreadState::self()->getCallingUid())) {

                ALOGW("%s: transaction %d received from PID %d unauthorized UID %d",

                      __func__, code, IPCThreadState::self()->getCallingPid(),
@@ -2458,6 +2467,12 @@ status_t BnAudioPolicyService::onTransact( 
            return NO_ERROR;

        }



        case AUDIO_MODULES_UPDATED: {

            CHECK_INTERFACE(IAudioPolicyService, data, reply);

            onNewAudioModulesAvailable();

            return NO_ERROR;

        } break;



        default:

            return BBinder::onTransact(code, data, reply, flags);

    }

media/libaudioclient/include/media/AudioSystem.h

+1 −0
Original line number Diff line number Diff line
@@ -211,6 +211,7 @@ public: 
    //

    // IAudioPolicyService interface (see AudioPolicyInterface for method descriptions)

    //

    static void onNewAudioModulesAvailable();

    static status_t setDeviceConnectionState(audio_devices_t device, audio_policy_dev_state_t state,

                                             const char *device_address, const char *device_name,

                                             audio_format_t encodedFormat);

media/libaudioclient/include/media/IAudioPolicyService.h

+1 −0
Original line number Diff line number Diff line
@@ -42,6 +42,7 @@ public: 
    //

    // IAudioPolicyService interface (see AudioPolicyInterface for method descriptions)

    //

    virtual void onNewAudioModulesAvailable() = 0;

    virtual status_t setDeviceConnectionState(audio_devices_t device,

                                              audio_policy_dev_state_t state,

                                              const char *device_address,

media/libaudiohal/impl/DevicesFactoryHalHidl.cpp

+90 −22
Original line number Diff line number Diff line
@@ -15,12 +15,13 @@ 
 */



#include <string.h>

#include <vector>

#include <set>



#define LOG_TAG "DevicesFactoryHalHidl"

//#define LOG_NDEBUG 0



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

#include <android/hidl/manager/1.0/IServiceNotification.h>

#include PATH(android/hardware/audio/FILE_VERSION/IDevice.h)

#include <media/audiohal/hidl/HalDeathHandler.h>

#include <utils/Log.h>
@@ -29,33 +30,57 @@ 
#include "DeviceHalHidl.h"

#include "DevicesFactoryHalHidl.h"



#include <set>



using ::android::hardware::audio::CPP_VERSION::IDevice;

using ::android::hardware::audio::CPP_VERSION::Result;

using ::android::hardware::Return;

using ::android::hardware::Void;

using ::android::hidl::manager::V1_0::IServiceManager;

using ::android::hidl::manager::V1_0::IServiceNotification;



namespace android {

namespace CPP_VERSION {



DevicesFactoryHalHidl::DevicesFactoryHalHidl(sp<IDevicesFactory> devicesFactory) {

    ALOG_ASSERT(devicesFactory != nullptr, "Provided IDevicesFactory service is NULL");



    mDeviceFactories.push_back(devicesFactory);

    if (MAJOR_VERSION >= 4) {

        // The MSD factory is optional and only available starting at HAL 4.0

        sp<IDevicesFactory> msdFactory{IDevicesFactory::getService(AUDIO_HAL_SERVICE_NAME_MSD)};

        if (msdFactory) {

            mDeviceFactories.push_back(msdFactory);

        }

class ServiceNotificationListener : public IServiceNotification {

  public:

    explicit ServiceNotificationListener(sp<DevicesFactoryHalHidl> factory)

            : mFactory(factory) {}



    Return<void> onRegistration(const hidl_string& /*fully_qualified_name*/,

            const hidl_string& instance_name,

            bool /*pre_existing*/) override {

        if (static_cast<std::string>(instance_name) == "default") return Void();

        sp<DevicesFactoryHalHidl> factory = mFactory.promote();

        if (!factory) return Void();

        sp<IDevicesFactory> halFactory = IDevicesFactory::getService(instance_name);

        if (halFactory) {

            factory->addDeviceFactory(halFactory, true /*needToNotify*/);

        }

    for (const auto& factory : mDeviceFactories) {

        // It is assumed that the DevicesFactoryHalInterface instance is owned

        // by AudioFlinger and thus have the same lifespan.

        factory->linkToDeath(HalDeathHandler::getInstance(), 0 /*cookie*/);

        return Void();

    }



  private:

    wp<DevicesFactoryHalHidl> mFactory;

};



DevicesFactoryHalHidl::DevicesFactoryHalHidl(sp<IDevicesFactory> devicesFactory) {

    ALOG_ASSERT(devicesFactory != nullptr, "Provided default IDevicesFactory service is NULL");

    addDeviceFactory(devicesFactory, false /*needToNotify*/);

}



void DevicesFactoryHalHidl::onFirstRef() {

    sp<IServiceManager> sm = IServiceManager::getService();

    ALOG_ASSERT(sm != nullptr, "Hardware service manager is not running");

    sp<ServiceNotificationListener> listener = new ServiceNotificationListener(this);

    Return<bool> result = sm->registerForNotifications(

            IDevicesFactory::descriptor, "", listener);

    if (result.isOk()) {

        ALOGE_IF(!static_cast<bool>(result),

                "Hardware service manager refused to register listener");

    } else {

        ALOGE("Failed to register for hardware service manager notifications: %s",

                result.description().c_str());

    }

}



#if MAJOR_VERSION == 2

static IDevicesFactory::Device idFromHal(const char *name, status_t* status) {
@@ -83,12 +108,13 @@ static const char* idFromHal(const char *name, status_t* status) { 
#endif



status_t DevicesFactoryHalHidl::openDevice(const char *name, sp<DeviceHalInterface> *device) {

    if (mDeviceFactories.empty()) return NO_INIT;

    auto factories = copyDeviceFactories();

    if (factories.empty()) return NO_INIT;

    status_t status;

    auto hidlId = idFromHal(name, &status);

    if (status != OK) return status;

    Result retval = Result::NOT_INITIALIZED;

    for (const auto& factory : mDeviceFactories) {

    for (const auto& factory : factories) {

        Return<void> ret = factory->openDevice(

                hidlId,

                [&](Result r, const sp<IDevice>& result) {
@@ -113,10 +139,9 @@ status_t DevicesFactoryHalHidl::openDevice(const char *name, sp<DeviceHalInterfa 


status_t DevicesFactoryHalHidl::getHalPids(std::vector<pid_t> *pids) {

    std::set<pid_t> pidsSet;



    for (const auto& factory : mDeviceFactories) {

    auto factories = copyDeviceFactories();

    for (const auto& factory : factories) {

        using ::android::hidl::base::V1_0::DebugInfo;

        using android::hidl::manager::V1_0::IServiceManager;



        DebugInfo debugInfo;

        auto ret = factory->getDebugInfo([&] (const auto &info) {
@@ -135,5 +160,48 @@ status_t DevicesFactoryHalHidl::getHalPids(std::vector<pid_t> *pids) { 
    return NO_ERROR;

}



status_t DevicesFactoryHalHidl::setCallbackOnce(sp<DevicesFactoryHalCallback> callback) {

    ALOG_ASSERT(callback != nullptr);

    bool needToCallCallback = false;

    {

        std::lock_guard<std::mutex> lock(mLock);

        if (mCallback.unsafe_get()) return INVALID_OPERATION;

        mCallback = callback;

        if (mHaveUndeliveredNotifications) {

            needToCallCallback = true;

            mHaveUndeliveredNotifications = false;

        }

    }

    if (needToCallCallback) {

        callback->onNewDevicesAvailable();

    }

    return NO_ERROR;

}



void DevicesFactoryHalHidl::addDeviceFactory(sp<IDevicesFactory> factory, bool needToNotify) {

    // It is assumed that the DevicesFactoryHalInterface instance is owned

    // by AudioFlinger and thus have the same lifespan.

    factory->linkToDeath(HalDeathHandler::getInstance(), 0 /*cookie*/);

    sp<DevicesFactoryHalCallback> callback;

    {

        std::lock_guard<std::mutex> lock(mLock);

        mDeviceFactories.push_back(factory);

        if (needToNotify) {

            callback = mCallback.promote();

            if (!callback) {

                mHaveUndeliveredNotifications = true;

            }

        }

    }

    if (callback) {

        callback->onNewDevicesAvailable();

    }

}



std::vector<sp<IDevicesFactory>> DevicesFactoryHalHidl::copyDeviceFactories() {

    std::lock_guard<std::mutex> lock(mLock);

    return mDeviceFactories;

}



} // namespace CPP_VERSION

} // namespace android