gugelfrei
/
android_frameworks_av
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge changes from topic "ndk-binder"

Browse Source 
* changes:
  DrmSessionManager_test: remove ndk wrappers for IResourceManagerService
  convert ResourceManager usage in MediaCodec to ndk aidl
gugelfrei
TreeHugger Robot 5 years ago committed by Android (Google) Code Review
parent 15ccc64746 e45ac608ee
commit d054bb7218
20 changed files with 292 additions and 342 deletions
Show Stats Download Patch File Download Diff File

5
media/libmedia/Android.bp
Unescape View File

@ -313,6 +313,7 @@ cc_library {
"libprocessgroup",
"libutils",
"libbinder",
"libbinder_ndk",
"libsonivox",
"libandroidicu",
"libexpat",
@ -335,11 +336,11 @@ cc_library {
static_libs: [
"libc_malloc_debug_backtrace", // for memory heap analysis
"resourcemanager_aidl_interface-unstable-cpp",
"resourcemanager_aidl_interface-ndk_platform",
],
export_static_lib_headers: [
"resourcemanager_aidl_interface-unstable-cpp",
"resourcemanager_aidl_interface-ndk_platform",
],
export_include_dirs: [

6
media/libmedia/MediaResource.cpp
Unescape View File

@ -35,7 +35,7 @@ MediaResource::MediaResource(Type type, SubType subType, int64_t value) {
this->value = value;
}
MediaResource::MediaResource(Type type, const std::vector<uint8_t> &id, int64_t value) {
MediaResource::MediaResource(Type type, const std::vector<int8_t> &id, int64_t value) {
this->type = type;
this->subType = SubType::kUnspecifiedSubType;
this->id = id;
@ -66,11 +66,11 @@ MediaResource MediaResource::VideoBatteryResource() {
}
//static
MediaResource MediaResource::DrmSessionResource(const std::vector<uint8_t> &id, int64_t value) {
MediaResource MediaResource::DrmSessionResource(const std::vector<int8_t> &id, int64_t value) {
return MediaResource(Type::kDrmSession, id, value);
}
static String8 bytesToHexString(const std::vector<uint8_t> &bytes) {
static String8 bytesToHexString(const std::vector<int8_t> &bytes) {
String8 str;
for (auto &b : bytes) {
str.appendFormat("%02x", b);

15
media/libmedia/MediaResourcePolicy.cpp
Unescape View File

@ -16,20 +16,21 @@
//#define LOG_NDEBUG 0
#define LOG_TAG "MediaResourcePolicy"
#include <utils/Log.h>
#include <aidl/android/media/IResourceManagerService.h>
#include <media/MediaResourcePolicy.h>
#include <android/media/IResourceManagerService.h>
#include <utils/Log.h>
namespace android {
using android::media::IResourceManagerService;
using aidl::android::media::IResourceManagerService;
//static
const ::std::string& MediaResourcePolicy::kPolicySupportsMultipleSecureCodecs() {
return IResourceManagerService::kPolicySupportsMultipleSecureCodecs();
const char* MediaResourcePolicy::kPolicySupportsMultipleSecureCodecs() {
return IResourceManagerService::kPolicySupportsMultipleSecureCodecs;
}
//static
const ::std::string& MediaResourcePolicy::kPolicySupportsSecureWithNonSecureCodec() {
return IResourceManagerService::kPolicySupportsSecureWithNonSecureCodec();
const char* MediaResourcePolicy::kPolicySupportsSecureWithNonSecureCodec() {
return IResourceManagerService::kPolicySupportsSecureWithNonSecureCodec;
}
MediaResourcePolicy::MediaResourcePolicy(

13
media/libmedia/include/media/MediaResource.h
Unescape View File

@ -18,13 +18,14 @@
#ifndef ANDROID_MEDIA_RESOURCE_H
#define ANDROID_MEDIA_RESOURCE_H
#include <android/media/MediaResourceParcel.h>
#include <aidl/android/media/MediaResourceParcel.h>
#include <utils/String8.h>
namespace android {
using android::media::MediaResourceParcel;
using android::media::MediaResourceSubType;
using android::media::MediaResourceType;
using aidl::android::media::MediaResourceParcel;
using aidl::android::media::MediaResourceSubType;
using aidl::android::media::MediaResourceType;
class MediaResource : public MediaResourceParcel {
public:
@ -34,13 +35,13 @@ public:
MediaResource() = delete;
MediaResource(Type type, int64_t value);
MediaResource(Type type, SubType subType, int64_t value);
MediaResource(Type type, const std::vector<uint8_t> &id, int64_t value);
MediaResource(Type type, const std::vector<int8_t> &id, int64_t value);
static MediaResource CodecResource(bool secure, bool video);
static MediaResource GraphicMemoryResource(int64_t value);
static MediaResource CpuBoostResource();
static MediaResource VideoBatteryResource();
static MediaResource DrmSessionResource(const std::vector<uint8_t> &id, int64_t value);
static MediaResource DrmSessionResource(const std::vector<int8_t> &id, int64_t value);
};
inline static const char *asString(MediaResource::Type i, const char *def = "??") {

9
media/libmedia/include/media/MediaResourcePolicy.h
Unescape View File

@ -18,19 +18,20 @@
#ifndef ANDROID_MEDIA_RESOURCE_POLICY_H
#define ANDROID_MEDIA_RESOURCE_POLICY_H
#include <android/media/MediaResourcePolicyParcel.h>
#include <aidl/android/media/MediaResourcePolicyParcel.h>
#include <utils/String8.h>
namespace android {
using media::MediaResourcePolicyParcel;
using aidl::android::media::MediaResourcePolicyParcel;
class MediaResourcePolicy : public MediaResourcePolicyParcel {
public:
MediaResourcePolicy() = delete;
MediaResourcePolicy(const std::string& type, const std::string& value);
static const ::std::string& kPolicySupportsMultipleSecureCodecs();
static const ::std::string& kPolicySupportsSecureWithNonSecureCodec();
static const char* kPolicySupportsMultipleSecureCodecs();
static const char* kPolicySupportsSecureWithNonSecureCodec();
};
String8 toString(const MediaResourcePolicyParcel &policy);

156
media/libmediaplayerservice/tests/DrmSessionManager_test.cpp
Unescape View File

@ -23,7 +23,6 @@
#include <aidl/android/media/BnResourceManagerClient.h>
#include <aidl/android/media/BnResourceManagerService.h>
#include <android/media/BnResourceManagerClient.h>
#include <media/stagefright/foundation/ADebug.h>
#include <media/stagefright/ProcessInfoInterface.h>
@ -37,110 +36,11 @@
namespace android {
using ::android::binder::Status;
using ::android::media::ResourceManagerService;
using ::ndk::ScopedAStatus;
using NdkBnResourceManagerClient = ::aidl::android::media::BnResourceManagerClient;
using NdkBnResourceManagerService = ::aidl::android::media::BnResourceManagerService;
using NdkMediaResource = ::aidl::android::media::MediaResourceParcel;
using NdkResourceManagerClient = ::aidl::android::media::IResourceManagerClient;
using FwkBnResourceManagerClient = ::android::media::BnResourceManagerClient;
using FwkMediaResource = ::android::media::MediaResourceParcel;
namespace {
struct FwkResourceManagerClientImpl : public FwkBnResourceManagerClient {
FwkResourceManagerClientImpl(const std::shared_ptr<NdkResourceManagerClient> &client)
: mClient(client) {
}
Status reclaimResource(bool* _aidl_return) override {
mClient->reclaimResource(_aidl_return);
return Status::ok();
}
Status getName(std::string* _aidl_return) override {
mClient->getName(_aidl_return);
return Status::ok();
}
private:
std::shared_ptr<NdkResourceManagerClient> mClient;
};
FwkMediaResource NdkToFwkMediaResource(const NdkMediaResource &in) {
FwkMediaResource out{};
out.type = static_cast<decltype(out.type)>(in.type);
out.subType = static_cast<decltype(out.subType)>(in.subType);
auto v(reinterpret_cast<const uint8_t *>(in.id.data()));
out.id.assign(v, v + in.id.size());
out.value = in.value;
return out;
}
std::vector<FwkMediaResource> NdkToFwkMediaResourceVec(const std::vector<NdkMediaResource> &in) {
std::vector<FwkMediaResource> out;
for (auto e : in) {
out.push_back(NdkToFwkMediaResource(e));
}
return out;
}
ScopedAStatus FwkToNdkStatus(Status err) {
return ScopedAStatus(AStatus_fromExceptionCode(err.serviceSpecificErrorCode()));
}
struct NdkResourceManagerServiceImpl : public NdkBnResourceManagerService {
using NdkMediaResourcePolicy = ::aidl::android::media::MediaResourcePolicyParcel;
NdkResourceManagerServiceImpl(const sp<ResourceManagerService> &service)
: mService(service) {}
ScopedAStatus config(const std::vector<NdkMediaResourcePolicy>& in_policies) override {
(void)in_policies;
return ScopedAStatus::ok();
}
ScopedAStatus addResource(int32_t in_pid, int32_t in_uid, int64_t in_clientId,
const std::shared_ptr<NdkResourceManagerClient>& in_client,
const std::vector<NdkMediaResource>& in_resources) override {
sp<FwkBnResourceManagerClient> client(new FwkResourceManagerClientImpl(in_client));
std::vector<FwkMediaResource> resources(NdkToFwkMediaResourceVec(in_resources));
auto err = mService->addResource(in_pid, in_uid, in_clientId, client, resources);
return FwkToNdkStatus(err);
}
ScopedAStatus removeResource(int32_t in_pid, int64_t in_clientId,
const std::vector<NdkMediaResource>& in_resources) override {
std::vector<FwkMediaResource> resources(NdkToFwkMediaResourceVec(in_resources));
auto err = mService->removeResource(in_pid, in_clientId, resources);
return FwkToNdkStatus(err);
}
ScopedAStatus removeClient(int32_t in_pid, int64_t in_clientId) override{
auto err = mService->removeClient(in_pid, in_clientId);
return FwkToNdkStatus(err);
}
ScopedAStatus reclaimResource(int32_t in_callingPid,
const std::vector<NdkMediaResource>& in_resources, bool* _aidl_return) override {
std::vector<FwkMediaResource> resources(NdkToFwkMediaResourceVec(in_resources));
auto err = mService->reclaimResource(in_callingPid, resources, _aidl_return);
return FwkToNdkStatus(err);
}
private:
sp<ResourceManagerService> mService;
};
template <typename Impl>
std::shared_ptr<NdkResourceManagerClient> NdkImplToIface(const Impl &impl) {
return std::static_pointer_cast<NdkResourceManagerClient>(impl);
}
}
using Status = ::ndk::ScopedAStatus;
using ::aidl::android::media::BnResourceManagerClient;
using ::aidl::android::media::BnResourceManagerService;
using ::aidl::android::media::MediaResourceParcel;
using ::aidl::android::media::IResourceManagerClient;
static Vector<uint8_t> toAndroidVector(const std::vector<uint8_t> &vec) {
Vector<uint8_t> aVec;
@ -169,27 +69,27 @@ private:
DISALLOW_EVIL_CONSTRUCTORS(FakeProcessInfo);
};
struct FakeDrm : public NdkBnResourceManagerClient {
struct FakeDrm : public BnResourceManagerClient {
FakeDrm(const std::vector<uint8_t>& sessionId, const sp<DrmSessionManager>& manager)
: mSessionId(toAndroidVector(sessionId)),
mReclaimed(false),
mDrmSessionManager(manager) {}
ScopedAStatus reclaimResource(bool* _aidl_return) {
Status reclaimResource(bool* _aidl_return) {
mReclaimed = true;
mDrmSessionManager->removeSession(mSessionId);
*_aidl_return = true;
return ScopedAStatus::ok();
return Status::ok();
}
ScopedAStatus getName(::std::string* _aidl_return) {
Status getName(::std::string* _aidl_return) {
String8 name("FakeDrm[");
for (size_t i = 0; i < mSessionId.size(); ++i) {
name.appendFormat("%02x", mSessionId[i]);
}
name.append("]");
*_aidl_return = name;
return ScopedAStatus::ok();
return Status::ok();
}
bool isReclaimed() const {
@ -215,8 +115,7 @@ struct FakeSystemCallback :
virtual void noteResetVideo() override {}
virtual bool requestCpusetBoost(
bool /*enable*/, const sp<IInterface> &/*client*/) override {
virtual bool requestCpusetBoost(bool /*enable*/) override {
return true;
}
@ -237,21 +136,25 @@ static const std::vector<uint8_t> kTestSessionId3{9, 0};
class DrmSessionManagerTest : public ::testing::Test {
public:
DrmSessionManagerTest()
: mService(new ResourceManagerService(new FakeProcessInfo(), new FakeSystemCallback())),
mDrmSessionManager(new DrmSessionManager(std::shared_ptr<NdkBnResourceManagerService>(new NdkResourceManagerServiceImpl(mService)))),
mTestDrm1(new FakeDrm(kTestSessionId1, mDrmSessionManager)),
mTestDrm2(new FakeDrm(kTestSessionId2, mDrmSessionManager)),
mTestDrm3(new FakeDrm(kTestSessionId3, mDrmSessionManager)) {
: mService(::ndk::SharedRefBase::make<ResourceManagerService>
(new FakeProcessInfo(), new FakeSystemCallback())),
mDrmSessionManager(new DrmSessionManager(mService)),
mTestDrm1(::ndk::SharedRefBase::make<FakeDrm>(
kTestSessionId1, mDrmSessionManager)),
mTestDrm2(::ndk::SharedRefBase::make<FakeDrm>(
kTestSessionId2, mDrmSessionManager)),
mTestDrm3(::ndk::SharedRefBase::make<FakeDrm>(
kTestSessionId3, mDrmSessionManager)) {
}
protected:
void addSession() {
mDrmSessionManager->addSession(kTestPid1, NdkImplToIface(mTestDrm1), mTestDrm1->mSessionId);
mDrmSessionManager->addSession(kTestPid2, NdkImplToIface(mTestDrm2), mTestDrm2->mSessionId);
mDrmSessionManager->addSession(kTestPid2, NdkImplToIface(mTestDrm3), mTestDrm3->mSessionId);
mDrmSessionManager->addSession(kTestPid1, mTestDrm1, mTestDrm1->mSessionId);
mDrmSessionManager->addSession(kTestPid2, mTestDrm2, mTestDrm2->mSessionId);
mDrmSessionManager->addSession(kTestPid2, mTestDrm3, mTestDrm3->mSessionId);
}
sp<ResourceManagerService> mService;
std::shared_ptr<ResourceManagerService> mService;
sp<DrmSessionManager> mDrmSessionManager;
std::shared_ptr<FakeDrm> mTestDrm1;
std::shared_ptr<FakeDrm> mTestDrm2;
@ -302,8 +205,9 @@ TEST_F(DrmSessionManagerTest, reclaimSession) {
// add a session from a higher priority process.
const std::vector<uint8_t> sid{1, 3, 5};
std::shared_ptr<FakeDrm> drm(new FakeDrm(sid, mDrmSessionManager));
mDrmSessionManager->addSession(15, NdkImplToIface(drm), drm->mSessionId);
std::shared_ptr<FakeDrm> drm =
::ndk::SharedRefBase::make<FakeDrm>(sid, mDrmSessionManager);
mDrmSessionManager->addSession(15, drm, drm->mSessionId);
// make sure mTestDrm2 is reclaimed next instead of mTestDrm3
mDrmSessionManager->useSession(mTestDrm3->mSessionId);
@ -323,9 +227,9 @@ TEST_F(DrmSessionManagerTest, reclaimAfterUse) {
EXPECT_FALSE(mDrmSessionManager->reclaimSession(kTestPid2));
// add sessions from same pid
mDrmSessionManager->addSession(kTestPid2, NdkImplToIface(mTestDrm1), mTestDrm1->mSessionId);
mDrmSessionManager->addSession(kTestPid2, NdkImplToIface(mTestDrm2), mTestDrm2->mSessionId);
mDrmSessionManager->addSession(kTestPid2, NdkImplToIface(mTestDrm3), mTestDrm3->mSessionId);
mDrmSessionManager->addSession(kTestPid2, mTestDrm1, mTestDrm1->mSessionId);
mDrmSessionManager->addSession(kTestPid2, mTestDrm2, mTestDrm2->mSessionId);
mDrmSessionManager->addSession(kTestPid2, mTestDrm3, mTestDrm3->mSessionId);
// use some but not all sessions
mDrmSessionManager->useSession(mTestDrm1->mSessionId);

1
media/libstagefright/Android.bp
Unescape View File

@ -227,6 +227,7 @@ cc_library {
"libaudioutils",
"libbase",
"libbinder",
"libbinder_ndk",
"libcamera_client",
"libcutils",
"libdatasource",

151
media/libstagefright/MediaCodec.cpp
Unescape View File

@ -27,11 +27,11 @@
#include <android/hardware/cas/native/1.0/IDescrambler.h>
#include <android/hardware/media/omx/1.0/IGraphicBufferSource.h>
#include <android/media/BnResourceManagerClient.h>
#include <android/media/IResourceManagerService.h>
#include <aidl/android/media/BnResourceManagerClient.h>
#include <aidl/android/media/IResourceManagerService.h>
#include <android/binder_ibinder.h>
#include <android/binder_manager.h>
#include <binder/IMemory.h>
#include <binder/IPCThreadState.h>
#include <binder/IServiceManager.h>
#include <binder/MemoryDealer.h>
#include <cutils/properties.h>
#include <gui/BufferQueue.h>
@ -64,9 +64,10 @@
namespace android {
using ::android::binder::Status;
using ::android::media::BnResourceManagerClient;
using ::android::media::IResourceManagerService;
using Status = ::ndk::ScopedAStatus;
using aidl::android::media::BnResourceManagerClient;
using aidl::android::media::IResourceManagerClient;
using aidl::android::media::IResourceManagerService;
// key for media statistics
static const char *kCodecKeyName = "codec";
@ -111,7 +112,7 @@ static const char *kCodecRecentLatencyHist = "android.media.mediacodec.recent.hi
static bool kEmitHistogram = false;
static int64_t getId(const sp<IResourceManagerClient> &client) {
static int64_t getId(const std::shared_ptr<IResourceManagerClient> &client) {
return (int64_t) client.get();
}
@ -164,7 +165,6 @@ struct ResourceManagerClient : public BnResourceManagerClient {
return Status::ok();
}
protected:
virtual ~ResourceManagerClient() {}
private:
@ -173,93 +173,99 @@ private:
DISALLOW_EVIL_CONSTRUCTORS(ResourceManagerClient);
};
struct MediaCodec::ResourceManagerServiceProxy : public IBinder::DeathRecipient {
ResourceManagerServiceProxy(pid_t pid, uid_t uid);
~ResourceManagerServiceProxy();
struct MediaCodec::ResourceManagerServiceProxy : public RefBase {
ResourceManagerServiceProxy(pid_t pid, uid_t uid,
const std::shared_ptr<IResourceManagerClient> &client);
virtual ~ResourceManagerServiceProxy();
void init();
// implements DeathRecipient
virtual void binderDied(const wp<IBinder>& /*who*/);
void addResource(
int64_t clientId,
const sp<IResourceManagerClient> &client,
const std::vector<MediaResourceParcel> &resources);
void removeResource(
int64_t clientId,
const std::vector<MediaResourceParcel> &resources);
void removeClient(int64_t clientId);
static void BinderDiedCallback(void* cookie);
void binderDied();
void addResource(const MediaResourceParcel &resource);
void removeResource(const MediaResourceParcel &resource);
void removeClient();
bool reclaimResource(const std::vector<MediaResourceParcel> &resources);
private:
Mutex mLock;
sp<android::media::IResourceManagerService> mService;
pid_t mPid;
uid_t mUid;
std::shared_ptr<IResourceManagerService> mService;
std::shared_ptr<IResourceManagerClient> mClient;
::ndk::ScopedAIBinder_DeathRecipient mDeathRecipient;
};
MediaCodec::ResourceManagerServiceProxy::ResourceManagerServiceProxy(
pid_t pid, uid_t uid)
: mPid(pid), mUid(uid) {
pid_t pid, uid_t uid, const std::shared_ptr<IResourceManagerClient> &client)
: mPid(pid), mUid(uid), mClient(client),
mDeathRecipient(AIBinder_DeathRecipient_new(BinderDiedCallback)) {
if (mPid == MediaCodec::kNoPid) {
mPid = IPCThreadState::self()->getCallingPid();
mPid = AIBinder_getCallingPid();
}
}
MediaCodec::ResourceManagerServiceProxy::~ResourceManagerServiceProxy() {
if (mService != NULL) {
IInterface::asBinder(mService)->unlinkToDeath(this);
if (mService != nullptr) {
AIBinder_unlinkToDeath(mService->asBinder().get(), mDeathRecipient.get(), this);
}
}
void MediaCodec::ResourceManagerServiceProxy::init() {
sp<IServiceManager> sm = defaultServiceManager();
sp<IBinder> binder = sm->getService(String16("media.resource_manager"));
mService = interface_cast<IResourceManagerService>(binder);
if (mService == NULL) {
::ndk::SpAIBinder binder(AServiceManager_getService("media.resource_manager"));
mService = IResourceManagerService::fromBinder(binder);
if (mService == nullptr) {
ALOGE("Failed to get ResourceManagerService");
return;
}
IInterface::asBinder(mService)->linkToDeath(this);
AIBinder_linkToDeath(mService->asBinder().get(), mDeathRecipient.get(), this);
}
//static
void MediaCodec::ResourceManagerServiceProxy::BinderDiedCallback(void* cookie) {
auto thiz = static_cast<ResourceManagerServiceProxy*>(cookie);
thiz->binderDied();
}
void MediaCodec::ResourceManagerServiceProxy::binderDied(const wp<IBinder>& /*who*/) {
void MediaCodec::ResourceManagerServiceProxy::binderDied() {
ALOGW("ResourceManagerService died.");
Mutex::Autolock _l(mLock);
mService.clear();
mService = nullptr;
}
void MediaCodec::ResourceManagerServiceProxy::addResource(
int64_t clientId,
const sp<IResourceManagerClient> &client,
const std::vector<MediaResourceParcel> &resources) {
const MediaResourceParcel &resource) {
std::vector<MediaResourceParcel> resources;
resources.push_back(resource);
Mutex::Autolock _l(mLock);
if (mService == NULL) {
if (mService == nullptr) {
return;
}
mService->addResource(mPid, mUid, clientId, client, resources);
mService->addResource(mPid, mUid, getId(mClient), mClient, resources);
}
void MediaCodec::ResourceManagerServiceProxy::removeResource(
int64_t clientId,
const std::vector<MediaResourceParcel> &resources) {
const MediaResourceParcel &resource) {
std::vector<MediaResourceParcel> resources;
resources.push_back(resource);
Mutex::Autolock _l(mLock);
if (mService == NULL) {
if (mService == nullptr) {
return;
}
mService->removeResource(mPid, clientId, resources);
mService->removeResource(mPid, getId(mClient), resources);
}
void MediaCodec::ResourceManagerServiceProxy::removeClient(int64_t clientId) {
void MediaCodec::ResourceManagerServiceProxy::removeClient() {
Mutex::Autolock _l(mLock);
if (mService == NULL) {
if (mService == nullptr) {
return;
}
mService->removeClient(mPid, clientId);
mService->removeClient(mPid, getId(mClient));
}
bool MediaCodec::ResourceManagerServiceProxy::reclaimResource(
@ -579,19 +585,19 @@ MediaCodec::MediaCodec(const sp<ALooper> &looper, pid_t pid, uid_t uid)
mCpuBoostRequested(false),
mLatencyUnknown(0) {
if (uid == kNoUid) {
mUid = IPCThreadState::self()->getCallingUid();
mUid = AIBinder_getCallingUid();
} else {
mUid = uid;
}
mResourceManagerClient = new ResourceManagerClient(this);
mResourceManagerService = new ResourceManagerServiceProxy(pid, mUid);
mResourceManagerProxy = new ResourceManagerServiceProxy(pid, mUid,
::ndk::SharedRefBase::make<ResourceManagerClient>(this));
initMediametrics();
}
MediaCodec::~MediaCodec() {
CHECK_EQ(mState, UNINITIALIZED);
mResourceManagerService->removeClient(getId(mResourceManagerClient));
mResourceManagerProxy->removeClient();
flushMediametrics();
}
@ -792,7 +798,7 @@ void MediaCodec::statsBufferSent(int64_t presentationUs) {
if (mBatteryChecker != nullptr) {
mBatteryChecker->onCodecActivity([this] () {
addResource(MediaResource::VideoBatteryResource());
mResourceManagerProxy->addResource(MediaResource::VideoBatteryResource());
});
}
@ -832,7 +838,7 @@ void MediaCodec::statsBufferReceived(int64_t presentationUs) {
if (mBatteryChecker != nullptr) {
mBatteryChecker->onCodecActivity([this] () {
addResource(MediaResource::VideoBatteryResource());
mResourceManagerProxy->addResource(MediaResource::VideoBatteryResource());
});
}
@ -942,7 +948,7 @@ sp<CodecBase> MediaCodec::GetCodecBase(const AString &name, const char *owner) {
}
status_t MediaCodec::init(const AString &name) {
mResourceManagerService->init();
mResourceManagerProxy->init();
// save init parameters for reset
mInitName = name;
@ -1041,7 +1047,7 @@ status_t MediaCodec::init(const AString &name) {
for (int i = 0; i <= kMaxRetry; ++i) {
if (i > 0) {
// Don't try to reclaim resource for the first time.
if (!mResourceManagerService->reclaimResource(resources)) {
if (!mResourceManagerProxy->reclaimResource(resources)) {
break;
}
}
@ -1156,7 +1162,7 @@ status_t MediaCodec::configure(
for (int i = 0; i <= kMaxRetry; ++i) {
if (i > 0) {
// Don't try to reclaim resource for the first time.
if (!mResourceManagerService->reclaimResource(resources)) {
if (!mResourceManagerProxy->reclaimResource(resources)) {
break;
}
}
@ -1277,19 +1283,6 @@ uint64_t MediaCodec::getGraphicBufferSize() {
return size;
}
void MediaCodec::addResource(const MediaResourceParcel &resource) {
std::vector<MediaResourceParcel> resources;
resources.push_back(resource);
mResourceManagerService->addResource(
getId(mResourceManagerClient), mResourceManagerClient, resources);
}
void MediaCodec::removeResource(const MediaResourceParcel &resource) {
std::vector<MediaResourceParcel> resources;
resources.push_back(resource);
mResourceManagerService->removeResource(getId(mResourceManagerClient), resources);
}
status_t MediaCodec::start() {
sp<AMessage> msg = new AMessage(kWhatStart, this);
@ -1302,7 +1295,7 @@ status_t MediaCodec::start() {
for (int i = 0; i <= kMaxRetry; ++i) {
if (i > 0) {
// Don't try to reclaim resource for the first time.
if (!mResourceManagerService->reclaimResource(resources)) {
if (!mResourceManagerProxy->reclaimResource(resources)) {
break;
}
// Recover codec from previous error before retry start.
@ -1740,7 +1733,7 @@ void MediaCodec::requestCpuBoostIfNeeded() {
totalPixel = width * height;
}
if (totalPixel >= 1920 * 1080) {
addResource(MediaResource::CpuBoostResource());
mResourceManagerProxy->addResource(MediaResource::CpuBoostResource());
mCpuBoostRequested = true;
}
}
@ -2095,7 +2088,8 @@ void MediaCodec::onMessageReceived(const sp<AMessage> &msg) {
if (mIsVideo) {
// audio codec is currently ignored.
addResource(MediaResource::CodecResource(mFlags & kFlagIsSecure, mIsVideo));
mResourceManagerProxy->addResource(
MediaResource::CodecResource(mFlags & kFlagIsSecure, mIsVideo));
}
(new AMessage)->postReply(mReplyID);
@ -2216,8 +2210,8 @@ void MediaCodec::onMessageReceived(const sp<AMessage> &msg) {
CHECK_EQ(mState, STARTING);
if (mIsVideo) {
addResource(MediaResource::GraphicMemoryResource(
getGraphicBufferSize()));
mResourceManagerProxy->addResource(
MediaResource::GraphicMemoryResource(getGraphicBufferSize()));
}
setState(STARTED);
(new AMessage)->postReply(mReplyID);
@ -2441,7 +2435,7 @@ void MediaCodec::onMessageReceived(const sp<AMessage> &msg) {
mBatteryChecker->onClientRemoved();
}
mResourceManagerService->removeClient(getId(mResourceManagerClient));
mResourceManagerProxy->removeClient();
(new AMessage)->postReply(mReplyID);
break;
@ -3158,7 +3152,8 @@ void MediaCodec::onMessageReceived(const sp<AMessage> &msg) {
{
if (mBatteryChecker != nullptr) {
mBatteryChecker->onCheckBatteryTimer(msg, [this] () {
removeResource(MediaResource::VideoBatteryResource());
mResourceManagerProxy->removeResource(
MediaResource::VideoBatteryResource());
});
}
break;

2
media/libstagefright/MediaCodecListOverrides.cpp
Unescape View File

@ -265,7 +265,7 @@ void profileCodecs(
}
}
global_results->add(
MediaResourcePolicy::kPolicySupportsMultipleSecureCodecs().c_str(),
MediaResourcePolicy::kPolicySupportsMultipleSecureCodecs(),
supportMultipleSecureCodecs);
}

21
media/libstagefright/include/media/stagefright/MediaCodec.h
Unescape View File

@ -29,6 +29,14 @@
#include <media/stagefright/FrameRenderTracker.h>
#include <utils/Vector.h>
namespace aidl {
namespace android {
namespace media {
class MediaResourceParcel;
} // media
} // android
} // aidl
namespace android {
struct ABuffer;
@ -51,13 +59,9 @@ namespace native {
namespace V1_0 {
struct IDescrambler;
}}}}
namespace media {
class IResourceManagerClient;
class MediaResourceParcel;
}
using hardware::cas::native::V1_0::IDescrambler;
using media::IResourceManagerClient;
using media::MediaResourceParcel;
using aidl::android::media::MediaResourceParcel;
struct MediaCodec : public AHandler {
enum ConfigureFlags {
@ -315,8 +319,7 @@ private:
sp<AMessage> mCallback;
sp<AMessage> mOnFrameRenderedNotification;
sp<IResourceManagerClient> mResourceManagerClient;
sp<ResourceManagerServiceProxy> mResourceManagerService;
sp<ResourceManagerServiceProxy> mResourceManagerProxy;
bool mIsVideo;
int32_t mVideoWidth;
@ -410,8 +413,6 @@ private:
bool isExecuting() const;
uint64_t getGraphicBufferSize();
void addResource(const MediaResourceParcel &resource);
void removeResource(const MediaResourceParcel &resource);
void requestCpuBoostIfNeeded();
bool hasPendingBuffer(int portIndex);

2
media/mediaserver/main_mediaserver.cpp
Unescape View File

@ -40,7 +40,7 @@ int main(int argc __unused, char **argv __unused)
ALOGI("ServiceManager: %p", sm.get());
AIcu_initializeIcuOrDie();
MediaPlayerService::instantiate();
media::ResourceManagerService::instantiate();
ResourceManagerService::instantiate();
registerExtensions();
ProcessState::self()->startThreadPool();
IPCThreadState::self()->joinThreadPool();

4
media/utils/ISchedulingPolicyService.cpp
Unescape View File

@ -62,12 +62,12 @@ public:
return reply.readInt32();
}
virtual int requestCpusetBoost(bool enable, const sp<IInterface>& client)
virtual int requestCpusetBoost(bool enable, const sp<IBinder>& client)
{
Parcel data, reply;
data.writeInterfaceToken(ISchedulingPolicyService::getInterfaceDescriptor());
data.writeInt32(enable);
data.writeStrongBinder(IInterface::asBinder(client));
data.writeStrongBinder(client);
status_t status = remote()->transact(REQUEST_CPUSET_BOOST, data, &reply, 0);
if (status != NO_ERROR) {
return status;

2
media/utils/ISchedulingPolicyService.h
Unescape View File

@ -29,7 +29,7 @@ public:
virtual int requestPriority(/*pid_t*/int32_t pid, /*pid_t*/int32_t tid,
int32_t prio, bool isForApp, bool asynchronous) = 0;
virtual int requestCpusetBoost(bool enable, const sp<IInterface>& client) = 0;
virtual int requestCpusetBoost(bool enable, const sp<IBinder>& client) = 0;
};
class BnSchedulingPolicyService : public BnInterface<ISchedulingPolicyService>

2
media/utils/SchedulingPolicyService.cpp
Unescape View File

@ -59,7 +59,7 @@ int requestPriority(pid_t pid, pid_t tid, int32_t prio, bool isForApp, bool asyn
return ret;
}
int requestCpusetBoost(bool enable, const sp<IInterface> &client)
int requestCpusetBoost(bool enable, const sp<IBinder> &client)
{
int ret;
sMutex.lock();

4
media/utils/include/mediautils/SchedulingPolicyService.h
Unescape View File

@ -21,7 +21,7 @@
namespace android {
class IInterface;
class IBinder;
// Request elevated priority for thread tid, whose thread group leader must be pid.
// The priority parameter is currently restricted to either 1 or 2.
// The asynchronous parameter should be 'true' to return immediately,
@ -35,7 +35,7 @@ int requestPriority(pid_t pid, pid_t tid, int32_t prio, bool isForApp, bool asyn
// for the server to receive death notifications. When 'enable' is 'false', server
// will attempt to move media.codec process back to the original cpuset, and
// 'client' is ignored in this case.
int requestCpusetBoost(bool enable, const sp<IInterface> &client);
int requestCpusetBoost(bool enable, const sp<IBinder> &client);
} // namespace android

1
services/mediaresourcemanager/Android.bp
Unescape View File

@ -12,6 +12,7 @@ cc_library_shared {
"libmedia",
"libmediautils",
"libbinder",
"libbinder_ndk",
"libutils",
"liblog",
],

108
services/mediaresourcemanager/ResourceManagerService.cpp
Unescape View File

@ -19,6 +19,8 @@
#define LOG_TAG "ResourceManagerService"
#include <utils/Log.h>
#include <android/binder_manager.h>
#include <android/binder_process.h>
#include <binder/IMediaResourceMonitor.h>
#include <binder/IServiceManager.h>
#include <cutils/sched_policy.h>
@ -38,28 +40,25 @@
namespace android {
namespace media {
DeathNotifier::DeathNotifier(const std::shared_ptr<ResourceManagerService> &service,
int pid, int64_t clientId)
: mService(service), mPid(pid), mClientId(clientId) {}
class DeathNotifier : public IBinder::DeathRecipient {
public:
DeathNotifier(const wp<ResourceManagerService> &service, int pid, int64_t clientId)
: mService(service), mPid(pid), mClientId(clientId) {}
//static
void DeathNotifier::BinderDiedCallback(void* cookie) {
auto thiz = static_cast<DeathNotifier*>(cookie);
thiz->binderDied();
}
virtual void binderDied(const wp<IBinder> & /* who */) override {
// Don't check for pid validity since we know it's already dead.
sp<ResourceManagerService> service = mService.promote();
if (service == nullptr) {
ALOGW("ResourceManagerService is dead as well.");
return;
}
service->removeResource(mPid, mClientId, false);
void DeathNotifier::binderDied() {
// Don't check for pid validity since we know it's already dead.
std::shared_ptr<ResourceManagerService> service = mService.lock();
if (service == nullptr) {
ALOGW("ResourceManagerService is dead as well.");
return;
}
private:
wp<ResourceManagerService> mService;
int mPid;
int64_t mClientId;
};
service->removeResource(mPid, mClientId, false);
}
template <typename T>
static String8 getString(const std::vector<T> &items) {
@ -104,7 +103,7 @@ static ResourceInfos& getResourceInfosForEdit(
static ResourceInfo& getResourceInfoForEdit(
uid_t uid,
int64_t clientId,
const sp<IResourceManagerClient>& client,
const std::shared_ptr<IResourceManagerClient>& client,
ResourceInfos& infos) {
ssize_t index = infos.indexOfKey(clientId);
@ -135,14 +134,15 @@ static void notifyResourceGranted(int pid, const std::vector<MediaResourceParcel
}
}
status_t ResourceManagerService::dump(int fd, const Vector<String16>& /* args */) {
binder_status_t ResourceManagerService::dump(
int fd, const char** /*args*/, uint32_t /*numArgs*/) {
String8 result;
if (checkCallingPermission(String16("android.permission.DUMP")) == false) {
result.format("Permission Denial: "
"can't dump ResourceManagerService from pid=%d, uid=%d\n",
IPCThreadState::self()->getCallingPid(),
IPCThreadState::self()->getCallingUid());
AIBinder_getCallingPid(),
AIBinder_getCallingUid());
write(fd, result.string(), result.size());
return PERMISSION_DENIED;
}
@ -206,7 +206,7 @@ status_t ResourceManagerService::dump(int fd, const Vector<String16>& /* args */
struct SystemCallbackImpl :
public ResourceManagerService::SystemCallbackInterface {
SystemCallbackImpl() {}
SystemCallbackImpl() : mClientToken(new BBinder()) {}
virtual void noteStartVideo(int uid) override {
BatteryNotifier::getInstance().noteStartVideo(uid);
@ -217,9 +217,8 @@ struct SystemCallbackImpl :
virtual void noteResetVideo() override {
BatteryNotifier::getInstance().noteResetVideo();
}
virtual bool requestCpusetBoost(
bool enable, const sp<IInterface> &client) override {
return android::requestCpusetBoost(enable, client);
virtual bool requestCpusetBoost(bool enable) override {
return android::requestCpusetBoost(enable, mClientToken);
}
protected:
@ -227,6 +226,7 @@ protected:
private:
DISALLOW_EVIL_CONSTRUCTORS(SystemCallbackImpl);
sp<IBinder> mClientToken;
};
ResourceManagerService::ResourceManagerService()
@ -240,10 +240,26 @@ ResourceManagerService::ResourceManagerService(
mServiceLog(new ServiceLog()),
mSupportsMultipleSecureCodecs(true),
mSupportsSecureWithNonSecureCodec(true),
mCpuBoostCount(0) {
mCpuBoostCount(0),
mDeathRecipient(AIBinder_DeathRecipient_new(DeathNotifier::BinderDiedCallback)) {
mSystemCB->noteResetVideo();
}
//static
void ResourceManagerService::instantiate() {
std::shared_ptr<ResourceManagerService> service =
::ndk::SharedRefBase::make<ResourceManagerService>();
binder_status_t status =
AServiceManager_addService(service->asBinder().get(), getServiceName());
if (status != STATUS_OK) {
return;
}
// TODO: mediaserver main() is already starting the thread pool,
// move this to mediaserver main() when other services in mediaserver
// are converted to ndk-platform aidl.
//ABinderProcess_startThreadPool();
}
ResourceManagerService::~ResourceManagerService() {}
Status ResourceManagerService::config(const std::vector<MediaResourcePolicyParcel>& policies) {
@ -271,7 +287,7 @@ void ResourceManagerService::onFirstAdded(
// Request it on every new instance of kCpuBoost, as the media.codec
// could have died, if we only do it the first time subsequent instances
// never gets the boost.
if (mSystemCB->requestCpusetBoost(true, this) != OK) {
if (mSystemCB->requestCpusetBoost(true) != OK) {
ALOGW("couldn't request cpuset boost");
}
mCpuBoostCount++;
@ -287,7 +303,7 @@ void ResourceManagerService::onLastRemoved(
&& resource.subType == MediaResource::SubType::kUnspecifiedSubType
&& mCpuBoostCount > 0) {
if (--mCpuBoostCount == 0) {
mSystemCB->requestCpusetBoost(false, this);
mSystemCB->requestCpusetBoost(false);
}
} else if (resource.type == MediaResource::Type::kBattery
&& resource.subType == MediaResource::SubType::kVideoCodec) {
@ -316,7 +332,7 @@ Status ResourceManagerService::addResource(
int32_t pid,
int32_t uid,
int64_t clientId,
const sp<IResourceManagerClient>& client,
const std::shared_ptr<IResourceManagerClient>& client,
const std::vector<MediaResourceParcel>& resources) {
String8 log = String8::format("addResource(pid %d, clientId %lld, resources %s)",
pid, (long long) clientId, getString(resources).string());
@ -352,8 +368,9 @@ Status ResourceManagerService::addResource(
}
}
if (info.deathNotifier == nullptr && client != nullptr) {
info.deathNotifier = new DeathNotifier(this, pid, clientId);
IInterface::asBinder(client)->linkToDeath(info.deathNotifier);
info.deathNotifier = new DeathNotifier(ref<ResourceManagerService>(), pid, clientId);
AIBinder_linkToDeath(client->asBinder().get(),
mDeathRecipient.get(), info.deathNotifier.get());
}
notifyResourceGranted(pid, resources);
return Status::ok();
@ -442,18 +459,20 @@ Status ResourceManagerService::removeResource(int pid, int64_t clientId, bool ch
onLastRemoved(it->second, info);
}
IInterface::asBinder(info.client)->unlinkToDeath(info.deathNotifier);
AIBinder_unlinkToDeath(info.client->asBinder().get(),
mDeathRecipient.get(), info.deathNotifier.get());
infos.removeItemsAt(index);
return Status::ok();
}
void ResourceManagerService::getClientForResource_l(
int callingPid, const MediaResourceParcel *res, Vector<sp<IResourceManagerClient>> *clients) {
int callingPid, const MediaResourceParcel *res,
Vector<std::shared_ptr<IResourceManagerClient>> *clients) {
if (res == NULL) {
return;
}
sp<IResourceManagerClient> client;
std::shared_ptr<IResourceManagerClient> client;
if (getLowestPriorityBiggestClient_l(callingPid, res->type, &client)) {
clients->push_back(client);
}
@ -468,7 +487,7 @@ Status ResourceManagerService::reclaimResource(
mServiceLog->add(log);
*_aidl_return = false;
Vector<sp<IResourceManagerClient>> clients;
Vector<std::shared_ptr<IResourceManagerClient>> clients;
{
Mutex::Autolock lock(mLock);
if (!mProcessInfo->isValidPid(callingPid)) {
@ -547,7 +566,7 @@ Status ResourceManagerService::reclaimResource(
return Status::ok();
}
sp<IResourceManagerClient> failedClient;
std::shared_ptr<IResourceManagerClient> failedClient;
for (size_t i = 0; i < clients.size(); ++i) {
log = String8::format("reclaimResource from client %p", clients[i].get());
mServiceLog->add(log);
@ -590,8 +609,9 @@ Status ResourceManagerService::reclaimResource(
}
bool ResourceManagerService::getAllClients_l(
int callingPid, MediaResource::Type type, Vector<sp<IResourceManagerClient>> *clients) {
Vector<sp<IResourceManagerClient>> temp;
int callingPid, MediaResource::Type type,
Vector<std::shared_ptr<IResourceManagerClient>> *clients) {
Vector<std::shared_ptr<IResourceManagerClient>> temp;
for (size_t i = 0; i < mMap.size(); ++i) {
ResourceInfos &infos = mMap.editValueAt(i);
for (size_t j = 0; j < infos.size(); ++j) {
@ -616,7 +636,8 @@ bool ResourceManagerService::getAllClients_l(
}
bool ResourceManagerService::getLowestPriorityBiggestClient_l(
int callingPid, MediaResource::Type type, sp<IResourceManagerClient> *client) {
int callingPid, MediaResource::Type type,
std::shared_ptr<IResourceManagerClient> *client) {
int lowestPriorityPid;
int lowestPriority;
int callingPriority;
@ -688,14 +709,14 @@ bool ResourceManagerService::isCallingPriorityHigher_l(int callingPid, int pid)
}
bool ResourceManagerService::getBiggestClient_l(
int pid, MediaResource::Type type, sp<IResourceManagerClient> *client) {
int pid, MediaResource::Type type, std::shared_ptr<IResourceManagerClient> *client) {
ssize_t index = mMap.indexOfKey(pid);
if (index < 0) {
ALOGE("getBiggestClient_l: can't find resource info for pid %d", pid);
return false;
}
sp<IResourceManagerClient> clientTemp;
std::shared_ptr<IResourceManagerClient> clientTemp;
uint64_t largestValue = 0;
const ResourceInfos &infos = mMap.valueAt(index);
for (size_t i = 0; i < infos.size(); ++i) {
@ -720,5 +741,4 @@ bool ResourceManagerService::getBiggestClient_l(
return true;
}
} // namespace media
} // namespace android

70
services/mediaresourcemanager/ResourceManagerService.h
Unescape View File

@ -18,9 +18,8 @@
#ifndef ANDROID_MEDIA_RESOURCEMANAGERSERVICE_H
#define ANDROID_MEDIA_RESOURCEMANAGERSERVICE_H
#include <android/media/BnResourceManagerService.h>
#include <aidl/android/media/BnResourceManagerService.h>
#include <arpa/inet.h>
#include <binder/BinderService.h>
#include <media/MediaResource.h>
#include <utils/Errors.h>
#include <utils/KeyedVector.h>
@ -30,22 +29,26 @@
namespace android {
class DeathNotifier;
class ResourceManagerService;
class ServiceLog;
struct ProcessInfoInterface;
namespace media {
using android::binder::Status;
using Status = ::ndk::ScopedAStatus;
using ::aidl::android::media::IResourceManagerClient;
using ::aidl::android::media::BnResourceManagerService;
using ::aidl::android::media::MediaResourceParcel;
using ::aidl::android::media::MediaResourcePolicyParcel;
typedef std::map<std::tuple<
MediaResource::Type, MediaResource::SubType, std::vector<uint8_t>>,
MediaResource::Type, MediaResource::SubType, std::vector<int8_t>>,
MediaResourceParcel> ResourceList;
struct ResourceInfo {
int64_t clientId;
uid_t uid;
sp<IResourceManagerClient> client;
sp<IBinder::DeathRecipient> deathNotifier;
std::shared_ptr<IResourceManagerClient> client;
sp<DeathNotifier> deathNotifier;
ResourceList resources;
};
@ -53,27 +56,42 @@ struct ResourceInfo {
typedef KeyedVector<int64_t, ResourceInfo> ResourceInfos;
typedef KeyedVector<int, ResourceInfos> PidResourceInfosMap;
class ResourceManagerService
: public BinderService<ResourceManagerService>,
public BnResourceManagerService
{
class DeathNotifier : public RefBase {
public:
DeathNotifier(const std::shared_ptr<ResourceManagerService> &service,
int pid, int64_t clientId);
~DeathNotifier() {}
// Implement death recipient
static void BinderDiedCallback(void* cookie);
void binderDied();
private:
std::weak_ptr<ResourceManagerService> mService;
int mPid;
int64_t mClientId;
};
class ResourceManagerService : public BnResourceManagerService {
public:
struct SystemCallbackInterface : public RefBase {
virtual void noteStartVideo(int uid) = 0;
virtual void noteStopVideo(int uid) = 0;
virtual void noteResetVideo() = 0;
virtual bool requestCpusetBoost(
bool enable, const sp<IInterface> &client) = 0;
virtual bool requestCpusetBoost(bool enable) = 0;
};
static char const *getServiceName() { return "media.resource_manager"; }
static void instantiate();
virtual status_t dump(int fd, const Vector<String16>& args);
virtual inline binder_status_t dump(
int /*fd*/, const char** /*args*/, uint32_t /*numArgs*/);
ResourceManagerService();
explicit ResourceManagerService(
const sp<ProcessInfoInterface> &processInfo,
const sp<SystemCallbackInterface> &systemResource);
virtual ~ResourceManagerService();
// IResourceManagerService interface
Status config(const std::vector<MediaResourcePolicyParcel>& policies) override;
@ -82,7 +100,7 @@ public:
int32_t pid,
int32_t uid,
int64_t clientId,
const sp<IResourceManagerClient>& client,
const std::shared_ptr<IResourceManagerClient>& client,
const std::vector<MediaResourceParcel>& resources) override;
Status removeResource(
@ -102,9 +120,6 @@ public:
Status removeResource(int pid, int64_t clientId, bool checkValid);
protected:
virtual ~ResourceManagerService();
private:
friend class ResourceManagerServiceTest;
@ -112,13 +127,13 @@ private:
// Returns false if any client belongs to a process with higher priority than the
// calling process. The clients will remain unchanged if returns false.
bool getAllClients_l(int callingPid, MediaResource::Type type,
Vector<sp<IResourceManagerClient>> *clients);
Vector<std::shared_ptr<IResourceManagerClient>> *clients);
// Gets the client who owns specified resource type from lowest possible priority process.
// Returns false if the calling process priority is not higher than the lowest process
// priority. The client will remain unchanged if returns false.
bool getLowestPriorityBiggestClient_l(int callingPid, MediaResource::Type type,
sp<IResourceManagerClient> *client);
std::shared_ptr<IResourceManagerClient> *client);
// Gets lowest priority process that has the specified resource type.
// Returns false if failed. The output parameters will remain unchanged if failed.
@ -126,14 +141,15 @@ private:
// Gets the client who owns biggest piece of specified resource type from pid.
// Returns false if failed. The client will remain unchanged if failed.
bool getBiggestClient_l(int pid, MediaResource::Type type, sp<IResourceManagerClient> *client);
bool getBiggestClient_l(int pid, MediaResource::Type type,
std::shared_ptr<IResourceManagerClient> *client);
bool isCallingPriorityHigher_l(int callingPid, int pid);
// A helper function basically calls getLowestPriorityBiggestClient_l and add the result client
// to the given Vector.
void getClientForResource_l(int callingPid,
const MediaResourceParcel *res, Vector<sp<IResourceManagerClient>> *clients);
// A helper function basically calls getLowestPriorityBiggestClient_l and add
// the result client to the given Vector.
void getClientForResource_l(int callingPid, const MediaResourceParcel *res,
Vector<std::shared_ptr<IResourceManagerClient>> *clients);
void onFirstAdded(const MediaResourceParcel& res, const ResourceInfo& clientInfo);
void onLastRemoved(const MediaResourceParcel& res, const ResourceInfo& clientInfo);
@ -149,10 +165,10 @@ private:
bool mSupportsMultipleSecureCodecs;
bool mSupportsSecureWithNonSecureCodec;
int32_t mCpuBoostCount;
::ndk::ScopedAIBinder_DeathRecipient mDeathRecipient;
};
// ----------------------------------------------------------------------------
} // namespace media
} // namespace android
#endif // ANDROID_MEDIA_RESOURCEMANAGERSERVICE_H

1
services/mediaresourcemanager/test/Android.bp
Unescape View File

@ -5,6 +5,7 @@ cc_test {
test_suites: ["device-tests"],
shared_libs: [
"libbinder",
"libbinder_ndk",
"liblog",
"libmedia",
"libresourcemanagerservice",

61
services/mediaresourcemanager/test/ResourceManagerService_test.cpp
Unescape View File

@ -21,18 +21,28 @@
#include <gtest/gtest.h>
#include "ResourceManagerService.h"
#include <android/media/BnResourceManagerClient.h>
#include <aidl/android/media/BnResourceManagerClient.h>
#include <media/MediaResource.h>
#include <media/MediaResourcePolicy.h>
#include <media/stagefright/foundation/ADebug.h>
#include <media/stagefright/ProcessInfoInterface.h>
namespace aidl {
namespace android {
namespace media {
bool operator== (const MediaResourceParcel& lhs, const MediaResourceParcel& rhs) {
return lhs.type == rhs.type && lhs.subType == rhs.subType &&
lhs.id == rhs.id && lhs.value == rhs.value;
}}}}
using ::android::binder::Status;
namespace android {
using Status = ::ndk::ScopedAStatus;
using ::aidl::android::media::BnResourceManagerClient;
using ::aidl::android::media::IResourceManagerService;
using ::aidl::android::media::IResourceManagerClient;
static int64_t getId(const sp<IResourceManagerClient>& client) {
static int64_t getId(const std::shared_ptr<IResourceManagerClient>& client) {
return (int64_t) client.get();
}
@ -89,8 +99,7 @@ struct TestSystemCallback :
mEventCount++;
}
virtual bool requestCpusetBoost(
bool enable, const sp<IInterface> &/*client*/) override {
virtual bool requestCpusetBoost(bool enable) override {
mLastEvent = {enable ? EventType::CPUSET_ENABLE : EventType::CPUSET_DISABLE, 0};
mEventCount++;
return true;
@ -112,12 +121,11 @@ private:
struct TestClient : public BnResourceManagerClient {
TestClient(int pid, sp<ResourceManagerService> service)
TestClient(int pid, const std::shared_ptr<ResourceManagerService> &service)
: mReclaimed(false), mPid(pid), mService(service) {}
Status reclaimResource(bool* _aidl_return) override {
sp<IResourceManagerClient> client(this);
mService->removeClient(mPid, (int64_t) client.get());
mService->removeClient(mPid, getId(ref<TestClient>()));
mReclaimed = true;
*_aidl_return = true;
return Status::ok();
@ -136,13 +144,12 @@ struct TestClient : public BnResourceManagerClient {
mReclaimed = false;
}
protected:
virtual ~TestClient() {}
private:
bool mReclaimed;
int mPid;
sp<ResourceManagerService> mService;
std::shared_ptr<ResourceManagerService> mService;
DISALLOW_EVIL_CONSTRUCTORS(TestClient);
};
@ -172,10 +179,11 @@ class ResourceManagerServiceTest : public ::testing::Test {
public:
ResourceManagerServiceTest()
: mSystemCB(new TestSystemCallback()),
mService(new ResourceManagerService(new TestProcessInfo, mSystemCB)),
mTestClient1(new TestClient(kTestPid1, mService)),
mTestClient2(new TestClient(kTestPid2, mService)),
mTestClient3(new TestClient(kTestPid2, mService)) {
mService(::ndk::SharedRefBase::make<ResourceManagerService>(
new TestProcessInfo, mSystemCB)),
mTestClient1(::ndk::SharedRefBase::make<TestClient>(kTestPid1, mService)),
mTestClient2(::ndk::SharedRefBase::make<TestClient>(kTestPid2, mService)),
mTestClient3(::ndk::SharedRefBase::make<TestClient>(kTestPid2, mService)) {
}
protected:
@ -193,7 +201,7 @@ protected:
static void expectEqResourceInfo(const ResourceInfo &info,
int uid,
sp<IResourceManagerClient> client,
std::shared_ptr<IResourceManagerClient> client,
const std::vector<MediaResourceParcel> &resources) {
EXPECT_EQ(uid, info.uid);
EXPECT_EQ(client, info.client);
@ -334,11 +342,11 @@ protected:
std::vector<MediaResourcePolicyParcel> policies1;
policies1.push_back(
MediaResourcePolicy(
IResourceManagerService::kPolicySupportsMultipleSecureCodecs(),
IResourceManagerService::kPolicySupportsMultipleSecureCodecs,
"true"));
policies1.push_back(
MediaResourcePolicy(
IResourceManagerService::kPolicySupportsSecureWithNonSecureCodec(),
IResourceManagerService::kPolicySupportsSecureWithNonSecureCodec,
"false"));
mService->config(policies1);
EXPECT_TRUE(mService->mSupportsMultipleSecureCodecs);
@ -347,11 +355,11 @@ protected:
std::vector<MediaResourcePolicyParcel> policies2;
policies2.push_back(
MediaResourcePolicy(
IResourceManagerService::kPolicySupportsMultipleSecureCodecs(),
IResourceManagerService::kPolicySupportsMultipleSecureCodecs,
"false"));
policies2.push_back(
MediaResourcePolicy(
IResourceManagerService::kPolicySupportsSecureWithNonSecureCodec(),
IResourceManagerService::kPolicySupportsSecureWithNonSecureCodec,
"true"));
mService->config(policies2);
EXPECT_FALSE(mService->mSupportsMultipleSecureCodecs);
@ -458,7 +466,7 @@ protected:
addResource();
MediaResource::Type type = MediaResource::Type::kSecureCodec;
Vector<sp<IResourceManagerClient> > clients;
Vector<std::shared_ptr<IResourceManagerClient> > clients;
EXPECT_FALSE(mService->getAllClients_l(kLowPriorityPid, type, &clients));
// some higher priority process (e.g. kTestPid2) owns the resource, so getAllClients_l
// will fail.
@ -667,7 +675,7 @@ protected:
void testGetLowestPriorityBiggestClient() {
MediaResource::Type type = MediaResource::Type::kGraphicMemory;
sp<IResourceManagerClient> client;
std::shared_ptr<IResourceManagerClient> client;
EXPECT_FALSE(mService->getLowestPriorityBiggestClient_l(kHighPriorityPid, type, &client));
addResource();
@ -706,7 +714,7 @@ protected:
void testGetBiggestClient() {
MediaResource::Type type = MediaResource::Type::kGraphicMemory;
sp<IResourceManagerClient> client;
std::shared_ptr<IResourceManagerClient> client;
EXPECT_FALSE(mService->getBiggestClient_l(kTestPid2, type, &client));
addResource();
@ -799,10 +807,10 @@ protected:
}
sp<TestSystemCallback> mSystemCB;
sp<ResourceManagerService> mService;
sp<IResourceManagerClient> mTestClient1;
sp<IResourceManagerClient> mTestClient2;
sp<IResourceManagerClient> mTestClient3;
std::shared_ptr<ResourceManagerService> mService;
std::shared_ptr<IResourceManagerClient> mTestClient1;
std::shared_ptr<IResourceManagerClient> mTestClient2;
std::shared_ptr<IResourceManagerClient> mTestClient3;
};
TEST_F(ResourceManagerServiceTest, config) {
@ -862,5 +870,4 @@ TEST_F(ResourceManagerServiceTest, testCpusetBoost) {
testCpusetBoost();
}
} // namespace media
} // namespace android

Write Preview
Loading…
Cancel
Save