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

Commit bbb4eac1 authored by Chong Zhang's avatar Chong Zhang
Browse files

transcoder: plumb uid/pid to transcoder createCodec 

Instead of using ResourceManagerService::overrideProcessInfo to
override the procinfo of the native MediaTranscodingService,
use the newly added AMediaCodec create methods with UID/PID.
This will allow the codec instance to be attributed to the
actual client (for battery reporting as well resource managerment
purposes), instead of all to media.transcoding.

Plumb uid/pid to transcoder to create the codec with them.

Fix up the unit test after the change.

bug: 159172726
test: transcoder unit tests.
Change-Id: Ie7e6fd813ec53f125590665ab3466758a0fd4601
parent a71f8a2a

media/libmediatranscoding/Android.bp

+0 −1
Original line number Diff line number Diff line
@@ -77,7 +77,6 @@ cc_library_shared { 


    static_libs: [

        "mediatranscoding_aidl_interface-ndk_platform",

        "resourcemanager_aidl_interface-ndk_platform",

        "resourceobserver_aidl_interface-ndk_platform",

    ],

media/libmediatranscoding/TranscoderWrapper.cpp

+2 −1
Original line number Diff line number Diff line
@@ -347,7 +347,8 @@ media_status_t TranscoderWrapper::setupTranscoder( 
    mCurrentClientId = clientId;

    mCurrentSessionId = sessionId;

    mTranscoderCb = std::make_shared<CallbackImpl>(shared_from_this(), clientId, sessionId);

    mTranscoder = MediaTranscoder::create(mTranscoderCb, pausedState);

    mTranscoder = MediaTranscoder::create(mTranscoderCb, request.clientPid, request.clientUid,

                                          pausedState);

    if (mTranscoder == nullptr) {

        ALOGE("failed to create transcoder");

        return AMEDIA_ERROR_UNKNOWN;

media/libmediatranscoding/TranscodingResourcePolicy.cpp

+18 −8
Original line number Diff line number Diff line
@@ -41,7 +41,7 @@ static std::string toString(const MediaObservableParcel& observable) { 
}



struct TranscodingResourcePolicy::ResourceObserver : public BnResourceObserver {

    explicit ResourceObserver(TranscodingResourcePolicy* owner) : mOwner(owner), mPid(getpid()) {}

    explicit ResourceObserver(TranscodingResourcePolicy* owner) : mOwner(owner) {}



    // IResourceObserver

    ::ndk::ScopedAStatus onStatusChanged(
@@ -51,12 +51,12 @@ struct TranscodingResourcePolicy::ResourceObserver : public BnResourceObserver { 
              ::aidl::android::media::toString(event).c_str(), uid, pid,

              toString(observables[0]).c_str());



        // Only report kIdle event for codec resources from other processes.

        if (((uint64_t)event & (uint64_t)MediaObservableEvent::kIdle) != 0 && (pid != mPid)) {

        // Only report kIdle event.

        if (((uint64_t)event & (uint64_t)MediaObservableEvent::kIdle) != 0) {

            for (auto& observable : observables) {

                if (observable.type == MediaObservableType::kVideoSecureCodec ||

                    observable.type == MediaObservableType::kVideoNonSecureCodec) {

                    mOwner->onResourceAvailable();

                    mOwner->onResourceAvailable(pid);

                    break;

                }

            }
@@ -65,7 +65,6 @@ struct TranscodingResourcePolicy::ResourceObserver : public BnResourceObserver { 
    }



    TranscodingResourcePolicy* mOwner;

    const pid_t mPid;

};



// static
@@ -83,7 +82,9 @@ void TranscodingResourcePolicy::BinderDiedCallback(void* cookie) { 
}



TranscodingResourcePolicy::TranscodingResourcePolicy()

      : mRegistered(false), mDeathRecipient(AIBinder_DeathRecipient_new(BinderDiedCallback)) {

      : mRegistered(false),

        mResourceLostPid(-1),

        mDeathRecipient(AIBinder_DeathRecipient_new(BinderDiedCallback)) {

    registerSelf();

}
@@ -155,11 +156,20 @@ void TranscodingResourcePolicy::setCallback( 
    mResourcePolicyCallback = cb;

}



void TranscodingResourcePolicy::onResourceAvailable() {

void TranscodingResourcePolicy::setPidResourceLost(pid_t pid) {

    std::scoped_lock lock{mCallbackLock};

    mResourceLostPid = pid;

}



void TranscodingResourcePolicy::onResourceAvailable(pid_t pid) {

    std::shared_ptr<ResourcePolicyCallbackInterface> cb;

    {

        std::scoped_lock lock{mCallbackLock};

        // Only callback if codec resource is released from other processes.

        if (mResourceLostPid != -1 && mResourceLostPid != pid) {

            cb = mResourcePolicyCallback.lock();

            mResourceLostPid = -1;

        }

    }



    if (cb != nullptr) {

media/libmediatranscoding/TranscodingSessionController.cpp

+1 −0
Original line number Diff line number Diff line
@@ -504,6 +504,7 @@ void TranscodingSessionController::onResourceLost() { 
        if (clientCallback != nullptr) {

            clientCallback->onTranscodingPaused(mCurrentSession->key.second);

        }

        mResourcePolicy->setPidResourceLost(mCurrentSession->request.clientPid);

    }

    mResourceLost = true;

media/libmediatranscoding/TranscodingUidPolicy.cpp

+0 −56
Original line number Diff line number Diff line
@@ -17,8 +17,6 @@ 
//#define LOG_NDEBUG 0

#define LOG_TAG "TranscodingUidPolicy"



#include <aidl/android/media/BnResourceManagerClient.h>

#include <aidl/android/media/IResourceManagerService.h>

#include <android/binder_manager.h>

#include <android/binder_process.h>

#include <binder/ActivityManager.h>
@@ -35,43 +33,6 @@ namespace android { 
constexpr static uid_t OFFLINE_UID = -1;

constexpr static const char* kTranscodingTag = "transcoding";



/*

 * The OOM score we're going to ask ResourceManager to use for our native transcoding

 * service. ResourceManager issues reclaims based on these scores. It gets the scores

 * from ActivityManagerService, which doesn't track native services. The values of the

 * OOM scores are defined in:

 * frameworks/base/services/core/java/com/android/server/am/ProcessList.java

 * We use SERVICE_ADJ which is lower priority than an app possibly visible to the

 * user, but higher priority than a cached app (which could be killed without disruption

 * to the user).

 */

constexpr static int32_t SERVICE_ADJ = 500;



using Status = ::ndk::ScopedAStatus;

using aidl::android::media::BnResourceManagerClient;

using aidl::android::media::IResourceManagerService;



/*

 * Placeholder ResourceManagerClient for registering process info override

 * with the IResourceManagerService. This is only used as a token by the service

 * to get notifications about binder death, not used for reclaiming resources.

 */

struct TranscodingUidPolicy::ResourceManagerClient : public BnResourceManagerClient {

    explicit ResourceManagerClient() = default;



    Status reclaimResource(bool* _aidl_return) override {

        *_aidl_return = false;

        return Status::ok();

    }



    Status getName(::std::string* _aidl_return) override {

        _aidl_return->clear();

        return Status::ok();

    }



    virtual ~ResourceManagerClient() = default;

};



struct TranscodingUidPolicy::UidObserver : public BnUidObserver,

                                           public virtual IBinder::DeathRecipient {

    explicit UidObserver(TranscodingUidPolicy* owner) : mOwner(owner) {}
@@ -116,7 +77,6 @@ TranscodingUidPolicy::TranscodingUidPolicy() 
        mRegistered(false),

        mTopUidState(ActivityManager::PROCESS_STATE_UNKNOWN) {

    registerSelf();

    setProcessInfoOverride();

}



TranscodingUidPolicy::~TranscodingUidPolicy() {
@@ -152,22 +112,6 @@ void TranscodingUidPolicy::unregisterSelf() { 
    ALOGI("TranscodingUidPolicy: Unregistered with ActivityManager");

}



void TranscodingUidPolicy::setProcessInfoOverride() {

    ::ndk::SpAIBinder binder(AServiceManager_getService("media.resource_manager"));

    std::shared_ptr<IResourceManagerService> service = IResourceManagerService::fromBinder(binder);

    if (service == nullptr) {

        ALOGE("Failed to get IResourceManagerService");

        return;

    }



    mProcInfoOverrideClient = ::ndk::SharedRefBase::make<ResourceManagerClient>();

    Status status = service->overrideProcessInfo(

            mProcInfoOverrideClient, getpid(), ActivityManager::PROCESS_STATE_SERVICE, SERVICE_ADJ);

    if (!status.isOk()) {

        ALOGW("Failed to setProcessInfoOverride.");

    }

}



void TranscodingUidPolicy::setUidObserverRegistered(bool registered) {

    Mutex::Autolock _l(mUidLock);