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

Commit f4e0a07d authored by Chong Zhang's avatar Chong Zhang Committed by Android (Google) Code Review
Browse files

Merge "transcoding: use libandroid for activity_manager"

parents 2d81ecdd ad8fdfc7

media/libmediatranscoding/Android.bp

+0 −1
Original line number Diff line number Diff line
@@ -66,7 +66,6 @@ cc_library_shared { 
        "liblog",

        "libutils",

        "libmediatranscoder",

        "libbinder",

        "libmediandk",

    ],

    export_shared_lib_headers: [

media/libmediatranscoding/TranscodingResourcePolicy.cpp

+0 −1
Original line number Diff line number Diff line
@@ -21,7 +21,6 @@ 
#include <aidl/android/media/IResourceObserverService.h>

#include <android/binder_manager.h>

#include <android/binder_process.h>

#include <binder/IServiceManager.h>

#include <media/TranscodingResourcePolicy.h>

#include <utils/Log.h>

media/libmediatranscoding/TranscodingUidPolicy.cpp

+37 −82
Original line number Diff line number Diff line
@@ -17,11 +17,9 @@ 
//#define LOG_NDEBUG 0

#define LOG_TAG "TranscodingUidPolicy"



#include <android/activity_manager.h>

#include <android/binder_manager.h>

#include <android/binder_process.h>

#include <binder/ActivityManager.h>

#include <cutils/misc.h>  // FIRST_APPLICATION_UID

#include <cutils/multiuser.h>

#include <inttypes.h>

#include <media/TranscodingUidPolicy.h>

#include <utils/Log.h>
@@ -31,51 +29,12 @@ 
namespace android {



constexpr static uid_t OFFLINE_UID = -1;

constexpr static const char* kTranscodingTag = "transcoding";



struct TranscodingUidPolicy::UidObserver : public BnUidObserver,

                                           public virtual IBinder::DeathRecipient {

    explicit UidObserver(TranscodingUidPolicy* owner) : mOwner(owner) {}



    // IUidObserver

    void onUidGone(uid_t uid, bool disabled) override;

    void onUidActive(uid_t uid) override;

    void onUidIdle(uid_t uid, bool disabled) override;

    void onUidStateChanged(uid_t uid, int32_t procState, int64_t procStateSeq,

                           int32_t capability) override;



    // IBinder::DeathRecipient implementation

    void binderDied(const wp<IBinder>& who) override;



    TranscodingUidPolicy* mOwner;

};



void TranscodingUidPolicy::UidObserver::onUidGone(uid_t uid __unused, bool disabled __unused) {}



void TranscodingUidPolicy::UidObserver::onUidActive(uid_t uid __unused) {}



void TranscodingUidPolicy::UidObserver::onUidIdle(uid_t uid __unused, bool disabled __unused) {}



void TranscodingUidPolicy::UidObserver::onUidStateChanged(uid_t uid, int32_t procState,

                                                          int64_t procStateSeq __unused,

                                                          int32_t capability __unused) {

    mOwner->onUidStateChanged(uid, procState);

}



void TranscodingUidPolicy::UidObserver::binderDied(const wp<IBinder>& /*who*/) {

    ALOGW("TranscodingUidPolicy: ActivityManager has died");

    // TODO(chz): this is a rare event (since if the AMS is dead, the system is

    // probably dead as well). But we should try to reconnect.

    mOwner->setUidObserverRegistered(false);

}



////////////////////////////////////////////////////////////////////////////

constexpr static int32_t IMPORTANCE_UNKNOWN = INT32_MAX;



TranscodingUidPolicy::TranscodingUidPolicy()

      : mAm(std::make_shared<ActivityManager>()),

        mUidObserver(new UidObserver(this)),

      : mUidObserver(nullptr),

        mRegistered(false),

        mTopUidState(ActivityManager::PROCESS_STATE_UNKNOWN) {

        mTopUidState(IMPORTANCE_UNKNOWN) {

    registerSelf();

}
@@ -83,39 +42,32 @@ TranscodingUidPolicy::~TranscodingUidPolicy() { 
    unregisterSelf();

}



void TranscodingUidPolicy::OnUidImportance(uid_t uid, int32_t uidImportance, void* cookie) {

    TranscodingUidPolicy* owner = reinterpret_cast<TranscodingUidPolicy*>(cookie);

    owner->onUidStateChanged(uid, uidImportance);

}



void TranscodingUidPolicy::registerSelf() {

    status_t res = mAm->linkToDeath(mUidObserver.get());

    mAm->registerUidObserver(

            mUidObserver.get(),

            ActivityManager::UID_OBSERVER_GONE | ActivityManager::UID_OBSERVER_IDLE |

                    ActivityManager::UID_OBSERVER_ACTIVE | ActivityManager::UID_OBSERVER_PROCSTATE,

            ActivityManager::PROCESS_STATE_UNKNOWN, String16(kTranscodingTag));



    if (res == OK) {

        Mutex::Autolock _l(mUidLock);

    mUidObserver = AActivityManager_addUidImportanceListener(

            &OnUidImportance, -1, (void*)this);



        mRegistered = true;

        ALOGI("TranscodingUidPolicy: Registered with ActivityManager");

    } else {

        mAm->unregisterUidObserver(mUidObserver.get());

    if (mUidObserver == nullptr) {

        ALOGE("Failed to register uid observer");

        return;

    }



    Mutex::Autolock _l(mUidLock);

    mRegistered = true;

    ALOGI("Registered uid observer");

}



void TranscodingUidPolicy::unregisterSelf() {

    mAm->unregisterUidObserver(mUidObserver.get());

    mAm->unlinkToDeath(mUidObserver.get());

    AActivityManager_removeUidImportanceListener(mUidObserver);

    mUidObserver = nullptr;



    Mutex::Autolock _l(mUidLock);



    mRegistered = false;



    ALOGI("TranscodingUidPolicy: Unregistered with ActivityManager");

}



void TranscodingUidPolicy::setUidObserverRegistered(bool registered) {

    Mutex::Autolock _l(mUidLock);



    mRegistered = registered;

    ALOGI("Unregistered uid observer");

}



void TranscodingUidPolicy::setCallback(const std::shared_ptr<UidPolicyCallbackInterface>& cb) {
@@ -133,9 +85,9 @@ void TranscodingUidPolicy::registerMonitorUid(uid_t uid) { 
        return;

    }



    int32_t state = ActivityManager::PROCESS_STATE_UNKNOWN;

    if (mRegistered && mAm->isUidActive(uid, String16(kTranscodingTag))) {

        state = mAm->getUidProcessState(uid, String16(kTranscodingTag));

    int32_t state = IMPORTANCE_UNKNOWN;

    if (mRegistered && AActivityManager_isUidActive(uid)) {

        state = AActivityManager_getUidImportance(uid);

    }



    ALOGV("%s: inserting new uid: %u, procState %d", __FUNCTION__, uid, state);
@@ -170,14 +122,14 @@ void TranscodingUidPolicy::unregisterMonitorUid(uid_t uid) { 
bool TranscodingUidPolicy::isUidOnTop(uid_t uid) {

    Mutex::Autolock _l(mUidLock);



    return mTopUidState != ActivityManager::PROCESS_STATE_UNKNOWN &&

    return mTopUidState != IMPORTANCE_UNKNOWN &&

           mTopUidState == getProcState_l(uid);

}



std::unordered_set<uid_t> TranscodingUidPolicy::getTopUids() const {

    Mutex::Autolock _l(mUidLock);



    if (mTopUidState == ActivityManager::PROCESS_STATE_UNKNOWN) {

    if (mTopUidState == IMPORTANCE_UNKNOWN) {

        return std::unordered_set<uid_t>();

    }
@@ -195,11 +147,13 @@ void TranscodingUidPolicy::onUidStateChanged(uid_t uid, int32_t procState) { 
        if (it != mUidStateMap.end() && it->second != procState) {

            // Top set changed if 1) the uid is in the current top uid set, or 2) the

            // new procState is at least the same priority as the current top uid state.

            bool isUidCurrentTop = mTopUidState != ActivityManager::PROCESS_STATE_UNKNOWN &&

            bool isUidCurrentTop =

                    mTopUidState != IMPORTANCE_UNKNOWN &&

                    mStateUidMap[mTopUidState].count(uid) > 0;

            bool isNewStateHigherThanTop = procState != ActivityManager::PROCESS_STATE_UNKNOWN &&

            bool isNewStateHigherThanTop =

                    procState != IMPORTANCE_UNKNOWN &&

                    (procState <= mTopUidState ||

                                            mTopUidState == ActivityManager::PROCESS_STATE_UNKNOWN);

                     mTopUidState == IMPORTANCE_UNKNOWN);

            topUidSetChanged = (isUidCurrentTop || isNewStateHigherThanTop);



            // Move uid to the new procState.
@@ -227,11 +181,12 @@ void TranscodingUidPolicy::onUidStateChanged(uid_t uid, int32_t procState) { 
}



void TranscodingUidPolicy::updateTopUid_l() {

    mTopUidState = ActivityManager::PROCESS_STATE_UNKNOWN;

    mTopUidState = IMPORTANCE_UNKNOWN;



    // Find the lowest uid state (ignoring PROCESS_STATE_UNKNOWN) with some monitored uids.

    for (auto stateIt = mStateUidMap.begin(); stateIt != mStateUidMap.end(); stateIt++) {

        if (stateIt->first != ActivityManager::PROCESS_STATE_UNKNOWN && !stateIt->second.empty()) {

        if (stateIt->first != IMPORTANCE_UNKNOWN &&

            !stateIt->second.empty()) {

            mTopUidState = stateIt->first;

            break;

        }
@@ -245,7 +200,7 @@ int32_t TranscodingUidPolicy::getProcState_l(uid_t uid) { 
    if (it != mUidStateMap.end()) {

        return it->second;

    }

    return ActivityManager::PROCESS_STATE_UNKNOWN;

    return IMPORTANCE_UNKNOWN;

}



}  // namespace android

media/libmediatranscoding/include/media/TranscodingUidPolicy.h

+6 −8
Original line number Diff line number Diff line
@@ -22,18 +22,16 @@ 
#include <media/UidPolicyInterface.h>

#include <sys/types.h>

#include <utils/Condition.h>

#include <utils/RefBase.h>

#include <utils/String8.h>

#include <utils/Vector.h>



#include <map>

#include <mutex>

#include <unordered_map>

#include <unordered_set>



struct AActivityManager_UidImportanceListener;



namespace android {



class ActivityManager;

// Observer for UID lifecycle and provide information about the uid's app

// priority used by the session controller.

class TranscodingUidPolicy : public UidPolicyInterface {
@@ -51,17 +49,17 @@ public: 


private:

    void onUidStateChanged(uid_t uid, int32_t procState);

    void setUidObserverRegistered(bool registerd);

    void registerSelf();

    void unregisterSelf();

    int32_t getProcState_l(uid_t uid) NO_THREAD_SAFETY_ANALYSIS;

    void updateTopUid_l() NO_THREAD_SAFETY_ANALYSIS;



    struct UidObserver;

    static void OnUidImportance(uid_t uid, int32_t uidImportance, void* cookie);



    struct ResourceManagerClient;

    mutable Mutex mUidLock;

    std::shared_ptr<ActivityManager> mAm;

    sp<UidObserver> mUidObserver;

    AActivityManager_UidImportanceListener* mUidObserver;



    bool mRegistered GUARDED_BY(mUidLock);

    int32_t mTopUidState GUARDED_BY(mUidLock);

    std::unordered_map<uid_t, int32_t> mUidStateMap GUARDED_BY(mUidLock);