fuquan/allwinner_a64
1
1
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

upload android base code part1

Browse source
This commit is contained in:
August 2018-08-08 15:50:00 +08:00
parent e02f198e2d
commit 0a1de6c4b3
48159 changed files with 9071466 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

183
android/frameworks/av/include/drm/DrmConstraints.h Normal file
View file

@ -0,0 +1,183 @@
/*
* Copyright (C) 2010 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.
*/
#ifndef __DRM_CONSTRAINTS_H__
#define __DRM_CONSTRAINTS_H__
#include "drm_framework_common.h"
namespace android {
/**
* This is an utility class which contains the constraints information.
*
* As a result of DrmManagerClient::getConstraints(const String8*, const int)
* an instance of DrmConstraints would be returned.
*
*/
class DrmConstraints {
public:
/**
* The following variables are replica of android.drm.DrmStore.ConstraintsColumns
* Any changes should also be incorporated with Java Layer as well
*/
/**
* The max repeat count
*/
static const String8 MAX_REPEAT_COUNT;
/**
* The remaining repeat count
*/
static const String8 REMAINING_REPEAT_COUNT;
/**
* The time before which the protected file can not be played/viewed
*/
static const String8 LICENSE_START_TIME;
/**
* The time after which the protected file can not be played/viewed
*/
static const String8 LICENSE_EXPIRY_TIME;
/**
* The available time for license
*/
static const String8 LICENSE_AVAILABLE_TIME;
/**
* The data stream for extended metadata
*/
static const String8 EXTENDED_METADATA;
public:
/**
* Iterator for key
*/
class KeyIterator {
friend class DrmConstraints;
private:
explicit KeyIterator(DrmConstraints* drmConstraints)
: mDrmConstraints(drmConstraints), mIndex(0) {}
public:
KeyIterator(const KeyIterator& keyIterator);
KeyIterator& operator=(const KeyIterator& keyIterator);
virtual ~KeyIterator() {}
public:
bool hasNext();
const String8& next();
private:
DrmConstraints* mDrmConstraints;
unsigned int mIndex;
};
/**
* Iterator for constraints
*/
class Iterator {
friend class DrmConstraints;
private:
explicit Iterator(DrmConstraints* drmConstraints)
: mDrmConstraints(drmConstraints), mIndex(0) {}
public:
Iterator(const Iterator& iterator);
Iterator& operator=(const Iterator& iterator);
virtual ~Iterator() {}
public:
bool hasNext();
String8 next();
private:
DrmConstraints* mDrmConstraints;
unsigned int mIndex;
};
public:
DrmConstraints() {}
virtual ~DrmConstraints() {
DrmConstraints::KeyIterator keyIt = this->keyIterator();
while (keyIt.hasNext()) {
String8 key = keyIt.next();
const char* value = this->getAsByteArray(&key);
if (NULL != value) {
delete[] value;
value = NULL;
}
}
mConstraintMap.clear();
}
public:
/**
* Returns the number of constraints contained in this instance
*
* @return Number of constraints
*/
int getCount(void) const;
/**
* Adds constraint information as <key, value> pair to this instance
*
* @param[in] key Key to add
* @param[in] value Value to add
* @return Returns DRM_NO_ERROR for success, DRM_ERROR_UNKNOWN for failure
*/
status_t put(const String8* key, const char* value);
/**
* Retrieves the value of given key
*
* @param key Key whose value to be retrieved
* @return The value
*/
String8 get(const String8& key) const;
/**
* Retrieves the value as byte array of given key
* @param key Key whose value to be retrieved as byte array
* @return The byte array value
*/
const char* getAsByteArray(const String8* key) const;
/**
* Returns KeyIterator object to walk through the keys associated with this instance
*
* @return KeyIterator object
*/
KeyIterator keyIterator();
/**
* Returns Iterator object to walk through the values associated with this instance
*
* @return Iterator object
*/
Iterator iterator();
private:
const char* getValue(const String8* key) const;
private:
typedef KeyedVector<String8, const char*> DrmConstraintsMap;
DrmConstraintsMap mConstraintMap;
};
};
#endif /* __DRM_CONSTRAINTS_H__ */

67
android/frameworks/av/include/drm/DrmConvertedStatus.h Normal file
View file

@ -0,0 +1,67 @@
/*
* Copyright (C) 2010 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.
*/
#ifndef __DRM_CONVERTED_STATUS_H__
#define __DRM_CONVERTED_STATUS_H__
#include "drm_framework_common.h"
namespace android {
/**
* This is an utility class which wraps the status of the conversion, the converted
* data/checksum data and the offset. Offset is going to be used in the case of close
* session where the agent will inform where the header and body signature should be added
*
* As a result of DrmManagerClient::convertData(int, const DrmBuffer*) and
* DrmManagerClient::closeConvertSession(int) an instance of DrmConvertedStatus
* would be returned.
*
*/
class DrmConvertedStatus {
public:
// Should be in sync with DrmConvertedStatus.java
static const int STATUS_OK = 1;
static const int STATUS_INPUTDATA_ERROR = 2;
static const int STATUS_ERROR = 3;
public:
/**
* Constructor for DrmConvertedStatus
*
* @param[in] _statusCode Status of the conversion
* @param[in] _convertedData Converted data/checksum data
* @param[in] _offset Offset value
*/
DrmConvertedStatus(int _statusCode, const DrmBuffer* _convertedData, int _offset);
/**
* Destructor for DrmConvertedStatus
*/
virtual ~DrmConvertedStatus() {
}
public:
int statusCode;
const DrmBuffer* convertedData;
int offset;
};
};
#endif /* __DRM_CONVERTED_STATUS_H__ */

176
android/frameworks/av/include/drm/DrmInfo.h Normal file
View file

