DrmManagerClientImpl.cpp revision b5ce361d19e69fe156f7188c9ee0f4734b259874
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; 32sp<IDrmManagerService> DrmManagerClientImpl::mDrmManagerService; 33const String8 DrmManagerClientImpl::EMPTY_STRING(""); 34 35DrmManagerClientImpl* DrmManagerClientImpl::create(int* pUniqueId) { 36 if (0 == *pUniqueId) { 37 int uniqueId = getDrmManagerService()->addUniqueId(*pUniqueId); 38 *pUniqueId = uniqueId; 39 } else { 40 getDrmManagerService()->addUniqueId(*pUniqueId); 41 } 42 return new DrmManagerClientImpl(); 43} 44 45void DrmManagerClientImpl::remove(int uniqueId) { 46 getDrmManagerService()->removeUniqueId(uniqueId); 47} 48 49const sp<IDrmManagerService>& DrmManagerClientImpl::getDrmManagerService() { 50 mMutex.lock(); 51 if (NULL == mDrmManagerService.get()) { 52 sp<IServiceManager> sm = defaultServiceManager(); 53 sp<IBinder> binder; 54 do { 55 binder = sm->getService(String16("drm.drmManager")); 56 if (binder != 0) { 57 break; 58 } 59 LOGW("DrmManagerService not published, waiting..."); 60 struct timespec reqt; 61 reqt.tv_sec = 0; 62 reqt.tv_nsec = 500000000; //0.5 sec 63 nanosleep(&reqt, NULL); 64 } while (true); 65 66 mDrmManagerService = interface_cast<IDrmManagerService>(binder); 67 } 68 mMutex.unlock(); 69 return mDrmManagerService; 70} 71 72void DrmManagerClientImpl::addClient(int uniqueId) { 73 getDrmManagerService()->addClient(uniqueId); 74} 75 76void DrmManagerClientImpl::removeClient(int uniqueId) { 77 getDrmManagerService()->removeClient(uniqueId); 78} 79 80status_t DrmManagerClientImpl::setOnInfoListener( 81 int uniqueId, 82 const sp<DrmManagerClient::OnInfoListener>& infoListener) { 83 Mutex::Autolock _l(mLock); 84 mOnInfoListener = infoListener; 85 return getDrmManagerService()->setDrmServiceListener(uniqueId, 86 (NULL != infoListener.get()) ? this : NULL); 87} 88 89status_t DrmManagerClientImpl::installDrmEngine( 90 int uniqueId, const String8& drmEngineFile) { 91 status_t status = DRM_ERROR_UNKNOWN; 92 if (EMPTY_STRING != drmEngineFile) { 93 status = getDrmManagerService()->installDrmEngine(uniqueId, drmEngineFile); 94 } 95 return status; 96} 97 98DrmConstraints* DrmManagerClientImpl::getConstraints( 99 int uniqueId, const String8* path, const int action) { 100 DrmConstraints *drmConstraints = NULL; 101 if ((NULL != path) && (EMPTY_STRING != *path)) { 102 drmConstraints = 103 getDrmManagerService()->getConstraints(uniqueId, path, action); 104 } 105 return drmConstraints; 106} 107 108DrmMetadata* DrmManagerClientImpl::getMetadata(int uniqueId, const String8* path) { 109 DrmMetadata *drmMetadata = NULL; 110 if ((NULL != path) && (EMPTY_STRING != *path)) { 111 drmMetadata = getDrmManagerService()->getMetadata(uniqueId, path); 112 } 113 return drmMetadata; 114} 115 116bool DrmManagerClientImpl::canHandle( 117 int uniqueId, const String8& path, const String8& mimeType) { 118 bool retCode = false; 119 if ((EMPTY_STRING != path) || (EMPTY_STRING != mimeType)) { 120 retCode = getDrmManagerService()->canHandle(uniqueId, path, mimeType); 121 } 122 return retCode; 123} 124 125DrmInfoStatus* DrmManagerClientImpl::processDrmInfo( 126 int uniqueId, const DrmInfo* drmInfo) { 127 DrmInfoStatus *drmInfoStatus = NULL; 128 if (NULL != drmInfo) { 129 drmInfoStatus = getDrmManagerService()->processDrmInfo(uniqueId, drmInfo); 130 } 131 return drmInfoStatus; 132} 133 134DrmInfo* DrmManagerClientImpl::acquireDrmInfo( 135 int uniqueId, const DrmInfoRequest* drmInfoRequest) { 136 DrmInfo* drmInfo = NULL; 137 if (NULL != drmInfoRequest) { 138 drmInfo = getDrmManagerService()->acquireDrmInfo(uniqueId, drmInfoRequest); 139 } 140 return drmInfo; 141} 142 143status_t DrmManagerClientImpl::saveRights(int uniqueId, const DrmRights& drmRights, 144 const String8& rightsPath, const String8& contentPath) { 145 status_t status = DRM_ERROR_UNKNOWN; 146 if (EMPTY_STRING != contentPath) { 147 status = getDrmManagerService()->saveRights( 148 uniqueId, drmRights, rightsPath, contentPath); 149 } 150 return status; 151} 152 153String8 DrmManagerClientImpl::getOriginalMimeType( 154 int uniqueId, const String8& path) { 155 String8 mimeType = EMPTY_STRING; 156 if (EMPTY_STRING != path) { 157 mimeType = getDrmManagerService()->getOriginalMimeType(uniqueId, path); 158 } 159 return mimeType; 160} 161 162int DrmManagerClientImpl::getDrmObjectType( 163 int uniqueId, const String8& path, const String8& mimeType) { 164 int drmOjectType = DrmObjectType::UNKNOWN; 165 if ((EMPTY_STRING != path) || (EMPTY_STRING != mimeType)) { 166 drmOjectType = 167 getDrmManagerService()->getDrmObjectType(uniqueId, path, mimeType); 168 } 169 return drmOjectType; 170} 171 172int DrmManagerClientImpl::checkRightsStatus( 173 int uniqueId, const String8& path, int action) { 174 int rightsStatus = RightsStatus::RIGHTS_INVALID; 175 if (EMPTY_STRING != path) { 176 rightsStatus = 177 getDrmManagerService()->checkRightsStatus(uniqueId, path, action); 178 } 179 return rightsStatus; 180} 181 182status_t DrmManagerClientImpl::consumeRights( 183 int uniqueId, sp<DecryptHandle> &decryptHandle, 184 int action, bool reserve) { 185 status_t status = DRM_ERROR_UNKNOWN; 186 if (NULL != decryptHandle.get()) { 187 status = getDrmManagerService()->consumeRights( 188 uniqueId, decryptHandle.get(), action, reserve); 189 } 190 return status; 191} 192 193status_t DrmManagerClientImpl::setPlaybackStatus( 194 int uniqueId, sp<DecryptHandle> &decryptHandle, 195 int playbackStatus, int64_t position) { 196 status_t status = DRM_ERROR_UNKNOWN; 197 if (NULL != decryptHandle.get()) { 198 status = getDrmManagerService()->setPlaybackStatus( 199 uniqueId, decryptHandle.get(), playbackStatus, position); 200 } 201 return status; 202} 203 204bool DrmManagerClientImpl::validateAction( 205 int uniqueId, const String8& path, 206 int action, const ActionDescription& description) { 207 bool retCode = false; 208 if (EMPTY_STRING != path) { 209 retCode = getDrmManagerService()->validateAction( 210 uniqueId, path, action, description); 211 } 212 return retCode; 213} 214 215status_t DrmManagerClientImpl::removeRights(int uniqueId, const String8& path) { 216 status_t status = DRM_ERROR_UNKNOWN; 217 if (EMPTY_STRING != path) { 218 status = getDrmManagerService()->removeRights(uniqueId, path); 219 } 220 return status; 221} 222 223status_t DrmManagerClientImpl::removeAllRights(int uniqueId) { 224 return getDrmManagerService()->removeAllRights(uniqueId); 225} 226 227int DrmManagerClientImpl::openConvertSession( 228 int uniqueId, const String8& mimeType) { 229 int retCode = INVALID_VALUE; 230 if (EMPTY_STRING != mimeType) { 231 retCode = getDrmManagerService()->openConvertSession(uniqueId, mimeType); 232 } 233 return retCode; 234} 235 236DrmConvertedStatus* DrmManagerClientImpl::convertData( 237 int uniqueId, int convertId, const DrmBuffer* inputData) { 238 DrmConvertedStatus* drmConvertedStatus = NULL; 239 if (NULL != inputData) { 240 drmConvertedStatus = 241 getDrmManagerService()->convertData(uniqueId, convertId, inputData); 242 } 243 return drmConvertedStatus; 244} 245 246DrmConvertedStatus* DrmManagerClientImpl::closeConvertSession( 247 int uniqueId, int convertId) { 248 return getDrmManagerService()->closeConvertSession(uniqueId, convertId); 249} 250 251status_t DrmManagerClientImpl::getAllSupportInfo( 252 int uniqueId, int* length, DrmSupportInfo** drmSupportInfoArray) { 253 status_t status = DRM_ERROR_UNKNOWN; 254 if ((NULL != drmSupportInfoArray) && (NULL != length)) { 255 status = getDrmManagerService()->getAllSupportInfo( 256 uniqueId, length, drmSupportInfoArray); 257 } 258 return status; 259} 260 261sp<DecryptHandle> DrmManagerClientImpl::openDecryptSession( 262 int uniqueId, int fd, off64_t offset, off64_t length) { 263 return getDrmManagerService()->openDecryptSession(uniqueId, fd, offset, length); 264} 265 266sp<DecryptHandle> DrmManagerClientImpl::openDecryptSession( 267 int uniqueId, const char* uri) { 268 DecryptHandle* handle = NULL; 269 if (NULL != uri) { 270 handle = getDrmManagerService()->openDecryptSession(uniqueId, uri); 271 } 272 return handle; 273} 274 275status_t DrmManagerClientImpl::closeDecryptSession( 276 int uniqueId, sp<DecryptHandle> &decryptHandle) { 277 status_t status = DRM_ERROR_UNKNOWN; 278 if (NULL != decryptHandle.get()) { 279 status = getDrmManagerService()->closeDecryptSession( 280 uniqueId, decryptHandle.get()); 281 } 282 return status; 283} 284 285status_t DrmManagerClientImpl::initializeDecryptUnit( 286 int uniqueId, sp<DecryptHandle> &decryptHandle, 287 int decryptUnitId, const DrmBuffer* headerInfo) { 288 status_t status = DRM_ERROR_UNKNOWN; 289 if ((NULL != decryptHandle.get()) && (NULL != headerInfo)) { 290 status = getDrmManagerService()->initializeDecryptUnit( 291 uniqueId, decryptHandle.get(), decryptUnitId, headerInfo); 292 } 293 return status; 294} 295 296status_t DrmManagerClientImpl::decrypt( 297 int uniqueId, sp<DecryptHandle> &decryptHandle, 298 int decryptUnitId, const DrmBuffer* encBuffer, 299 DrmBuffer** decBuffer, DrmBuffer* IV) { 300 status_t status = DRM_ERROR_UNKNOWN; 301 if ((NULL != decryptHandle.get()) && (NULL != encBuffer) 302 && (NULL != decBuffer) && (NULL != *decBuffer)) { 303 status = getDrmManagerService()->decrypt( 304 uniqueId, decryptHandle.get(), decryptUnitId, 305 encBuffer, decBuffer, IV); 306 } 307 return status; 308} 309 310status_t DrmManagerClientImpl::finalizeDecryptUnit( 311 int uniqueId, sp<DecryptHandle> &decryptHandle, int decryptUnitId) { 312 status_t status = DRM_ERROR_UNKNOWN; 313 if (NULL != decryptHandle.get()) { 314 status = getDrmManagerService()->finalizeDecryptUnit( 315 uniqueId, decryptHandle.get(), decryptUnitId); 316 } 317 return status; 318} 319 320ssize_t DrmManagerClientImpl::pread(int uniqueId, sp<DecryptHandle> &decryptHandle, 321 void* buffer, ssize_t numBytes, off64_t offset) { 322 ssize_t retCode = INVALID_VALUE; 323 if ((NULL != decryptHandle.get()) && (NULL != buffer) && (0 < numBytes)) { 324 retCode = getDrmManagerService()->pread( 325 uniqueId, decryptHandle.get(), buffer, numBytes, offset); 326 } 327 return retCode; 328} 329 330status_t DrmManagerClientImpl::notify(const DrmInfoEvent& event) { 331 if (NULL != mOnInfoListener.get()) { 332 Mutex::Autolock _l(mLock); 333 sp<DrmManagerClient::OnInfoListener> listener = mOnInfoListener; 334 listener->onInfo(event); 335 } 336 return DRM_NO_ERROR; 337} 338 339