Merge "transcoder: plumb uid/pid to transcoder createCodec" (75390ea0) · Commits · e / os / android_frameworks_av

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);