@ -0,0 +1,176 @@
/*
* Copyright (C) 2010 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.
*/
#ifndef __DRM_INFO_H__
#define __DRM_INFO_H__
#include "drm_framework_common.h"
namespace android {
/**
* This is an utility class in which necessary information required to transact
* between device and online DRM server is described. DRM Framework achieves
* server registration, license acquisition and any other server related transaction
* by passing an instance of this class to DrmManagerClient::processDrmInfo(const DrmInfo*).
*
* The Caller can retrieve the DrmInfo instance by using
* DrmManagerClient::acquireDrmInfo(const DrmInfoRequest*) by passing DrmInfoRequest instance.
*
*/
class DrmInfo {
public:
/**
* Constructor for DrmInfo
*
* @param[in] infoType Type of information
* @param[in] drmBuffer Trigger data
* @param[in] mimeType MIME type
*/
DrmInfo(int infoType, const DrmBuffer& drmBuffer, const String8& mimeType);
/**
* Destructor for DrmInfo
*/
virtual ~DrmInfo() {}
public:
/**
* Iterator for key
*/
class KeyIterator {
friend class DrmInfo;
private:
explicit KeyIterator(const DrmInfo* drmInfo)
: mDrmInfo(const_cast <DrmInfo*> (drmInfo)), mIndex(0) {}
public:
KeyIterator(const KeyIterator& keyIterator);
KeyIterator& operator=(const KeyIterator& keyIterator);
virtual ~KeyIterator() {}
public:
bool hasNext();
const String8& next();
private:
DrmInfo* mDrmInfo;
unsigned int mIndex;
};
/**
* Iterator
*/
class Iterator {
friend class DrmInfo;
private:
explicit Iterator(const DrmInfo* drmInfo)
: mDrmInfo(const_cast <DrmInfo*> (drmInfo)), mIndex(0) {}
public:
Iterator(const Iterator& iterator);
Iterator& operator=(const Iterator& iterator);
virtual ~Iterator() {}
public:
bool hasNext();
String8& next();
private:
DrmInfo* mDrmInfo;
unsigned int mIndex;
};
public:
/**
* Returns information type associated with this instance
*
* @return Information type
*/
int getInfoType(void) const;
/**
* Returns MIME type associated with this instance
*
* @return MIME type
*/
String8 getMimeType(void) const;
/**
* Returns the trigger data associated with this instance
*
* @return Trigger data
*/
const DrmBuffer& getData(void) const;
/**
* Returns the number of attributes contained in this instance
*
* @return Number of attributes
*/
int getCount(void) const;
/**
* Adds optional information as <key, value> pair to this instance
*
* @param[in] key Key to add
* @param[in] value Value to add
* @return Returns the error code
*/
status_t put(const String8& key, const String8& value);
/**
* Retrieves the value of given key
*
* @param key Key whose value to be retrieved
* @return The value
*/
String8 get(const String8& key) const;
/**
* Returns KeyIterator object to walk through the keys associated with this instance
*
* @return KeyIterator object
*/
KeyIterator keyIterator() const;
/**
* Returns Iterator object to walk through the values associated with this instance
*
* @return Iterator object
*/
Iterator iterator() const;
/**
* Returns index of the given key
*
* @return index
*/
int indexOfKey(const String8& key) const;
protected:
int mInfoType;
DrmBuffer mData;
String8 mMimeType;
KeyedVector<String8, String8> mAttributes;
};
};
#endif /* __DRM_INFO_H__ */

118
android/frameworks/av/include/drm/DrmInfoEvent.h Normal file
View file

@ -0,0 +1,118 @@
/*
* Copyright (C) 2010 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.
*/
#ifndef __DRM_INFO_EVENT_H__
#define __DRM_INFO_EVENT_H__
namespace android {
class String8;
/**
* This is an entity class which would be passed to caller in
* DrmManagerClient::OnInfoListener::onInfo(const DrmInfoEvent&).
*/
class DrmInfoEvent {
public:
/**
* The following constant values should be in sync with DrmInfoEvent.java
*/
//! TYPE_ALREADY_REGISTERED_BY_ANOTHER_ACCOUNT, when registration has been
//! already done by another account ID.
static const int TYPE_ALREADY_REGISTERED_BY_ANOTHER_ACCOUNT = 1;
//! TYPE_REMOVE_RIGHTS, when the rights needs to be removed completely.
static const int TYPE_REMOVE_RIGHTS = 2;
//! TYPE_RIGHTS_INSTALLED, when the rights are downloaded and installed ok.
static const int TYPE_RIGHTS_INSTALLED = 3;
//! TYPE_WAIT_FOR_RIGHTS, rights object is on it's way to phone,
//! wait before calling checkRights again
static const int TYPE_WAIT_FOR_RIGHTS = 4;
//! TYPE_ACCOUNT_ALREADY_REGISTERED, when registration has been
//! already done for the given account.
static const int TYPE_ACCOUNT_ALREADY_REGISTERED = 5;
//! TYPE_RIGHTS_REMOVED, when the rights has been removed.
static const int TYPE_RIGHTS_REMOVED = 6;
/**
* The following constant values should be in sync with DrmErrorEvent.java
*/
//! TYPE_RIGHTS_NOT_INSTALLED, when something went wrong installing the rights
static const int TYPE_RIGHTS_NOT_INSTALLED = 2001;
//! TYPE_RIGHTS_RENEWAL_NOT_ALLOWED, when the server rejects renewal of rights
static const int TYPE_RIGHTS_RENEWAL_NOT_ALLOWED = 2002;
//! TYPE_NOT_SUPPORTED, when answer from server can not be handled by the native agent
static const int TYPE_NOT_SUPPORTED = 2003;
//! TYPE_OUT_OF_MEMORY, when memory allocation fail during renewal.
//! Can in the future perhaps be used to trigger garbage collector
static const int TYPE_OUT_OF_MEMORY = 2004;
//! TYPE_NO_INTERNET_CONNECTION, when the Internet connection is missing and no attempt
//! can be made to renew rights
static const int TYPE_NO_INTERNET_CONNECTION = 2005;
//! TYPE_PROCESS_DRM_INFO_FAILED, when failed to process DrmInfo.
static const int TYPE_PROCESS_DRM_INFO_FAILED = 2006;
//! TYPE_REMOVE_ALL_RIGHTS_FAILED, when failed to remove all the rights objects
//! associated with all DRM schemes.
static const int TYPE_REMOVE_ALL_RIGHTS_FAILED = 2007;
//! TYPE_ACQUIRE_DRM_INFO_FAILED, when failed to acquire DrmInfo.
static const int TYPE_ACQUIRE_DRM_INFO_FAILED = 2008;
public:
/**
* Constructor for DrmInfoEvent
*
* @param[in] uniqueId Unique session identifier
* @param[in] infoType Type of information
* @param[in] message Message description
*/
DrmInfoEvent(int uniqueId, int infoType, const String8& message);
/**
* Destructor for DrmInfoEvent
*/
virtual ~DrmInfoEvent() {}
public:
/**
* Returns the Unique Id associated with this instance
*
* @return Unique Id
*/
int getUniqueId() const;
/**
* Returns the Type of information associated with this object
*
* @return Type of information
*/
int getType() const;
/**
* Returns the message description associated with this object
*
* @return Message description
*/
const String8 getMessage() const;
private:
int mUniqueId;
int mInfoType;
const String8 mMessage;
};
};
#endif /* __DRM_INFO_EVENT_H__ */

