blob: 02270d087c68f0231a3f7ffd1c02c8145a59a449 [file] [log] [blame]
/*
* Copyright (C) 2015 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
//#define LOG_NDEBUG 0
#define LOG_TAG "DrmSessionManager"
#include <utils/Log.h>
#include <binder/IPCThreadState.h>
#include <binder/IProcessInfoService.h>
#include <binder/IServiceManager.h>
#include <media/DrmSessionManager.h>
#include <media/DrmSessionClientInterface.h>
#include <media/stagefright/ProcessInfo.h>
#include <unistd.h>
#include <utils/String8.h>
namespace android {
static String8 GetSessionIdString(const Vector<uint8_t> &sessionId) {
String8 sessionIdStr;
for (size_t i = 0; i < sessionId.size(); ++i) {
sessionIdStr.appendFormat("%u ", sessionId[i]);
}
return sessionIdStr;
}
bool isEqualSessionId(const Vector<uint8_t> &sessionId1, const Vector<uint8_t> &sessionId2) {
if (sessionId1.size() != sessionId2.size()) {
return false;
}
for (size_t i = 0; i < sessionId1.size(); ++i) {
if (sessionId1[i] != sessionId2[i]) {
return false;
}
}
return true;
}
sp<DrmSessionManager> DrmSessionManager::Instance() {
static sp<DrmSessionManager> drmSessionManager = new DrmSessionManager();
return drmSessionManager;
}
DrmSessionManager::DrmSessionManager()
: mProcessInfo(new ProcessInfo()),
mTime(0) {}
DrmSessionManager::DrmSessionManager(sp<ProcessInfoInterface> processInfo)
: mProcessInfo(processInfo),
mTime(0) {}
DrmSessionManager::~DrmSessionManager() {}
void DrmSessionManager::addSession(
int pid, const sp<DrmSessionClientInterface>& drm, const Vector<uint8_t> &sessionId) {
ALOGV("addSession(pid %d, drm %p, sessionId %s)", pid, drm.get(),
GetSessionIdString(sessionId).string());
Mutex::Autolock lock(mLock);
SessionInfo info;
info.drm = drm;
info.sessionId = sessionId;
info.timeStamp = getTime_l();
ssize_t index = mSessionMap.indexOfKey(pid);
if (index < 0) {
// new pid
SessionInfos infosForPid;
infosForPid.push_back(info);
mSessionMap.add(pid, infosForPid);
} else {
mSessionMap.editValueAt(index).push_back(info);
}
}
void DrmSessionManager::useSession(const Vector<uint8_t> &sessionId) {
ALOGV("useSession(%s)", GetSessionIdString(sessionId).string());
Mutex::Autolock lock(mLock);
for (size_t i = 0; i < mSessionMap.size(); ++i) {
SessionInfos& infos = mSessionMap.editValueAt(i);
for (size_t j = 0; j < infos.size(); ++j) {
SessionInfo& info = infos.editItemAt(j);
if (isEqualSessionId(sessionId, info.sessionId)) {
info.timeStamp = getTime_l();
return;
}
}
}
}
void DrmSessionManager::removeSession(const Vector<uint8_t> &sessionId) {
ALOGV("removeSession(%s)", GetSessionIdString(sessionId).string());
Mutex::Autolock lock(mLock);
for (size_t i = 0; i < mSessionMap.size(); ++i) {
SessionInfos& infos = mSessionMap.editValueAt(i);
for (size_t j = 0; j < infos.size(); ++j) {
if (isEqualSessionId(sessionId, infos[j].sessionId)) {
infos.removeAt(j);
return;
}
}
}
}
void DrmSessionManager::removeDrm(const sp<DrmSessionClientInterface>& drm) {
ALOGV("removeDrm(%p)", drm.get());
Mutex::Autolock lock(mLock);
bool found = false;
for (size_t i = 0; i < mSessionMap.size(); ++i) {
SessionInfos& infos = mSessionMap.editValueAt(i);
for (size_t j = 0; j < infos.size();) {
if (infos[j].drm == drm) {
ALOGV("removed session (%s)", GetSessionIdString(infos[j].sessionId).string());
j = infos.removeAt(j);
found = true;
} else {
++j;
}
}
if (found) {
break;
}
}
}
bool DrmSessionManager::reclaimSession(int callingPid) {
ALOGV("reclaimSession(%d)", callingPid);
sp<DrmSessionClientInterface> drm;
Vector<uint8_t> sessionId;
int lowestPriorityPid;
int lowestPriority;
{
Mutex::Autolock lock(mLock);
int callingPriority;
if (!mProcessInfo->getPriority(callingPid, &callingPriority)) {
return false;
}
if (!getLowestPriority_l(&lowestPriorityPid, &lowestPriority)) {
return false;
}
if (lowestPriority <= callingPriority) {
return false;
}
if (!getLeastUsedSession_l(lowestPriorityPid, &drm, &sessionId)) {
return false;
}
}
if (drm == NULL) {
return false;
}
ALOGV("reclaim session(%s) opened by pid %d",
GetSessionIdString(sessionId).string(), lowestPriorityPid);
return drm->reclaimSession(sessionId);
}
int64_t DrmSessionManager::getTime_l() {
return mTime++;
}
bool DrmSessionManager::getLowestPriority_l(int* lowestPriorityPid, int* lowestPriority) {
int pid = -1;
int priority = -1;
for (size_t i = 0; i < mSessionMap.size(); ++i) {
if (mSessionMap.valueAt(i).size() == 0) {
// no opened session by this process.
continue;
}
int tempPid = mSessionMap.keyAt(i);
int tempPriority;
if (!mProcessInfo->getPriority(tempPid, &tempPriority)) {
// shouldn't happen.
return false;
}
if (pid == -1) {
pid = tempPid;
priority = tempPriority;
} else {
if (tempPriority > priority) {
pid = tempPid;
priority = tempPriority;
}
}
}
if (pid != -1) {
*lowestPriorityPid = pid;
*lowestPriority = priority;
}
return (pid != -1);
}
bool DrmSessionManager::getLeastUsedSession_l(
int pid, sp<DrmSessionClientInterface>* drm, Vector<uint8_t>* sessionId) {
ssize_t index = mSessionMap.indexOfKey(pid);
if (index < 0) {
return false;
}
int leastUsedIndex = -1;
int64_t minTs = LLONG_MAX;
const SessionInfos& infos = mSessionMap.valueAt(index);
for (size_t j = 0; j < infos.size(); ++j) {
if (leastUsedIndex == -1) {
leastUsedIndex = j;
minTs = infos[j].timeStamp;
} else {
if (infos[j].timeStamp < minTs) {
leastUsedIndex = j;
minTs = infos[j].timeStamp;
}
}
}
if (leastUsedIndex != -1) {
*drm = infos[leastUsedIndex].drm;
*sessionId = infos[leastUsedIndex].sessionId;
}
return (leastUsedIndex != -1);
}
} // namespace android