DrmManagerClientImpl.cpp revision 27ed8ad2db653f6ac07dcf8bcc05e2409c8bb024
1/* 2 * Copyright (C) 2010 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17#define LOG_NDEBUG 0 18#define LOG_TAG "DrmManagerClientImpl(Native)" 19#include <utils/Log.h> 20 21#include <utils/String8.h> 22#include <utils/Vector.h> 23#include <binder/IServiceManager.h> 24 25#include "DrmManagerClientImpl.h" 26 27using namespace android; 28 29#define INVALID_VALUE -1 30 31Mutex DrmManagerClientImpl::mMutex; 32Vector<int> DrmManagerClientImpl::mUniqueIdVector; 33sp<IDrmManagerService> DrmManagerClientImpl::mDrmManagerService; 34const String8 DrmManagerClientImpl::EMPTY_STRING(""); 35 36DrmManagerClientImpl* DrmManagerClientImpl::create(int* pUniqueId) { 37 if (0 == *pUniqueId) { 38 int uniqueId = 0; 39 bool foundUniqueId = false; 40 srand(time(NULL)); 41 42 while (!foundUniqueId) { 43 const int size = mUniqueIdVector.size(); 44 uniqueId = rand() % 100; 45 46 int index = 0; 47 for (; index < size; ++index) { 48 if (mUniqueIdVector.itemAt(index) == uniqueId) { 49 foundUniqueId = false; 50 break; 51 } 52 } 53 if (index == size) { 54 foundUniqueId = true; 55 } 56 } 57 *pUniqueId = uniqueId; 58 } 59 mUniqueIdVector.push(*pUniqueId); 60 return new DrmManagerClientImpl(); 61} 62 63void DrmManagerClientImpl::remove(int uniqueId) { 64 for (int i = 0; i < mUniqueIdVector.size(); i++) { 65 if (uniqueId == mUniqueIdVector.itemAt(i)) { 66 mUniqueIdVector.removeAt(i); 67 break; 68 } 69 } 70} 71 72DrmManagerClientImpl::DrmManagerClientImpl() { 73 74} 75 76DrmManagerClientImpl::~DrmManagerClientImpl() { 77 78} 79 80const sp<IDrmManagerService>& DrmManagerClientImpl::getDrmManagerService() { 81 mMutex.lock(); 82 if (NULL == mDrmManagerService.get()) { 83 sp<IServiceManager> sm = defaultServiceManager(); 84 sp<IBinder> binder; 85 do { 86 binder = sm->getService(String16("drm.drmManager")); 87 if (binder != 0) { 88 break; 89 } 90 LOGW("DrmManagerService not published, waiting..."); 91 struct timespec reqt; 92 reqt.tv_sec = 0; 93 reqt.tv_nsec = 500000000; //0.5 sec 94 nanosleep(&reqt, NULL); 95 } while (true); 96 97 mDrmManagerService = interface_cast<IDrmManagerService>(binder); 98 } 99 mMutex.unlock(); 100 return mDrmManagerService; 101} 102 103status_t DrmManagerClientImpl::loadPlugIns(int uniqueId) { 104 return getDrmManagerService()->loadPlugIns(uniqueId); 105} 106 107status_t DrmManagerClientImpl::loadPlugIns(int uniqueId, const String8& plugInDirPath) { 108 status_t status = DRM_ERROR_UNKNOWN; 109 if (EMPTY_STRING != plugInDirPath) { 110 status = getDrmManagerService()->loadPlugIns(uniqueId, plugInDirPath); 111 } 112 return status; 113} 114 115status_t DrmManagerClientImpl::setOnInfoListener( 116 int uniqueId, const sp<DrmManagerClient::OnInfoListener>& infoListener) { 117 Mutex::Autolock _l(mLock); 118 mOnInfoListener = infoListener; 119 return getDrmManagerService()->setDrmServiceListener(uniqueId, this); 120} 121 122status_t DrmManagerClientImpl::unloadPlugIns(int uniqueId) { 123 return getDrmManagerService()->unloadPlugIns(uniqueId); 124} 125 126status_t DrmManagerClientImpl::installDrmEngine(int uniqueId, const String8& drmEngineFile) { 127 status_t status = DRM_ERROR_UNKNOWN; 128 if (EMPTY_STRING != drmEngineFile) { 129 status = getDrmManagerService()->installDrmEngine(uniqueId, drmEngineFile); 130 } 131 return status; 132} 133 134DrmConstraints* DrmManagerClientImpl::getConstraints( 135 int uniqueId, const String8* path, const int action) { 136 DrmConstraints *drmConstraints = NULL; 137 if ((NULL != path) && (EMPTY_STRING != *path)) { 138 drmConstraints = getDrmManagerService()->getConstraints(uniqueId, path, action); 139 } 140 return drmConstraints; 141} 142 143bool DrmManagerClientImpl::canHandle(int uniqueId, const String8& path, const String8& mimeType) { 144 bool retCode = false; 145 if ((EMPTY_STRING != path) || (EMPTY_STRING != mimeType)) { 146 retCode = getDrmManagerService()->canHandle(uniqueId, path, mimeType); 147 } 148 return retCode; 149} 150 151DrmInfoStatus* DrmManagerClientImpl::processDrmInfo(int uniqueId, const DrmInfo* drmInfo) { 152 DrmInfoStatus *drmInfoStatus = NULL; 153 if (NULL != drmInfo) { 154 drmInfoStatus = getDrmManagerService()->processDrmInfo(uniqueId, drmInfo); 155 } 156 return drmInfoStatus; 157} 158 159DrmInfo* DrmManagerClientImpl::acquireDrmInfo(int uniqueId, const DrmInfoRequest* drmInfoRequest) { 160 DrmInfo* drmInfo = NULL; 161 if (NULL != drmInfoRequest) { 162 drmInfo = getDrmManagerService()->acquireDrmInfo(uniqueId, drmInfoRequest); 163 } 164 return drmInfo; 165} 166 167void DrmManagerClientImpl::saveRights(int uniqueId, const DrmRights& drmRights, 168 const String8& rightsPath, const String8& contentPath) { 169 if (EMPTY_STRING != contentPath) { 170 getDrmManagerService()->saveRights(uniqueId, drmRights, rightsPath, contentPath); 171 } 172} 173 174String8 DrmManagerClientImpl::getOriginalMimeType(int uniqueId, const String8& path) { 175 String8 mimeType = EMPTY_STRING; 176 if (EMPTY_STRING != path) { 177 mimeType = getDrmManagerService()->getOriginalMimeType(uniqueId, path); 178 } 179 return mimeType; 180} 181 182int DrmManagerClientImpl::getDrmObjectType( 183 int uniqueId, const String8& path, const String8& mimeType) { 184 int drmOjectType = DrmObjectType::UNKNOWN; 185 if ((EMPTY_STRING != path) || (EMPTY_STRING != mimeType)) { 186 drmOjectType = getDrmManagerService()->getDrmObjectType(uniqueId, path, mimeType); 187 } 188 return drmOjectType; 189} 190 191int DrmManagerClientImpl::checkRightsStatus( 192 int uniqueId, const String8& path, int action) { 193 int rightsStatus = RightsStatus::RIGHTS_INVALID; 194 if (EMPTY_STRING != path) { 195 rightsStatus = getDrmManagerService()->checkRightsStatus(uniqueId, path, action); 196 } 197 return rightsStatus; 198} 199 200void DrmManagerClientImpl::consumeRights( 201 int uniqueId, DecryptHandle* decryptHandle, int action, bool reserve) { 202 if (NULL != decryptHandle) { 203 getDrmManagerService()->consumeRights(uniqueId, decryptHandle, action, reserve); 204 } 205} 206 207void DrmManagerClientImpl::setPlaybackStatus( 208 int uniqueId, DecryptHandle* decryptHandle, int playbackStatus, int position) { 209 if (NULL != decryptHandle) { 210 getDrmManagerService()->setPlaybackStatus( 211 uniqueId, decryptHandle, playbackStatus, position); 212 } 213} 214 215bool DrmManagerClientImpl::validateAction( 216 int uniqueId, const String8& path, int action, const ActionDescription& description) { 217 bool retCode = false; 218 if (EMPTY_STRING != path) { 219 retCode = getDrmManagerService()->validateAction(uniqueId, path, action, description); 220 } 221 return retCode; 222} 223 224void DrmManagerClientImpl::removeRights(int uniqueId, const String8& path) { 225 if (EMPTY_STRING != path) { 226 getDrmManagerService()->removeRights(uniqueId, path); 227 } 228} 229 230void DrmManagerClientImpl::removeAllRights(int uniqueId) { 231 getDrmManagerService()->removeAllRights(uniqueId); 232} 233 234int DrmManagerClientImpl::openConvertSession(int uniqueId, const String8& mimeType) { 235 int retCode = INVALID_VALUE; 236 if (EMPTY_STRING != mimeType) { 237 retCode = getDrmManagerService()->openConvertSession(uniqueId, mimeType); 238 } 239 return retCode; 240} 241 242DrmConvertedStatus* DrmManagerClientImpl::convertData( 243 int uniqueId, int convertId, const DrmBuffer* inputData) { 244 DrmConvertedStatus* drmConvertedStatus = NULL; 245 if (NULL != inputData) { 246 drmConvertedStatus = getDrmManagerService()->convertData(uniqueId, convertId, inputData); 247 } 248 return drmConvertedStatus; 249} 250 251DrmConvertedStatus* DrmManagerClientImpl::closeConvertSession(int uniqueId, int convertId) { 252 return getDrmManagerService()->closeConvertSession(uniqueId, convertId); 253} 254 255status_t DrmManagerClientImpl::getAllSupportInfo( 256 int uniqueId, int* length, DrmSupportInfo** drmSupportInfoArray) { 257 status_t status = DRM_ERROR_UNKNOWN; 258 if ((NULL != drmSupportInfoArray) && (NULL != length)) { 259 status = getDrmManagerService()->getAllSupportInfo(uniqueId, length, drmSupportInfoArray); 260 } 261 return status; 262} 263 264DecryptHandle* DrmManagerClientImpl::openDecryptSession( 265 int uniqueId, int fd, int offset, int length) { 266 LOGV("Entering DrmManagerClientImpl::openDecryptSession"); 267 return getDrmManagerService()->openDecryptSession(uniqueId, fd, offset, length); 268} 269 270void DrmManagerClientImpl::closeDecryptSession(int uniqueId, DecryptHandle* decryptHandle) { 271 if (NULL != decryptHandle) { 272 getDrmManagerService()->closeDecryptSession( uniqueId, decryptHandle); 273 } 274} 275 276void DrmManagerClientImpl::initializeDecryptUnit(int uniqueId, DecryptHandle* decryptHandle, 277 int decryptUnitId, const DrmBuffer* headerInfo) { 278 if ((NULL != decryptHandle) && (NULL != headerInfo)) { 279 getDrmManagerService()->initializeDecryptUnit( 280 uniqueId, decryptHandle, decryptUnitId, headerInfo); 281 } 282} 283 284status_t DrmManagerClientImpl::decrypt(int uniqueId, DecryptHandle* decryptHandle, 285 int decryptUnitId, const DrmBuffer* encBuffer, DrmBuffer** decBuffer) { 286 status_t status = DRM_ERROR_UNKNOWN; 287 if ((NULL != decryptHandle) && (NULL != encBuffer) 288 && (NULL != decBuffer) && (NULL != *decBuffer)) { 289 status = getDrmManagerService()->decrypt( 290 uniqueId, decryptHandle, decryptUnitId, encBuffer, decBuffer); 291 } 292 return status; 293} 294 295void DrmManagerClientImpl::finalizeDecryptUnit( 296 int uniqueId, DecryptHandle* decryptHandle, int decryptUnitId) { 297 if (NULL != decryptHandle) { 298 getDrmManagerService()->finalizeDecryptUnit(uniqueId, decryptHandle, decryptUnitId); 299 } 300} 301 302ssize_t DrmManagerClientImpl::pread(int uniqueId, DecryptHandle* decryptHandle, 303 void* buffer, ssize_t numBytes, off_t offset) { 304 ssize_t retCode = INVALID_VALUE; 305 if ((NULL != decryptHandle) && (NULL != buffer) && (0 < numBytes)) { 306 retCode = getDrmManagerService()->pread(uniqueId, decryptHandle, buffer, numBytes, offset); 307 } 308 return retCode; 309} 310 311status_t DrmManagerClientImpl::notify(const DrmInfoEvent& event) { 312 if (NULL != mOnInfoListener.get()) { 313 Mutex::Autolock _l(mLock); 314 sp<DrmManagerClient::OnInfoListener> listener = mOnInfoListener; 315 listener->onInfo(event); 316 } 317 return DRM_NO_ERROR; 318} 319 320