177
android/frameworks/av/include/drm/DrmInfoRequest.h Normal file
View file

@ -0,0 +1,177 @@
/*
* Copyright (C) 2010 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.
*/
#ifndef __DRM_INFO_REQUEST_H__
#define __DRM_INFO_REQUEST_H__
#include "drm_framework_common.h"
namespace android {
/**
* This is an utility class used to pass required parameters to get
* the necessary information to communicate with online DRM server
*
* An instance of this class is passed to
* DrmManagerClient::acquireDrmInfo(const DrmInfoRequest*) to get the
* instance of DrmInfo.
*
*/
class DrmInfoRequest {
public:
// Changes in following constants should be in sync with DrmInfoRequest.java
static const int TYPE_REGISTRATION_INFO = 1;
static const int TYPE_UNREGISTRATION_INFO = 2;
static const int TYPE_RIGHTS_ACQUISITION_INFO = 3;
static const int TYPE_RIGHTS_ACQUISITION_PROGRESS_INFO = 4;
/**
* Key to pass the unique id for the account or the user
*/
static const String8 ACCOUNT_ID;
/**
* Key to pass the subscription id
*/
static const String8 SUBSCRIPTION_ID;
public:
/**
* Constructor for DrmInfoRequest
*
* @param[in] infoType Type of information
* @param[in] mimeType MIME type
*/
DrmInfoRequest(int infoType, const String8& mimeType);
/**
* Destructor for DrmInfoRequest
*/
virtual ~DrmInfoRequest() {}
public:
/**
* Iterator for key
*/
class KeyIterator {
friend class DrmInfoRequest;
private:
explicit KeyIterator(const DrmInfoRequest* drmInfoRequest)
: mDrmInfoRequest(const_cast <DrmInfoRequest*> (drmInfoRequest)), mIndex(0) {}
public:
KeyIterator(const KeyIterator& keyIterator);
KeyIterator& operator=(const KeyIterator& keyIterator);
virtual ~KeyIterator() {}
public:
bool hasNext();
const String8& next();
private:
DrmInfoRequest* mDrmInfoRequest;
unsigned int mIndex;
};
/**
* Iterator
*/
class Iterator {
friend class DrmInfoRequest;
private:
explicit Iterator(const DrmInfoRequest* drmInfoRequest)
: mDrmInfoRequest(const_cast <DrmInfoRequest*> (drmInfoRequest)), mIndex(0) {}
public:
Iterator(const Iterator& iterator);
Iterator& operator=(const Iterator& iterator);
virtual ~Iterator() {}
public:
bool hasNext();
String8& next();
private:
DrmInfoRequest* mDrmInfoRequest;
unsigned int mIndex;
};
public:
/**
* Returns information type associated with this instance
*
* @return Information type
*/
int getInfoType(void) const;
/**
* Returns MIME type associated with this instance
*
* @return MIME type
*/
String8 getMimeType(void) const;
/**
* Returns the number of entries in DrmRequestInfoMap
*
* @return Number of entries
*/
int getCount(void) const;
/**
* Adds optional information as <key, value> pair to this instance
*
* @param[in] key Key to add
* @param[in] value Value to add
* @return Returns the error code
*/
status_t put(const String8& key, const String8& value);
/**
* Retrieves the value of given key
*
* @param key Key whose value to be retrieved
* @return The value
*/
String8 get(const String8& key) const;
/**
* Returns KeyIterator object to walk through the keys associated with this instance
*
* @return KeyIterator object
*/
KeyIterator keyIterator() const;
/**
* Returns Iterator object to walk through the values associated with this instance
*
* @return Iterator object
*/
Iterator iterator() const;
private:
int mInfoType;
String8 mMimeType;
typedef KeyedVector<String8, String8> DrmRequestInfoMap;
DrmRequestInfoMap mRequestInformationMap;
};
};
#endif /* __DRM_INFO_REQUEST_H__ */

67
android/frameworks/av/include/drm/DrmInfoStatus.h Normal file
View file

@ -0,0 +1,67 @@
/*
* Copyright (C) 2010 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.
*/
#ifndef __DRM_INFO_STATUS_H__
#define __DRM_INFO_STATUS_H__
#include "drm_framework_common.h"
namespace android {
/**
* This is an utility class which wraps the result of communication between device
* and online DRM server.
*
* As a result of DrmManagerClient::processDrmInfo(const DrmInfo*) an instance of
* DrmInfoStatus would be returned. This class holds DrmBuffer which could be
* used to instantiate DrmRights in license acquisition.
*
*/
class DrmInfoStatus {
public:
// Should be in sync with DrmInfoStatus.java
static const int STATUS_OK = 1;
static const int STATUS_ERROR = 2;
public:
/**
* Constructor for DrmInfoStatus
*
* @param[in] _statusCode Status of the communication
* @param[in] _infoType Type of the DRM information processed
* @param[in] _drmBuffer Rights information
* @param[in] _mimeType MIME type
*/
DrmInfoStatus(int _statusCode, int _infoType, const DrmBuffer* _drmBuffer, const String8& _mimeType);
/**
* Destructor for DrmInfoStatus
*/
virtual ~DrmInfoStatus() {
}
public:
int statusCode;
int infoType;
const DrmBuffer* drmBuffer;
String8 mimeType;
};
};
#endif /* __DRM_INFO_STATUS_H__ */

390
android/frameworks/av/include/drm/DrmManagerClient.h Normal file
View file

@ -0,0 +1,390 @@
/*
* Copyright (C) 2010 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.
*/
#ifndef __DRM_MANAGER_CLIENT_H__
#define __DRM_MANAGER_CLIENT_H__
#include <utils/threads.h>
#include <binder/IInterface.h>
#include "drm_framework_common.h"
namespace android {
class DrmInfo;
class DrmRights;
class DrmMetadata;
class DrmInfoEvent;
class DrmInfoStatus;
class DrmInfoRequest;
class DrmSupportInfo;
class DrmConstraints;
class DrmConvertedStatus;
class DrmManagerClientImpl;
/**
* The Native application will instantiate this class and access DRM Framework
* services through this class.
*
*/
class DrmManagerClient {
public:
DrmManagerClient();
virtual ~DrmManagerClient();
public:
class OnInfoListener: virtual public RefBase {
public:
virtual ~OnInfoListener() {}
public:
virtual void onInfo(const DrmInfoEvent& event) = 0;
};
/**
* APIs which will be used by native modules (e.g. StageFright)
*
*/
public:
/**
* Open the decrypt session to decrypt the given protected content
*
* @param[in] fd File descriptor of the protected content to be decrypted
* @param[in] offset Start position of the content
* @param[in] length The length of the protected content
* @param[in] mime Mime type of the protected content if it is not NULL or empty
* @return
* Handle for the decryption session
*/
sp<DecryptHandle> openDecryptSession(int fd, off64_t offset, off64_t length, const char* mime);
/**
* Open the decrypt session to decrypt the given protected content
*
* @param[in] uri Path of the protected content to be decrypted
* @param[in] mime Mime type of the protected content if it is not NULL or empty
* @return
* Handle for the decryption session
*/
sp<DecryptHandle> openDecryptSession(const char* uri, const char* mime);
/**
* Open the decrypt session to decrypt the given protected content
*
* @param[in] buf Data to initiate decrypt session
* @param[in] mimeType Mime type of the protected content
* @return
* Handle for the decryption session
*/
sp<DecryptHandle> openDecryptSession(const DrmBuffer& buf, const String8& mimeType);
/**
* Close the decrypt session for the given handle
*
* @param[in] decryptHandle Handle for the decryption session
* @return status_t
* Returns DRM_NO_ERROR for success, DRM_ERROR_UNKNOWN for failure
*/
status_t closeDecryptSession(sp<DecryptHandle> &decryptHandle);
/**
* Consumes the rights for a content.
* If the reserve parameter is true the rights is reserved until the same
* application calls this api again with the reserve parameter set to false.
*
* @param[in] decryptHandle Handle for the decryption session
* @param[in] action Action to perform. (Action::DEFAULT, Action::PLAY, etc)
* @param[in] reserve True if the rights should be reserved.
* @return status_t
* Returns DRM_NO_ERROR for success, DRM_ERROR_UNKNOWN for failure.
* In case license has been expired, DRM_ERROR_LICENSE_EXPIRED will be returned.
*/
status_t consumeRights(sp<DecryptHandle> &decryptHandle, int action, bool reserve);
/**
* Informs the DRM engine about the playback actions performed on the DRM files.
*
* @param[in] decryptHandle Handle for the decryption session
* @param[in] playbackStatus Playback action (Playback::START, Playback::STOP, Playback::PAUSE)
* @param[in] position Position in the file (in milliseconds) where the start occurs.
* Only valid together with Playback::START.
* @return status_t
* Returns DRM_NO_ERROR for success, DRM_ERROR_UNKNOWN for failure
*/
status_t setPlaybackStatus(
sp<DecryptHandle> &decryptHandle, int playbackStatus, int64_t position);
/**
* Initialize decryption for the given unit of the protected content
*
* @param[in] decryptHandle Handle for the decryption session
* @param[in] decryptUnitId ID which specifies decryption unit, such as track ID
* @param[in] headerInfo Information for initializing decryption of this decrypUnit
* @return status_t
* Returns DRM_NO_ERROR for success, DRM_ERROR_UNKNOWN for failure
*/
status_t initializeDecryptUnit(
sp<DecryptHandle> &decryptHandle, int decryptUnitId, const DrmBuffer* headerInfo);
/**
* Decrypt the protected content buffers for the given unit
* This method will be called any number of times, based on number of
* encrypted streams received from application.
*
* @param[in] decryptHandle Handle for the decryption session
* @param[in] decryptUnitId ID which specifies decryption unit, such as track ID
* @param[in] encBuffer Encrypted data block
* @param[out] decBuffer Decrypted data block
* @param[in] IV Optional buffer
* @return status_t
* Returns the error code for this API
* DRM_NO_ERROR for success, and one of DRM_ERROR_UNKNOWN, DRM_ERROR_LICENSE_EXPIRED
* DRM_ERROR_SESSION_NOT_OPENED, DRM_ERROR_DECRYPT_UNIT_NOT_INITIALIZED,
* DRM_ERROR_DECRYPT for failure.
*/
status_t decrypt(
sp<DecryptHandle> &decryptHandle, int decryptUnitId,
const DrmBuffer* encBuffer, DrmBuffer** decBuffer, DrmBuffer* IV = NULL);
/**
* Finalize decryption for the given unit of the protected content
*
* @param[in] decryptHandle Handle for the decryption session
* @param[in] decryptUnitId ID which specifies decryption unit, such as track ID
* @return status_t
* Returns DRM_NO_ERROR for success, DRM_ERROR_UNKNOWN for failure
*/
status_t finalizeDecryptUnit(
sp<DecryptHandle> &decryptHandle, int decryptUnitId);
/**
* Reads the specified number of bytes from an open DRM file.
*
* @param[in] decryptHandle Handle for the decryption session
* @param[out] buffer Reference to the buffer that should receive the read data.
* @param[in] numBytes Number of bytes to read.
* @param[in] offset Offset with which to update the file position.
*
* @return Number of bytes read. Returns -1 for Failure.
*/
ssize_t pread(sp<DecryptHandle> &decryptHandle,
void* buffer, ssize_t numBytes, off64_t offset);
/**
* Validates whether an action on the DRM content is allowed or not.
*
* @param[in] path Path of the protected content
* @param[in] action Action to validate. (Action::DEFAULT, Action::PLAY, etc)
* @param[in] description Detailed description of the action
* @return true if the action is allowed.
*/
bool validateAction(const String8& path, int action, const ActionDescription& description);
/**
* APIs which are just the underlying implementation for the Java API
*
*/
public:
/**
* Register a callback to be invoked when the caller required to
* receive necessary information
*
* @param[in] infoListener Listener
* @return status_t
* Returns DRM_NO_ERROR for success, DRM_ERROR_UNKNOWN for failure
*/
status_t setOnInfoListener(const sp<DrmManagerClient::OnInfoListener>& infoListener);
/**
* Get constraint information associated with input content
*
* @param[in] path Path of the protected content
* @param[in] action Actions defined such as,
* Action::DEFAULT, Action::PLAY, etc
* @return DrmConstraints
* key-value pairs of constraint are embedded in it
* @note
* In case of error, return NULL
*/
DrmConstraints* getConstraints(const String8* path, const int action);
/**
* Get metadata information associated with input content
*
* @param[in] path Path of the protected content
* @return DrmMetadata
* key-value pairs of metadata
* @note
* In case of error, return NULL
*/
DrmMetadata* getMetadata(const String8* path);
/**
* Check whether the given mimetype or path can be handled
*
* @param[in] path Path of the content needs to be handled
* @param[in] mimetype Mimetype of the content needs to be handled
* @return
* True if DrmManager can handle given path or mime type.
*/
bool canHandle(const String8& path, const String8& mimeType);
/**
* Executes given drm information based on its type
*
* @param[in] drmInfo Information needs to be processed
* @return DrmInfoStatus
* instance as a result of processing given input
*/
DrmInfoStatus* processDrmInfo(const DrmInfo* drmInfo);
/**
* Retrieves necessary information for registration, unregistration or rights
* acquisition information.
*
* @param[in] drmInfoRequest Request information to retrieve drmInfo
* @return DrmInfo
* instance as a result of processing given input
*/
DrmInfo* acquireDrmInfo(const DrmInfoRequest* drmInfoRequest);
/**
* Save DRM rights to specified rights path
* and make association with content path
*
* @param[in] drmRights DrmRights to be saved
* @param[in] rightsPath File path where rights to be saved
* @param[in] contentPath File path where content was saved
* @return status_t
* Returns DRM_NO_ERROR for success, DRM_ERROR_UNKNOWN for failure
*/
status_t saveRights(
const DrmRights& drmRights, const String8& rightsPath, const String8& contentPath);
/**
* Retrieves the mime type embedded inside the original content
*
* @param[in] path the path of the protected content
* @param[in] fd the file descriptor of the protected content
* @return String8
* Returns mime-type of the original content, such as "video/mpeg"
*/
String8 getOriginalMimeType(const String8& path, int fd);
/**
* Retrieves the type of the protected object (content, rights, etc..)
* by using specified path or mimetype. At least one parameter should be non null
* to retrieve DRM object type
*
* @param[in] path Path of the content or null.
* @param[in] mimeType Mime type of the content or null.
* @return type of the DRM content,
* such as DrmObjectType::CONTENT, DrmObjectType::RIGHTS_OBJECT
*/
int getDrmObjectType(const String8& path, const String8& mimeType);
/**
* Check whether the given content has valid rights or not
*
* @param[in] path Path of the protected content
* @param[in] action Action to perform
* @return the status of the rights for the protected content,
* such as RightsStatus::RIGHTS_VALID, RightsStatus::RIGHTS_EXPIRED, etc.
*/
int checkRightsStatus(const String8& path, int action);
/**
* Removes the rights associated with the given protected content
*
* @param[in] path Path of the protected content
* @return status_t
* Returns DRM_NO_ERROR for success, DRM_ERROR_UNKNOWN for failure
*/
status_t removeRights(const String8& path);
/**
* Removes all the rights information of each plug-in associated with
* DRM framework. Will be used in master reset
*
* @return status_t
* Returns DRM_NO_ERROR for success, DRM_ERROR_UNKNOWN for failure
*/
status_t removeAllRights();
/**
* This API is for Forward Lock DRM.
* Each time the application tries to download a new DRM file
* which needs to be converted, then the application has to
* begin with calling this API.
*
* @param[in] convertId Handle for the convert session
* @param[in] mimeType Description/MIME type of the input data packet
* @return Return handle for the convert session
*/
int openConvertSession(const String8& mimeType);
/**
* Passes the input data which need to be converted. The resultant
* converted data and the status is returned in the DrmConvertedInfo
* object. This method will be called each time there are new block
* of data received by the application.
*
* @param[in] convertId Handle for the convert session
* @param[in] inputData Input Data which need to be converted
* @return Return object contains the status of the data conversion,
* the output converted data and offset. In this case the
* application will ignore the offset information.
*/
DrmConvertedStatus* convertData(int convertId, const DrmBuffer* inputData);
/**
* When there is no more data which need to be converted or when an
* error occurs that time the application has to inform the Drm agent
* via this API. Upon successful conversion of the complete data,
* the agent will inform that where the header and body signature
* should be added. This signature appending is needed to integrity
* protect the converted file.
*
* @param[in] convertId Handle for the convert session
* @return Return object contains the status of the data conversion,
* the header and body signature data. It also informs
* the application on which offset these signature data
* should be appended.
*/
DrmConvertedStatus* closeConvertSession(int convertId);
/**
* Retrieves all DrmSupportInfo instance that native DRM framework can handle.
* This interface is meant to be used by JNI layer
*
* @param[out] length Number of elements in drmSupportInfoArray
* @param[out] drmSupportInfoArray Array contains all DrmSupportInfo
* that native DRM framework can handle
* @return status_t
* Returns DRM_NO_ERROR for success, DRM_ERROR_UNKNOWN for failure
*/
status_t getAllSupportInfo(int* length, DrmSupportInfo** drmSupportInfoArray);
private:
int mUniqueId;
sp<DrmManagerClientImpl> mDrmManagerClientImpl;
};
};
#endif /* __DRM_MANAGER_CLIENT_H__ */

111
android/frameworks/av/include/drm/DrmMetadata.h Normal file
View file

@ -0,0 +1,111 @@
/*
* Copyright (C) 2010 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.
*/
#ifndef __DRM_METADATA_H__
#define __DRM_METADATA_H__
#include "drm_framework_common.h"
namespace android {
/**
* This is an utility class which contains the constraints information.
*
* As a result of DrmManagerClient::getMetadata(const String8*)
* an instance of DrmMetadata would be returned.
*/
class DrmMetadata {
public:
/**
* Iterator for key
*/
class KeyIterator {
friend class DrmMetadata;
private:
explicit KeyIterator(DrmMetadata* drmMetadata) : mDrmMetadata(drmMetadata), mIndex(0) {}
public:
KeyIterator(const KeyIterator& keyIterator);
KeyIterator& operator=(const KeyIterator& keyIterator);
virtual ~KeyIterator() {}
public:
bool hasNext();
const String8& next();
private:
DrmMetadata* mDrmMetadata;
unsigned int mIndex;
};
/**
* Iterator for constraints
*/
class Iterator {
friend class DrmMetadata;
private:
explicit Iterator(DrmMetadata* drmMetadata) : mDrmMetadata(drmMetadata), mIndex(0) {}
public:
Iterator(const Iterator& iterator);
Iterator& operator=(const Iterator& iterator);
virtual ~Iterator() {}
public:
bool hasNext();
String8 next();
private:
DrmMetadata* mDrmMetadata;
unsigned int mIndex;
};
public:
DrmMetadata() {}
virtual ~DrmMetadata() {
DrmMetadata::KeyIterator keyIt = this->keyIterator();
while (keyIt.hasNext()) {
String8 key = keyIt.next();
const char* value = this->getAsByteArray(&key);
if (NULL != value) {
delete[] value;
value = NULL;
}
}
mMetadataMap.clear();
}
public:
int getCount(void) const;
status_t put(const String8* key, const char* value);
String8 get(const String8& key) const;
const char* getAsByteArray(const String8* key) const;
KeyIterator keyIterator();
Iterator iterator();
private:
const char* getValue(const String8* key) const;
private:
typedef KeyedVector<String8, const char*> DrmMetadataMap;
DrmMetadataMap mMetadataMap;
};
};
#endif /* __DRM_METADATA_H__ */

106
android/frameworks/av/include/drm/DrmRights.h Normal file
View file

@ -0,0 +1,106 @@
/*
* Copyright (C) 2010 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.
*/
#ifndef __DRM_RIGHTS_H__
#define __DRM_RIGHTS_H__
#include "drm_framework_common.h"
namespace android {
/**
* This is an utility class which wraps the license information which was
* retrieved from the online DRM server.
*
* Caller can instantiate DrmRights by invoking DrmRights(const DrmBuffer&, String)
* constructor by using the result of DrmManagerClient::ProcessDrmInfo(const DrmInfo*) API.
* Caller can also instantiate DrmRights using the file path which contains rights information.
*
*/
class DrmRights {
public:
/**
* Constructor for DrmRights
*
* @param[in] rightsFilePath Path of the file containing rights data
* @param[in] mimeType MIME type
* @param[in] accountId Account Id of the user
* @param[in] subscriptionId Subscription Id of the user
*/
DrmRights(
const String8& rightsFilePath, const String8& mimeType,
const String8& accountId = String8("_NO_USER"),
const String8& subscriptionId = String8(""));
/**
* Constructor for DrmRights
*
* @param[in] rightsData Rights data
* @param[in] mimeType MIME type
* @param[in] accountId Account Id of the user
* @param[in] subscriptionId Subscription Id of the user
*/
DrmRights(
const DrmBuffer& rightsData, const String8& mimeType,
const String8& accountId = String8("_NO_USER"),
const String8& subscriptionId = String8(""));
/**
* Destructor for DrmRights
*/
virtual ~DrmRights();
public:
/**
* Returns the rights data associated with this instance
*
* @return Rights data
*/
const DrmBuffer& getData(void) const;
/**
* Returns MIME type associated with this instance
*
* @return MIME type
*/
String8 getMimeType(void) const;
/**
* Returns the account-id associated with this instance
*
* @return Account Id
*/
String8 getAccountId(void) const;
/**
* Returns the subscription-id associated with this object
*
* @return Subscription Id
*/
String8 getSubscriptionId(void) const;
private:
DrmBuffer mData;
String8 mMimeType;
String8 mAccountId;
String8 mSubscriptionId;
char* mRightsFromFile;
};
};
#endif /* __DRM_RIGHTS_H__ */

191
android/frameworks/av/include/drm/DrmSupportInfo.h Normal file
View file

@ -0,0 +1,191 @@
/*
* Copyright (C) 2010 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.
*/
#ifndef __DRM_SUPPORT_INFO_H__
#define __DRM_SUPPORT_INFO_H__
#include "drm_framework_common.h"
namespace android {
/**
* This is an utility class which wraps the capability of each plug-in,
* such as mimetype's and file suffixes it could handle.
*
* Plug-in developer could return the capability of the plugin by passing
* DrmSupportInfo instance.
*
*/
class DrmSupportInfo {
public:
/**
* Iterator for mMimeTypeVector
*/
class MimeTypeIterator {
friend class DrmSupportInfo;
private:
explicit MimeTypeIterator(DrmSupportInfo* drmSupportInfo)
: mDrmSupportInfo(drmSupportInfo), mIndex(0) {}
public:
MimeTypeIterator(const MimeTypeIterator& iterator);
MimeTypeIterator& operator=(const MimeTypeIterator& iterator);
virtual ~MimeTypeIterator() {}
public:
bool hasNext();
String8& next();
private:
DrmSupportInfo* mDrmSupportInfo;
unsigned int mIndex;
};
/**
* Iterator for mFileSuffixVector
*/
class FileSuffixIterator {
friend class DrmSupportInfo;
private:
explicit FileSuffixIterator(DrmSupportInfo* drmSupportInfo)
: mDrmSupportInfo(drmSupportInfo), mIndex(0) {}
public:
FileSuffixIterator(const FileSuffixIterator& iterator);
FileSuffixIterator& operator=(const FileSuffixIterator& iterator);
virtual ~FileSuffixIterator() {}
public:
bool hasNext();
String8& next();
private:
DrmSupportInfo* mDrmSupportInfo;
unsigned int mIndex;
};
public:
/**
* Constructor for DrmSupportInfo
*/
DrmSupportInfo();
/**
* Copy constructor for DrmSupportInfo
*/
DrmSupportInfo(const DrmSupportInfo& drmSupportInfo);
/**
* Destructor for DrmSupportInfo
*/
virtual ~DrmSupportInfo() {}
DrmSupportInfo& operator=(const DrmSupportInfo& drmSupportInfo);
bool operator<(const DrmSupportInfo& drmSupportInfo) const;
bool operator==(const DrmSupportInfo& drmSupportInfo) const;
/**
* Returns FileSuffixIterator object to walk through file suffix values
* associated with this instance
*
* @return FileSuffixIterator object
*/
FileSuffixIterator getFileSuffixIterator();
/**
* Returns MimeTypeIterator object to walk through mimetype values
* associated with this instance
*
* @return MimeTypeIterator object
*/
MimeTypeIterator getMimeTypeIterator();
public:
/**
* Returns the number of mimetypes supported.
*
* @return Number of mimetypes supported
*/
int getMimeTypeCount(void) const;
/**
* Returns the number of file types supported.
*
* @return Number of file types supported
*/
int getFileSuffixCount(void) const;
/**
* Adds the mimetype to the list of supported mimetypes
*
* @param[in] mimeType mimetype to be added
* @return Returns DRM_NO_ERROR for success, DRM_ERROR_UNKNOWN for failure
*/
status_t addMimeType(const String8& mimeType);
/**
* Adds the filesuffix to the list of supported file types
*
* @param[in] filesuffix file suffix to be added
* @return Returns DRM_NO_ERROR for success, DRM_ERROR_UNKNOWN for failure
*/
status_t addFileSuffix(const String8& fileSuffix);
/**
* Set the unique description about the plugin
*
* @param[in] description Unique description
* @return Returns DRM_NO_ERROR for success, DRM_ERROR_UNKNOWN for failure
*/
status_t setDescription(const String8& description);
/**
* Returns the unique description associated with the plugin
*
* @return Unique description
*/
String8 getDescription() const;
/**
* Returns whether given mimetype is supported or not
*
* @param[in] mimeType MIME type
* @return
* true - if mime-type is supported
* false - if mime-type is not supported
*/
bool isSupportedMimeType(const String8& mimeType) const;
/**
* Returns whether given file type is supported or not
*
* @param[in] fileType File type
* @return
* true if file type is supported
* false if file type is not supported
*/
bool isSupportedFileSuffix(const String8& fileType) const;
private:
Vector<String8> mMimeTypeVector;
Vector<String8> mFileSuffixVector;
String8 mDescription;
};
};
#endif /* __DRM_SUPPORT_INFO_H__ */

333
android/frameworks/av/include/drm/drm_framework_common.h Normal file
View file

@ -0,0 +1,333 @@
/*
* Copyright (C) 2010 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.
*/
#ifndef __DRM_FRAMEWORK_COMMON_H__
#define __DRM_FRAMEWORK_COMMON_H__
#include <utils/Vector.h>
#include <utils/KeyedVector.h>
#include <utils/RefBase.h>
#include <utils/String8.h>
#include <utils/Errors.h>
#define INVALID_VALUE (-1)
namespace android {
/**
* Error code for DRM Frameowrk
*/
enum {
// The following constant values should be in sync with
// media/stagefright/MediaErrors.h
ERROR_BASE = -2000,
DRM_ERROR_UNKNOWN = ERROR_BASE,
DRM_ERROR_NO_LICENSE = ERROR_BASE - 1,
DRM_ERROR_LICENSE_EXPIRED = ERROR_BASE - 2,
DRM_ERROR_SESSION_NOT_OPENED = ERROR_BASE - 3,
DRM_ERROR_DECRYPT_UNIT_NOT_INITIALIZED = ERROR_BASE - 4,
DRM_ERROR_DECRYPT = ERROR_BASE - 5,
DRM_ERROR_CANNOT_HANDLE = ERROR_BASE - 6,
DRM_ERROR_TAMPER_DETECTED = ERROR_BASE - 7,
DRM_ERROR_NO_PERMISSION = ERROR_BASE - 8,
DRM_NO_ERROR = NO_ERROR
};
/**
* copy control settings used in DecryptHandle::copyControlVector
*/
enum DrmCopyControl {
DRM_COPY_CONTROL_BASE = 1000,
// the key used to set the value for HDCP
// if the associated value is 1, then HDCP is required
// otherwise, HDCP is not required
DRM_COPY_CONTROL_HDCP = DRM_COPY_CONTROL_BASE
};
/**
* Defines DRM Buffer
*/
class DrmBuffer {
public:
char* data;
int length;
DrmBuffer() :
data(NULL),
length(0) {
}
DrmBuffer(char* dataBytes, int dataLength) :
data(dataBytes),
length(dataLength) {
}
};
/**
* Defines detailed description of the action
*/
class ActionDescription {
public:
ActionDescription(int _outputType, int _configuration) :
outputType(_outputType),
configuration(_configuration) {
}
public:
int outputType; /* BLUETOOTH , HDMI*/
int configuration; /* RESOLUTION_720_480 , RECORDABLE etc.*/
};
/**
* Defines constants related to DRM types
*/
class DrmObjectType {
private:
DrmObjectType();
public:
/**
* Field specifies the unknown type
*/
static const int UNKNOWN = 0x00;
/**
* Field specifies the protected content type
*/
static const int CONTENT = 0x01;
/**
* Field specifies the rights information
*/
static const int RIGHTS_OBJECT = 0x02;
/**
* Field specifies the trigger information
*/
static const int TRIGGER_OBJECT = 0x03;
};
/**
* Defines constants related to play back
*/
class Playback {
private:
Playback();
public:
/**
* Constant field signifies playback start
*/
static const int START = 0x00;
/**
* Constant field signifies playback stop
*/
static const int STOP = 0x01;
/**
* Constant field signifies playback paused
*/
static const int PAUSE = 0x02;
/**
* Constant field signifies playback resumed
*/
static const int RESUME = 0x03;
};
/**
* Defines actions that can be performed on protected content
*/
class Action {
private:
Action();
public:
/**
* Constant field signifies that the default action
*/
static const int DEFAULT = 0x00;
/**
* Constant field signifies that the content can be played
*/
static const int PLAY = 0x01;
/**
* Constant field signifies that the content can be set as ring tone
*/
static const int RINGTONE = 0x02;
/**
* Constant field signifies that the content can be transfered
*/
static const int TRANSFER = 0x03;
/**
* Constant field signifies that the content can be set as output
*/
static const int OUTPUT = 0x04;
/**
* Constant field signifies that preview is allowed
*/
static const int PREVIEW = 0x05;
/**
* Constant field signifies that the content can be executed
*/
static const int EXECUTE = 0x06;
/**
* Constant field signifies that the content can displayed
*/
static const int DISPLAY = 0x07;
};
/**
* Defines constants related to status of the rights
*/
class RightsStatus {
private:
RightsStatus();
public:
/**
* Constant field signifies that the rights are valid
*/
static const int RIGHTS_VALID = 0x00;
/**
* Constant field signifies that the rights are invalid
*/
static const int RIGHTS_INVALID = 0x01;
/**
* Constant field signifies that the rights are expired for the content
*/
static const int RIGHTS_EXPIRED = 0x02;
/**
* Constant field signifies that the rights are not acquired for the content
*/
static const int RIGHTS_NOT_ACQUIRED = 0x03;
};
/**
* Defines API set for decryption
*/
class DecryptApiType {
private:
DecryptApiType();
public:
/**
* Decrypt API set for non encrypted content
*/
static const int NON_ENCRYPTED = 0x00;
/**
* Decrypt API set for ES based DRM
*/
static const int ELEMENTARY_STREAM_BASED = 0x01;
/**
* POSIX based Decrypt API set for container based DRM
*/
static const int CONTAINER_BASED = 0x02;
};
/**
* Defines decryption information
*/
class DecryptInfo {
public:
/**
* size of memory to be allocated to get the decrypted content.
*/
int decryptBufferLength;
/**
* reserved for future purpose
*/
};
/**
* Defines decryption handle
*/
class DecryptHandle : public RefBase {
public:
/**
* Decryption session Handle
*/
int decryptId;
/**
* Mimetype of the content to be used to select the media extractor
* For e.g., "video/mpeg" or "audio/mp3"
*/
String8 mimeType;
/**
* Defines which decryption pattern should be used to decrypt the given content
* DrmFramework provides two different set of decryption APIs.
* 1. Decrypt APIs for elementary stream based DRM
* (file format is not encrypted but ES is encrypted)
* e.g., Marlin DRM (MP4 file format), WM-DRM (asf file format)
*
* DecryptApiType::ELEMENTARY_STREAM_BASED
* Decryption API set for ES based DRM
* initializeDecryptUnit(), decrypt(), and finalizeDecryptUnit()
* 2. Decrypt APIs for container based DRM (file format itself is encrypted)
* e.g., OMA DRM (dcf file format)
*
* DecryptApiType::CONTAINER_BASED
* POSIX based Decryption API set for container based DRM
* pread()
*/
int decryptApiType;
/**
* Defines the status of the rights like
* RIGHTS_VALID, RIGHTS_INVALID, RIGHTS_EXPIRED or RIGHTS_NOT_ACQUIRED
*/
int status;
/**
* Information required to decrypt content
* e.g. size of memory to be allocated to get the decrypted content.
*/
DecryptInfo* decryptInfo;
/**
* Defines a vector for the copy control settings sent from the DRM plugin
* to the player
*/
KeyedVector<DrmCopyControl, int> copyControlVector;
/**
* Defines a vector for any extra data the DRM plugin wants to send
* to the native code
*/
KeyedVector<String8, String8> extendedData;
public:
DecryptHandle():
decryptId(INVALID_VALUE),
mimeType(""),
decryptApiType(INVALID_VALUE),
status(INVALID_VALUE),
decryptInfo(NULL) {
}
~DecryptHandle() {
delete decryptInfo; decryptInfo = NULL;
}
bool operator<(const DecryptHandle& handle) const {
return (decryptId < handle.decryptId);
}
bool operator==(const DecryptHandle& handle) const {
return (decryptId == handle.decryptId);
}
};
};
#endif /* __DRM_FRAMEWORK_COMMON_H__ */