tequilaOS/platform_hardware_interfaces
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Merge "Update cas@1.1 hal to cas@1.2." am: f8d76bd144

Browse source 
am: f437124480

Change-Id: I624a08043e1dbacd1b063d766ce9f03a61513bc1
This commit is contained in:
Henry Fang 2019-11-07 11:59:51 -08:00 committed by android-build-merger
commit b52cc834a3
26 changed files with 2455 additions and 0 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

3
CleanSpec.mk
View file

@ -80,3 +80,6 @@ $(call add-clean-step, rm -rf $(PRODUCT_OUT)/system/lib64/vndk-Q/android.hardwar
$(call add-clean-step, rm -rf $(PRODUCT_OUT)/system/lib64/android.hardware.configstore@1.2.so)
$(call add-clean-step, rm -rf $(PRODUCT_OUT)/system/lib/vndk-Q/android.hardware.configstore@1.2.so)
$(call add-clean-step, rm -rf $(PRODUCT_OUT)/system/lib/android.hardware.configstore@1.2.so)
$(call add-clean-step, rm -rf $(PRODUCT_OUT)/vendor/bin/hw/android.hardware.cas@1.1*)
$(call add-clean-step, rm -rf $(PRODUCT_OUT)/vendor/etc/init/android.hardware.cas@1.1*)
$(call add-clean-step, rm -rf $(PRODUCT_OUT)/vendor/etc/vintf/manifest/android.hardware.cas@1.1*)

21
cas/1.2/Android.bp Normal file
View file

@ -0,0 +1,21 @@
// This file is autogenerated by hidl-gen -Landroidbp.
hidl_interface {
name: "android.hardware.cas@1.2",
root: "android.hardware",
vndk: {
enabled: true,
},
srcs: [
"ICas.hal",
"ICasListener.hal",
"IMediaCasService.hal",
"types.hal",
],
interfaces: [
"android.hardware.cas@1.0",
"android.hardware.cas@1.1",
"android.hidl.base@1.0",
],
gen_java: true,
}

43
cas/1.2/ICas.hal Normal file
View file

@ -0,0 +1,43 @@
/*
* Copyright (C) 2019 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.
*/
package android.hardware.cas@1.2;
import @1.0::HidlCasSessionId;
import @1.1::ICas;
import ScramblingMode;
import SessionIntent;
import Status;
/**
* ICas is the API to control the cas system and is accessible from both
* Java and native level. It is used to manage sessions, provision/refresh
* the cas system, and process the EMM/ECM messages. It also allows bi-directional,
* scheme-specific communications between the client and the cas system.
*/
interface ICas extends @1.1::ICas {
/**
* Open a session to descramble one or more streams by specifying intention
* and scrambling mode.
*
* @param intent the intention of the session to be opened.
* @param mode the scrambling mode the session will use.
* @return status the status of the call.
* @return sessionId the id of the newly opened session.
*/
openSession_1_2(SessionIntent intent, ScramblingMode mode)
generates (Status status, HidlCasSessionId sessionId);
};

37
cas/1.2/ICasListener.hal Normal file
View file

@ -0,0 +1,37 @@
/*
* Copyright (C) 2019 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.
*/
package android.hardware.cas@1.2;
import @1.1::ICasListener;
import StatusEvent;
interface ICasListener extends @1.1::ICasListener {
/**
* Notify the listener that the status of CAS system has changed.
*
* @param event the event type of status change.
* @param number value for status event.
* For PLUGIN_PHYSICAL_MODULE_CHANGED event:
* the positive number presents how many plugins are inserted;
* the negative number presents how many plugins are removed.
* Client must enumerate plugins after receive the event.
* For PLUGIN_SESSION_NUMBER_CHANGED event:
* the number presents how many sessions are supported
* in the plugin.
*/
onStatusUpdate(StatusEvent event, int32_t number);
};

35
cas/1.2/IMediaCasService.hal Normal file
View file

@ -0,0 +1,35 @@
/*
* Copyright (C) 2019 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.
*/
package android.hardware.cas@1.2;
import ICas;
import ICasListener;
import @1.1::IMediaCasService;
/**
* IMediaCasService is the main entry point for interacting with a vendor's
* cas HAL to create cas and descrambler plugin instances. A cas plugin instance
* opens cas sessions which are used to obtain keys for a descrambler session,
* which can in turn be used to descramble protected video content.
*
* The 1.2 must always create 1.2 ICas interfaces, which are
* returned via the 1.1 createPluginExt method.
*
* To use 1.2 features the caller must cast the returned interface to a
* 1.2 HAL, using V1_2::ICas::castFrom().
*/
interface IMediaCasService extends @1.1::IMediaCasService {};

49
cas/1.2/default/Android.bp Normal file
View file

@ -0,0 +1,49 @@
cc_defaults {
name: "cas_service_defaults@1.2",
defaults: ["hidl_defaults"],
vendor: true,
relative_install_path: "hw",
srcs: [
"CasImpl.cpp",
"DescramblerImpl.cpp",
"MediaCasService.cpp",
"service.cpp",
"SharedLibrary.cpp",
"TypeConvert.cpp",
],
compile_multilib: "32",
shared_libs: [
"android.hardware.cas@1.0",
"android.hardware.cas@1.1",
"android.hardware.cas@1.2",
"android.hardware.cas.native@1.0",
"android.hidl.memory@1.0",
"libbinder",
"libhidlbase",
"libhidlmemory",
"liblog",
"libutils",
],
header_libs: [
"libstagefright_foundation_headers",
"media_plugin_headers",
],
}
cc_binary {
name: "android.hardware.cas@1.2-service",
vintf_fragments: ["android.hardware.cas@1.2-service.xml"],
defaults: ["cas_service_defaults@1.2"],
init_rc: ["android.hardware.cas@1.2-service.rc"],
}
cc_binary {
name: "android.hardware.cas@1.2-service-lazy",
vintf_fragments: ["android.hardware.cas@1.2-service-lazy.xml"],
overrides: ["android.hardware.cas@1.2-service"],
defaults: ["cas_service_defaults@1.2"],
init_rc: ["android.hardware.cas@1.2-service-lazy.rc"],
cflags: ["-DLAZY_SERVICE"],
}

271
cas/1.2/default/CasImpl.cpp Normal file
View file

@ -0,0 +1,271 @@
/*
* Copyright (C) 2019 The Android Open Source Project
*
icensed 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 "android.hardware.cas@1.1-CasImpl"
#include <android/hardware/cas/1.1/ICasListener.h>
#include <android/hardware/cas/1.2/ICasListener.h>
#include <media/cas/CasAPI.h>
#include <utils/Log.h>
#include "CasImpl.h"
#include "SharedLibrary.h"
#include "TypeConvert.h"
namespace android {
namespace hardware {
namespace cas {
namespace V1_1 {
namespace implementation {
CasImpl::CasImpl(const sp<ICasListener>& listener) : mListener(listener) {
ALOGV("CTOR");
}
CasImpl::~CasImpl() {
ALOGV("DTOR");
release();
}
// static
void CasImpl::OnEvent(void* appData, int32_t event, int32_t arg, uint8_t* data, size_t size) {
if (appData == NULL) {
ALOGE("Invalid appData!");
return;
}
CasImpl* casImpl = static_cast<CasImpl*>(appData);
casImpl->onEvent(event, arg, data, size);
}
// static
void CasImpl::CallBackExt(void* appData, int32_t event, int32_t arg, uint8_t* data, size_t size,
const CasSessionId* sessionId) {
if (appData == NULL) {
ALOGE("Invalid appData!");
return;
}
CasImpl* casImpl = static_cast<CasImpl*>(appData);
casImpl->onEvent(sessionId, event, arg, data, size);
}
// static
void CasImpl::StatusUpdate(void* appData, int32_t event, int32_t arg) {
if (appData == NULL) {
ALOGE("Invalid appData!");
return;
}
CasImpl* casImpl = static_cast<CasImpl*>(appData);
casImpl->onStatusUpdate(event, arg);
}
void CasImpl::init(const sp<SharedLibrary>& library, CasPlugin* plugin) {
mLibrary = library;
std::shared_ptr<CasPlugin> holder(plugin);
std::atomic_store(&mPluginHolder, holder);
}
void CasImpl::onEvent(int32_t event, int32_t arg, uint8_t* data, size_t size) {
if (mListener == NULL) {
return;
}
HidlCasData eventData;
if (data != NULL) {
eventData.setToExternal(data, size);
}
mListener->onEvent(event, arg, eventData);
}
void CasImpl::onEvent(const CasSessionId* sessionId, int32_t event, int32_t arg, uint8_t* data,
size_t size) {
if (mListener == NULL) {
return;
}
HidlCasData eventData;
if (data != NULL) {
eventData.setToExternal(data, size);
}
if (sessionId != NULL) {
mListener->onSessionEvent(*sessionId, event, arg, eventData);
} else {
mListener->onEvent(event, arg, eventData);
}
}
void CasImpl::onStatusUpdate(int32_t event, int32_t arg) {
if (mListener == NULL) {
return;
}
sp<V1_2::ICasListener> listenerV1_2 = V1_2::ICasListener::castFrom(mListener);
if (listenerV1_2 != NULL) {
listenerV1_2->onStatusUpdate(static_cast<StatusEvent>(event), arg);
}
}
Return<Status> CasImpl::setPluginStatusUpdateCallback() {
ALOGV("%s", __FUNCTION__);
std::shared_ptr<CasPlugin> holder = std::atomic_load(&mPluginHolder);
if (holder.get() == nullptr) {
return toStatus(INVALID_OPERATION);
}
return toStatus(holder->setStatusCallback(&CasImpl::StatusUpdate));
}
Return<Status> CasImpl::setPrivateData(const HidlCasData& pvtData) {
ALOGV("%s", __FUNCTION__);
std::shared_ptr<CasPlugin> holder = std::atomic_load(&mPluginHolder);
if (holder.get() == nullptr) {
return toStatus(INVALID_OPERATION);
}
return toStatus(holder->setPrivateData(pvtData));
}
Return<void> CasImpl::openSession(openSession_cb _hidl_cb) {
ALOGV("%s", __FUNCTION__);
CasSessionId sessionId;
std::shared_ptr<CasPlugin> holder = std::atomic_load(&mPluginHolder);
status_t err = INVALID_OPERATION;
if (holder.get() != nullptr) {
err = holder->openSession(&sessionId);
holder.reset();
}
_hidl_cb(toStatus(err), sessionId);
return Void();
}
Return<void> CasImpl::openSession_1_2(const SessionIntent intent, const ScramblingMode mode,
openSession_1_2_cb _hidl_cb) {
ALOGV("%s", __FUNCTION__);
CasSessionId sessionId;
std::shared_ptr<CasPlugin> holder = std::atomic_load(&mPluginHolder);
status_t err = INVALID_OPERATION;
if (holder.get() != nullptr) {
err = holder->openSession(static_cast<uint32_t>(intent), static_cast<uint32_t>(mode),
&sessionId);
holder.reset();
}
_hidl_cb(toStatus_1_2(err), sessionId);
return Void();
}
Return<Status> CasImpl::setSessionPrivateData(const HidlCasSessionId& sessionId,
const HidlCasData& pvtData) {
ALOGV("%s: sessionId=%s", __FUNCTION__, sessionIdToString(sessionId).string());
std::shared_ptr<CasPlugin> holder = std::atomic_load(&mPluginHolder);
if (holder.get() == nullptr) {
return toStatus(INVALID_OPERATION);
}
return toStatus(holder->setSessionPrivateData(sessionId, pvtData));
}
Return<Status> CasImpl::closeSession(const HidlCasSessionId& sessionId) {
ALOGV("%s: sessionId=%s", __FUNCTION__, sessionIdToString(sessionId).string());
std::shared_ptr<CasPlugin> holder = std::atomic_load(&mPluginHolder);
if (holder.get() == nullptr) {
return toStatus(INVALID_OPERATION);
}
return toStatus(holder->closeSession(sessionId));
}
Return<Status> CasImpl::processEcm(const HidlCasSessionId& sessionId, const HidlCasData& ecm) {
ALOGV("%s: sessionId=%s", __FUNCTION__, sessionIdToString(sessionId).string());
std::shared_ptr<CasPlugin> holder = std::atomic_load(&mPluginHolder);
if (holder.get() == nullptr) {
return toStatus(INVALID_OPERATION);
}
return toStatus(holder->processEcm(sessionId, ecm));
}
Return<Status> CasImpl::processEmm(const HidlCasData& emm) {
ALOGV("%s", __FUNCTION__);
std::shared_ptr<CasPlugin> holder = std::atomic_load(&mPluginHolder);
if (holder.get() == nullptr) {
return toStatus(INVALID_OPERATION);
}
return toStatus(holder->processEmm(emm));
}
Return<Status> CasImpl::sendEvent(int32_t event, int32_t arg, const HidlCasData& eventData) {
ALOGV("%s", __FUNCTION__);
std::shared_ptr<CasPlugin> holder = std::atomic_load(&mPluginHolder);
if (holder.get() == nullptr) {
return toStatus(INVALID_OPERATION);
}
status_t err = holder->sendEvent(event, arg, eventData);
return toStatus(err);
}
Return<Status> CasImpl::sendSessionEvent(const HidlCasSessionId& sessionId, int32_t event,
int32_t arg, const HidlCasData& eventData) {
ALOGV("%s", __FUNCTION__);
std::shared_ptr<CasPlugin> holder = std::atomic_load(&mPluginHolder);
if (holder.get() == nullptr) {
return toStatus(INVALID_OPERATION);
}
status_t err = holder->sendSessionEvent(sessionId, event, arg, eventData);
return toStatus(err);
}
Return<Status> CasImpl::provision(const hidl_string& provisionString) {
ALOGV("%s: provisionString=%s", __FUNCTION__, provisionString.c_str());
std::shared_ptr<CasPlugin> holder = std::atomic_load(&mPluginHolder);
if (holder.get() == nullptr) {
return toStatus(INVALID_OPERATION);
}
return toStatus(holder->provision(String8(provisionString.c_str())));
}
Return<Status> CasImpl::refreshEntitlements(int32_t refreshType, const HidlCasData& refreshData) {
ALOGV("%s", __FUNCTION__);
std::shared_ptr<CasPlugin> holder = std::atomic_load(&mPluginHolder);
if (holder.get() == nullptr) {
return toStatus(INVALID_OPERATION);
}
status_t err = holder->refreshEntitlements(refreshType, refreshData);
return toStatus(err);
}
Return<Status> CasImpl::release() {
ALOGV("%s: plugin=%p", __FUNCTION__, mPluginHolder.get());
std::shared_ptr<CasPlugin> holder(nullptr);
std::atomic_store(&mPluginHolder, holder);
return Status::OK;
}
} // namespace implementation
} // namespace V1_1
} // namespace cas
} // namespace hardware
} // namespace android

111
cas/1.2/default/CasImpl.h Normal file
View file

@ -0,0 +1,111 @@
/*
* Copyright (C) 2019 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 ANDROID_HARDWARE_CAS_V1_1_CAS_IMPL_H_
#define ANDROID_HARDWARE_CAS_V1_1_CAS_IMPL_H_
#include <android/hardware/cas/1.1/ICas.h>
#include <android/hardware/cas/1.2/ICas.h>
#include <media/stagefright/foundation/ABase.h>
namespace android {
struct CasPlugin;
namespace hardware {
namespace cas {
namespace V1_1 {
struct ICasListener;
namespace implementation {
using ::android::hardware::cas::V1_0::HidlCasData;
using ::android::hardware::cas::V1_0::HidlCasSessionId;
using ::android::hardware::cas::V1_0::Status;
using ::android::hardware::cas::V1_2::ScramblingMode;
using ::android::hardware::cas::V1_2::SessionIntent;
using ::android::hardware::cas::V1_2::StatusEvent;
class SharedLibrary;
class CasImpl : public V1_2::ICas {
public:
CasImpl(const sp<ICasListener>& listener);
virtual ~CasImpl();
static void OnEvent(void* appData, int32_t event, int32_t arg, uint8_t* data, size_t size);
static void CallBackExt(void* appData, int32_t event, int32_t arg, uint8_t* data, size_t size,
const CasSessionId* sessionId);
static void StatusUpdate(void* appData, int32_t event, int32_t arg);
void init(const sp<SharedLibrary>& library, CasPlugin* plugin);
void onEvent(int32_t event, int32_t arg, uint8_t* data, size_t size);
void onEvent(const CasSessionId* sessionId, int32_t event, int32_t arg, uint8_t* data,
size_t size);
void onStatusUpdate(int32_t event, int32_t arg);
// ICas inherits
Return<Status> setPluginStatusUpdateCallback();
virtual Return<Status> setPrivateData(const HidlCasData& pvtData) override;
virtual Return<void> openSession(openSession_cb _hidl_cb) override;
virtual Return<void> openSession_1_2(const SessionIntent intent, const ScramblingMode mode,
openSession_1_2_cb _hidl_cb) override;
virtual Return<Status> closeSession(const HidlCasSessionId& sessionId) override;
virtual Return<Status> setSessionPrivateData(const HidlCasSessionId& sessionId,
const HidlCasData& pvtData) override;
virtual Return<Status> processEcm(const HidlCasSessionId& sessionId,
const HidlCasData& ecm) override;
virtual Return<Status> processEmm(const HidlCasData& emm) override;
virtual Return<Status> sendEvent(int32_t event, int32_t arg,
const HidlCasData& eventData) override;
virtual Return<Status> sendSessionEvent(const HidlCasSessionId& sessionId, int32_t event,
int32_t arg, const HidlCasData& eventData) override;
virtual Return<Status> provision(const hidl_string& provisionString) override;
virtual Return<Status> refreshEntitlements(int32_t refreshType,
const HidlCasData& refreshData) override;
virtual Return<Status> release() override;
private:
struct PluginHolder;
sp<SharedLibrary> mLibrary;
std::shared_ptr<CasPlugin> mPluginHolder;
sp<ICasListener> mListener;
DISALLOW_EVIL_CONSTRUCTORS(CasImpl);
};
} // namespace implementation
} // namespace V1_1
} // namespace cas
} // namespace hardware
} // namespace android
#endif // ANDROID_HARDWARE_CAS_V1_1_CAS_IMPL_H_

195
cas/1.2/default/DescramblerImpl.cpp Normal file
View file

@ -0,0 +1,195 @@
/*
* Copyright (C) 2019 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 "android.hardware.cas@1.1-DescramblerImpl"
#include <hidlmemory/mapping.h>
#include <media/cas/DescramblerAPI.h>
#include <media/hardware/CryptoAPI.h>
#include <media/stagefright/foundation/AUtils.h>
#include <utils/Log.h>
#include "DescramblerImpl.h"
#include "SharedLibrary.h"
#include "TypeConvert.h"
namespace android {
using hidl::memory::V1_0::IMemory;
namespace hardware {
namespace cas {
namespace V1_1 {
namespace implementation {
#define CHECK_SUBSAMPLE_DEF(type) \
static_assert(sizeof(SubSample) == sizeof(type::SubSample), "SubSample: size doesn't match"); \
static_assert(offsetof(SubSample, numBytesOfClearData) == \
offsetof(type::SubSample, mNumBytesOfClearData), \
"SubSample: numBytesOfClearData offset doesn't match"); \
static_assert(offsetof(SubSample, numBytesOfEncryptedData) == \
offsetof(type::SubSample, mNumBytesOfEncryptedData), \
"SubSample: numBytesOfEncryptedData offset doesn't match")
CHECK_SUBSAMPLE_DEF(DescramblerPlugin);
CHECK_SUBSAMPLE_DEF(CryptoPlugin);
DescramblerImpl::DescramblerImpl(const sp<SharedLibrary>& library, DescramblerPlugin* plugin)
: mLibrary(library), mPluginHolder(plugin) {
ALOGV("CTOR: plugin=%p", mPluginHolder.get());
}
DescramblerImpl::~DescramblerImpl() {
ALOGV("DTOR: plugin=%p", mPluginHolder.get());
release();
}
Return<Status> DescramblerImpl::setMediaCasSession(const HidlCasSessionId& sessionId) {
ALOGV("%s: sessionId=%s", __FUNCTION__, sessionIdToString(sessionId).string());
std::shared_ptr<DescramblerPlugin> holder = std::atomic_load(&mPluginHolder);
if (holder.get() == nullptr) {
return toStatus(INVALID_OPERATION);
}
return toStatus(holder->setMediaCasSession(sessionId));
}
Return<bool> DescramblerImpl::requiresSecureDecoderComponent(const hidl_string& mime) {
std::shared_ptr<DescramblerPlugin> holder = std::atomic_load(&mPluginHolder);
if (holder.get() == nullptr) {
return false;
}
return holder->requiresSecureDecoderComponent(String8(mime.c_str()));
}
static inline bool validateRangeForSize(uint64_t offset, uint64_t length, uint64_t size) {
return isInRange<uint64_t, uint64_t>(0, size, offset, length);
}
Return<void> DescramblerImpl::descramble(ScramblingControl scramblingControl,
const hidl_vec<SubSample>& subSamples,
const SharedBuffer& srcBuffer, uint64_t srcOffset,
const DestinationBuffer& dstBuffer, uint64_t dstOffset,
descramble_cb _hidl_cb) {
ALOGV("%s", __FUNCTION__);
// hidl_memory's size is stored in uint64_t, but mapMemory's mmap will map
// size in size_t. If size is over SIZE_MAX, mapMemory mapMemory could succeed
// but the mapped memory's actual size will be smaller than the reported size.
if (srcBuffer.heapBase.size() > SIZE_MAX) {
ALOGE("Invalid hidl_memory size: %llu", srcBuffer.heapBase.size());
android_errorWriteLog(0x534e4554, "79376389");
_hidl_cb(toStatus(BAD_VALUE), 0, NULL);
return Void();
}
sp<IMemory> srcMem = mapMemory(srcBuffer.heapBase);
// Validate if the offset and size in the SharedBuffer is consistent with the
// mapped ashmem, since the offset and size is controlled by client.
if (srcMem == NULL) {
ALOGE("Failed to map src buffer.");
_hidl_cb(toStatus(BAD_VALUE), 0, NULL);
return Void();
}
if (!validateRangeForSize(srcBuffer.offset, srcBuffer.size, (uint64_t)srcMem->getSize())) {
ALOGE("Invalid src buffer range: offset %llu, size %llu, srcMem size %llu",
srcBuffer.offset, srcBuffer.size, (uint64_t)srcMem->getSize());
android_errorWriteLog(0x534e4554, "67962232");
_hidl_cb(toStatus(BAD_VALUE), 0, NULL);
return Void();
}
// use 64-bit here to catch bad subsample size that might be overflowing.
uint64_t totalBytesInSubSamples = 0;
for (size_t i = 0; i < subSamples.size(); i++) {
totalBytesInSubSamples +=
(uint64_t)subSamples[i].numBytesOfClearData + subSamples[i].numBytesOfEncryptedData;
}
// Further validate if the specified srcOffset and requested total subsample size
// is consistent with the source shared buffer size.
if (!validateRangeForSize(srcOffset, totalBytesInSubSamples, srcBuffer.size)) {
ALOGE("Invalid srcOffset and subsample size: "
"srcOffset %llu, totalBytesInSubSamples %llu, srcBuffer size %llu",
srcOffset, totalBytesInSubSamples, srcBuffer.size);
android_errorWriteLog(0x534e4554, "67962232");
_hidl_cb(toStatus(BAD_VALUE), 0, NULL);
return Void();
}
void* srcPtr = (uint8_t*)(void*)srcMem->getPointer() + srcBuffer.offset;
void* dstPtr = NULL;
if (dstBuffer.type == BufferType::SHARED_MEMORY) {
// When using shared memory, src buffer is also used as dst,
// we don't map it again here.
dstPtr = srcPtr;
// In this case the dst and src would be the same buffer, need to validate
// dstOffset against the buffer size too.
if (!validateRangeForSize(dstOffset, totalBytesInSubSamples, srcBuffer.size)) {
ALOGE("Invalid dstOffset and subsample size: "
"dstOffset %llu, totalBytesInSubSamples %llu, srcBuffer size %llu",
dstOffset, totalBytesInSubSamples, srcBuffer.size);
android_errorWriteLog(0x534e4554, "67962232");
_hidl_cb(toStatus(BAD_VALUE), 0, NULL);
return Void();
}
} else {
native_handle_t* handle =
const_cast<native_handle_t*>(dstBuffer.secureMemory.getNativeHandle());
dstPtr = static_cast<void*>(handle);
}
// Get a local copy of the shared_ptr for the plugin. Note that before
// calling the HIDL callback, this shared_ptr must be manually reset,
// since the client side could proceed as soon as the callback is called
// without waiting for this method to go out of scope.
std::shared_ptr<DescramblerPlugin> holder = std::atomic_load(&mPluginHolder);
if (holder.get() == nullptr) {
_hidl_cb(toStatus(INVALID_OPERATION), 0, NULL);
return Void();
}
// Casting hidl SubSample to DescramblerPlugin::SubSample, but need
// to ensure structs are actually idential
int32_t result =
holder->descramble(dstBuffer.type != BufferType::SHARED_MEMORY,
(DescramblerPlugin::ScramblingControl)scramblingControl,
subSamples.size(), (DescramblerPlugin::SubSample*)subSamples.data(),
srcPtr, srcOffset, dstPtr, dstOffset, NULL);
holder.reset();
_hidl_cb(toStatus(result >= 0 ? OK : result), result, NULL);
return Void();
}
Return<Status> DescramblerImpl::release() {
ALOGV("%s: plugin=%p", __FUNCTION__, mPluginHolder.get());
std::shared_ptr<DescramblerPlugin> holder(nullptr);
std::atomic_store(&mPluginHolder, holder);
return Status::OK;
}
} // namespace implementation
} // namespace V1_1
} // namespace cas
} // namespace hardware
} // namespace android

67
cas/1.2/default/DescramblerImpl.h Normal file
View file

@ -0,0 +1,67 @@
/*
* Copyright (C) 2019 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 ANDROID_HARDWARE_CAS_V1_1_DESCRAMBLER_IMPL_H_
#define ANDROID_HARDWARE_CAS_V1_1_DESCRAMBLER_IMPL_H_
#include <android/hardware/cas/native/1.0/IDescrambler.h>
#include <media/stagefright/foundation/ABase.h>
namespace android {
struct DescramblerPlugin;
using namespace hardware::cas::native::V1_0;
namespace hardware {
namespace cas {
namespace V1_1 {
namespace implementation {
using ::android::hardware::cas::V1_0::HidlCasSessionId;
using ::android::hardware::cas::V1_0::Status;
class SharedLibrary;
class DescramblerImpl : public IDescrambler {
public:
DescramblerImpl(const sp<SharedLibrary>& library, DescramblerPlugin* plugin);
virtual ~DescramblerImpl();
virtual Return<Status> setMediaCasSession(const HidlCasSessionId& sessionId) override;
virtual Return<bool> requiresSecureDecoderComponent(const hidl_string& mime) override;
virtual Return<void> descramble(ScramblingControl scramblingControl,
const hidl_vec<SubSample>& subSamples,
const SharedBuffer& srcBuffer, uint64_t srcOffset,
const DestinationBuffer& dstBuffer, uint64_t dstOffset,
descramble_cb _hidl_cb) override;
virtual Return<Status> release() override;
private:
sp<SharedLibrary> mLibrary;
std::shared_ptr<DescramblerPlugin> mPluginHolder;
DISALLOW_EVIL_CONSTRUCTORS(DescramblerImpl);
};
} // namespace implementation
} // namespace V1_1
} // namespace cas
} // namespace hardware
} // namespace android
#endif // ANDROID_HARDWARE_CAS_V1_1_DESCRAMBLER_IMPL_H_

217
cas/1.2/default/FactoryLoader.h Normal file
View file

@ -0,0 +1,217 @@
/*
* Copyright (C) 2019 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 ANDROID_HARDWARE_CAS_V1_1_FACTORY_LOADER_H_
#define ANDROID_HARDWARE_CAS_V1_1_FACTORY_LOADER_H_
#include <dirent.h>
#include <dlfcn.h>
#include <media/cas/CasAPI.h>
#include <utils/KeyedVector.h>
#include <utils/Mutex.h>
#include "SharedLibrary.h"
using namespace std;
namespace android {
namespace hardware {
namespace cas {
namespace V1_1 {
namespace implementation {
using ::android::hardware::cas::V1_0::HidlCasPluginDescriptor;
template <class T>
class FactoryLoader {
public:
FactoryLoader(const char* name) : mFactory(NULL), mCreateFactoryFuncName(name) {}
virtual ~FactoryLoader() { closeFactory(); }
bool findFactoryForScheme(int32_t CA_system_id, sp<SharedLibrary>* library = NULL,
T** factory = NULL);
bool enumeratePlugins(vector<HidlCasPluginDescriptor>* results);
private:
typedef T* (*CreateFactoryFunc)();
Mutex mMapLock;
T* mFactory;
const char* mCreateFactoryFuncName;
sp<SharedLibrary> mLibrary;
KeyedVector<int32_t, String8> mCASystemIdToLibraryPathMap;
KeyedVector<String8, wp<SharedLibrary>> mLibraryPathToOpenLibraryMap;
bool loadFactoryForSchemeFromPath(const String8& path, int32_t CA_system_id,
sp<SharedLibrary>* library, T** factory);
bool queryPluginsFromPath(const String8& path, vector<HidlCasPluginDescriptor>* results);
bool openFactory(const String8& path);
void closeFactory();
};
template <class T>
bool FactoryLoader<T>::findFactoryForScheme(int32_t CA_system_id, sp<SharedLibrary>* library,
T** factory) {
if (library != NULL) {
library->clear();
}
if (factory != NULL) {
*factory = NULL;
}
Mutex::Autolock autoLock(mMapLock);
// first check cache
ssize_t index = mCASystemIdToLibraryPathMap.indexOfKey(CA_system_id);
if (index >= 0) {
return loadFactoryForSchemeFromPath(mCASystemIdToLibraryPathMap[index], CA_system_id,
library, factory);
}
// no luck, have to search
String8 dirPath("/vendor/lib/mediacas");
DIR* pDir = opendir(dirPath.string());
if (pDir == NULL) {
ALOGE("Failed to open plugin directory %s", dirPath.string());
return false;
}
struct dirent* pEntry;
while ((pEntry = readdir(pDir))) {
String8 pluginPath = dirPath + "/" + pEntry->d_name;
if (pluginPath.getPathExtension() == ".so") {
if (loadFactoryForSchemeFromPath(pluginPath, CA_system_id, library, factory)) {
mCASystemIdToLibraryPathMap.add(CA_system_id, pluginPath);
closedir(pDir);
return true;
}
}
}
closedir(pDir);
ALOGE("Failed to find plugin");
return false;
}
template <class T>
bool FactoryLoader<T>::enumeratePlugins(vector<HidlCasPluginDescriptor>* results) {
ALOGI("enumeratePlugins");
results->clear();
String8 dirPath("/vendor/lib/mediacas");
DIR* pDir = opendir(dirPath.string());
if (pDir == NULL) {
ALOGE("Failed to open plugin directory %s", dirPath.string());
return false;
}
Mutex::Autolock autoLock(mMapLock);
struct dirent* pEntry;
while ((pEntry = readdir(pDir))) {
String8 pluginPath = dirPath + "/" + pEntry->d_name;
if (pluginPath.getPathExtension() == ".so") {
queryPluginsFromPath(pluginPath, results);
}
}
return true;
}
template <class T>
bool FactoryLoader<T>::loadFactoryForSchemeFromPath(const String8& path, int32_t CA_system_id,
sp<SharedLibrary>* library, T** factory) {
closeFactory();
if (!openFactory(path) || !mFactory->isSystemIdSupported(CA_system_id)) {
closeFactory();
return false;
}
if (library != NULL) {
*library = mLibrary;
}
if (factory != NULL) {
*factory = mFactory;
}
return true;
}
template <class T>
bool FactoryLoader<T>::queryPluginsFromPath(const String8& path,
vector<HidlCasPluginDescriptor>* results) {
closeFactory();
vector<CasPluginDescriptor> descriptors;
if (!openFactory(path) || mFactory->queryPlugins(&descriptors) != OK) {
closeFactory();
return false;
}
for (auto it = descriptors.begin(); it != descriptors.end(); it++) {
results->push_back(
HidlCasPluginDescriptor{.caSystemId = it->CA_system_id, .name = it->name.c_str()});
}
return true;
}
template <class T>
bool FactoryLoader<T>::openFactory(const String8& path) {
// get strong pointer to open shared library
ssize_t index = mLibraryPathToOpenLibraryMap.indexOfKey(path);
if (index >= 0) {
mLibrary = mLibraryPathToOpenLibraryMap[index].promote();
} else {
index = mLibraryPathToOpenLibraryMap.add(path, NULL);
}
if (!mLibrary.get()) {
mLibrary = new SharedLibrary(path);
if (!*mLibrary) {
return false;
}
mLibraryPathToOpenLibraryMap.replaceValueAt(index, mLibrary);
}
CreateFactoryFunc createFactory = (CreateFactoryFunc)mLibrary->lookup(mCreateFactoryFuncName);
if (createFactory == NULL || (mFactory = createFactory()) == NULL) {
return false;
}
return true;
}
template <class T>
void FactoryLoader<T>::closeFactory() {
delete mFactory;
mFactory = NULL;
mLibrary.clear();
}
} // namespace implementation
} // namespace V1_1
} // namespace cas
} // namespace hardware
} // namespace android
#endif // ANDROID_HARDWARE_CAS_V1_1_FACTORY_LOADER_H_

153
cas/1.2/default/MediaCasService.cpp Normal file
View file

@ -0,0 +1,153 @@
/*
* Copyright (C) 2019 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 "android.hardware.cas@1.1-MediaCasService"
#include <android/hardware/cas/1.1/ICasListener.h>
#include <android/hardware/cas/1.2/ICasListener.h>
#include <media/cas/CasAPI.h>
#include <media/cas/DescramblerAPI.h>
#include <utils/Log.h>
#include "CasImpl.h"
#include "DescramblerImpl.h"
#include "MediaCasService.h"
namespace android {
namespace hardware {
namespace cas {
namespace V1_1 {
namespace implementation {
class Wrapper : public V1_1::ICasListener {
public:
static sp<V1_1::ICasListener> wrap(sp<V1_0::ICasListener> impl) {
sp<V1_1::ICasListener> cast = V1_1::ICasListener::castFrom(impl);
if (cast == NULL) {
cast = new Wrapper(impl);
}
return cast;
}
virtual Return<void> onEvent(int32_t event, int32_t arg,
const hidl_vec<uint8_t>& data) override {
mImpl->onEvent(event, arg, data);
return Void();
}
virtual Return<void> onSessionEvent(const hidl_vec<uint8_t>& /* sessionId */,
int32_t /* event */, int32_t /* arg */,
const hidl_vec<uint8_t>& /*data*/) override {
ALOGV("Do nothing on Session Event for cas@1.0 client in cas@1.1");
return Void();
}
private:
Wrapper(sp<V1_0::ICasListener> impl) : mImpl(impl){};
sp<V1_0::ICasListener> mImpl;
};
MediaCasService::MediaCasService()
: mCasLoader("createCasFactory"), mDescramblerLoader("createDescramblerFactory") {}
MediaCasService::~MediaCasService() {}
Return<void> MediaCasService::enumeratePlugins(enumeratePlugins_cb _hidl_cb) {
ALOGV("%s", __FUNCTION__);
vector<HidlCasPluginDescriptor> results;
mCasLoader.enumeratePlugins(&results);
_hidl_cb(results);
return Void();
}
Return<bool> MediaCasService::isSystemIdSupported(int32_t CA_system_id) {
ALOGV("isSystemIdSupported: CA_system_id=%d", CA_system_id);
return mCasLoader.findFactoryForScheme(CA_system_id);
}
Return<sp<V1_0::ICas>> MediaCasService::createPlugin(int32_t CA_system_id,
const sp<V1_0::ICasListener>& listener) {
ALOGV("%s:Use createPluginExt to create plugin in cas@1.1", __FUNCTION__);
sp<ICas> result;
sp<V1_1::ICasListener> listenerV1_1 = Wrapper::wrap(listener);
result = createPluginExt(CA_system_id, listenerV1_1);
return result;
}
Return<sp<ICas>> MediaCasService::createPluginExt(int32_t CA_system_id,
const sp<ICasListener>& listener) {
ALOGV("%s: CA_system_id=%d", __FUNCTION__, CA_system_id);
if (listener == NULL) ALOGV("%s: Listener is NULL", __FUNCTION__);
sp<V1_2::ICas> result;
CasFactory* factory;
sp<SharedLibrary> library;
if (mCasLoader.findFactoryForScheme(CA_system_id, &library, &factory)) {
CasPlugin* plugin = NULL;
sp<CasImpl> casImpl = new CasImpl(listener);
if (factory->createPlugin(CA_system_id, casImpl.get(), &CasImpl::CallBackExt, &plugin) ==
OK &&
plugin != NULL) {
casImpl->init(library, plugin);
result = casImpl;
sp<V1_2::ICasListener> listenerV1_2 = V1_2::ICasListener::castFrom(listener);
if (listenerV1_2 != NULL) {
casImpl->setPluginStatusUpdateCallback();
}
}
}
return result;
}
Return<bool> MediaCasService::isDescramblerSupported(int32_t CA_system_id) {
ALOGV("%s: CA_system_id=%d", __FUNCTION__, CA_system_id);
return mDescramblerLoader.findFactoryForScheme(CA_system_id);
}
Return<sp<IDescramblerBase>> MediaCasService::createDescrambler(int32_t CA_system_id) {
ALOGV("%s: CA_system_id=%d", __FUNCTION__, CA_system_id);
sp<IDescrambler> result;
DescramblerFactory* factory;
sp<SharedLibrary> library;
if (mDescramblerLoader.findFactoryForScheme(CA_system_id, &library, &factory)) {
DescramblerPlugin* plugin = NULL;
if (factory->createPlugin(CA_system_id, &plugin) == OK && plugin != NULL) {
result = new DescramblerImpl(library, plugin);
}
}
return result;
}
} // namespace implementation
} // namespace V1_1
} // namespace cas
} // namespace hardware
} // namespace android

67
cas/1.2/default/MediaCasService.h Normal file
View file

@ -0,0 +1,67 @@
/*
* Copyright (C) 2019 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 ANDROID_HARDWARE_CAS_V1_1_MEDIA_CAS_SERVICE_H_
#define ANDROID_HARDWARE_CAS_V1_1_MEDIA_CAS_SERVICE_H_
#include <android/hardware/cas/1.1/IMediaCasService.h>
#include <android/hardware/cas/1.2/IMediaCasService.h>
#include "FactoryLoader.h"
namespace android {
struct CasFactory;
struct DescramblerFactory;
namespace hardware {
namespace cas {
namespace V1_1 {
namespace implementation {
using ::android::hardware::cas::V1_0::HidlCasPluginDescriptor;
using ::android::hardware::cas::V1_0::IDescramblerBase;
class MediaCasService : public V1_2::IMediaCasService {
public:
MediaCasService();
virtual Return<void> enumeratePlugins(enumeratePlugins_cb _hidl_cb) override;
virtual Return<bool> isSystemIdSupported(int32_t CA_system_id) override;
virtual Return<sp<V1_0::ICas>> createPlugin(int32_t CA_system_id,
const sp<V1_0::ICasListener>& listener) override;
virtual Return<sp<ICas>> createPluginExt(int32_t CA_system_id,
const sp<ICasListener>& listener) override;
virtual Return<bool> isDescramblerSupported(int32_t CA_system_id) override;
virtual Return<sp<IDescramblerBase>> createDescrambler(int32_t CA_system_id) override;
private:
FactoryLoader<CasFactory> mCasLoader;
FactoryLoader<DescramblerFactory> mDescramblerLoader;
virtual ~MediaCasService();
};
} // namespace implementation
} // namespace V1_1
} // namespace cas
} // namespace hardware
} // namespace android
#endif // ANDROID_HARDWARE_CAS_V1_1_MEDIA_CAS_SERVICE_H_

65
cas/1.2/default/SharedLibrary.cpp Normal file
View file

@ -0,0 +1,65 @@
/*
* Copyright (C) 2019 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 "android.hardware.cas@1.1-SharedLibrary"
#include "SharedLibrary.h"
#include <dlfcn.h>
#include <media/stagefright/foundation/ADebug.h>
#include <utils/Log.h>
namespace android {
namespace hardware {
namespace cas {
namespace V1_1 {
namespace implementation {
SharedLibrary::SharedLibrary(const String8& path) {
mLibHandle = dlopen(path.string(), RTLD_NOW);
}
SharedLibrary::~SharedLibrary() {
if (mLibHandle != NULL) {
dlclose(mLibHandle);
mLibHandle = NULL;
}
}
bool SharedLibrary::operator!() const {
return mLibHandle == NULL;
}
void* SharedLibrary::lookup(const char* symbol) const {
if (!mLibHandle) {
return NULL;
}
// Clear last error before we load the symbol again,
// in case the caller didn't retrieve it.
(void)dlerror();
return dlsym(mLibHandle, symbol);
}
const char* SharedLibrary::lastError() const {
const char* error = dlerror();
return error ? error : "No errors or unknown error";
}
} // namespace implementation
} // namespace V1_1
} // namespace cas
} // namespace hardware
} // namespace android

50
cas/1.2/default/SharedLibrary.h Normal file
View file

@ -0,0 +1,50 @@
/*
* Copyright (C) 2019 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 ANDROID_HARDWARE_CAS_V1_1_SHARED_LIBRARY_H_
#define ANDROID_HARDWARE_CAS_V1_1_SHARED_LIBRARY_H_
#include <media/stagefright/foundation/ABase.h>
#include <utils/RefBase.h>
#include <utils/String8.h>
namespace android {
namespace hardware {
namespace cas {
namespace V1_1 {
namespace implementation {
class SharedLibrary : public RefBase {
public:
explicit SharedLibrary(const String8& path);
~SharedLibrary();
bool operator!() const;
void* lookup(const char* symbol) const;
const char* lastError() const;
private:
void* mLibHandle;
DISALLOW_EVIL_CONSTRUCTORS(SharedLibrary);
};
} // namespace implementation
} // namespace V1_1
} // namespace cas
} // namespace hardware
} // namespace android
#endif // ANDROID_HARDWARE_CAS_V1_1_SHARED_LIBRARY_H_

121
cas/1.2/default/TypeConvert.cpp Normal file
View file

@ -0,0 +1,121 @@
/*
* Copyright (C) 2019 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 "android.hardware.cas@1.1-TypeConvert"
#include "TypeConvert.h"
#include <utils/Log.h>
namespace android {
namespace hardware {
namespace cas {
namespace V1_1 {
namespace implementation {
Status toStatus(status_t legacyStatus) {
Status status;
switch (legacyStatus) {
case android::OK:
status = Status::OK;
break;
case android::ERROR_CAS_NO_LICENSE:
status = Status::ERROR_CAS_NO_LICENSE;
break;
case android::ERROR_CAS_LICENSE_EXPIRED:
status = Status::ERROR_CAS_LICENSE_EXPIRED;
break;
case android::ERROR_CAS_SESSION_NOT_OPENED:
status = Status::ERROR_CAS_SESSION_NOT_OPENED;
break;
case android::ERROR_CAS_CANNOT_HANDLE:
status = Status::ERROR_CAS_CANNOT_HANDLE;
break;
case android::ERROR_CAS_TAMPER_DETECTED:
status = Status::ERROR_CAS_INVALID_STATE;
break;
case android::BAD_VALUE:
status = Status::BAD_VALUE;
break;
case android::ERROR_CAS_NOT_PROVISIONED:
status = Status::ERROR_CAS_NOT_PROVISIONED;
break;
case android::ERROR_CAS_RESOURCE_BUSY:
status = Status::ERROR_CAS_RESOURCE_BUSY;
break;
case android::ERROR_CAS_INSUFFICIENT_OUTPUT_PROTECTION:
status = Status::ERROR_CAS_INSUFFICIENT_OUTPUT_PROTECTION;
break;
case android::ERROR_CAS_DEVICE_REVOKED:
status = Status::ERROR_CAS_DEVICE_REVOKED;
break;
case android::ERROR_CAS_DECRYPT_UNIT_NOT_INITIALIZED:
status = Status::ERROR_CAS_DECRYPT_UNIT_NOT_INITIALIZED;
break;
case android::ERROR_CAS_DECRYPT:
status = Status::ERROR_CAS_DECRYPT;
break;
default:
ALOGW("Unable to convert legacy status: %d, defaulting to UNKNOWN", legacyStatus);
status = Status::ERROR_CAS_UNKNOWN;
break;
}
return status;
}
V1_2::Status toStatus_1_2(status_t legacyStatus) {
V1_2::Status status = static_cast<V1_2::Status>(toStatus(legacyStatus));
if (status == V1_2::Status::ERROR_CAS_UNKNOWN) {
switch (legacyStatus) {
case android::ERROR_CAS_NEED_ACTIVATION:
status = V1_2::Status::ERROR_CAS_NEED_ACTIVATION;
break;
case android::ERROR_CAS_NEED_PAIRING:
status = V1_2::Status::ERROR_CAS_NEED_PAIRING;
break;
case android::ERROR_CAS_NO_CARD:
status = V1_2::Status::ERROR_CAS_NO_CARD;
break;
case android::ERROR_CAS_CARD_MUTE:
status = V1_2::Status::ERROR_CAS_CARD_MUTE;
break;
case android::ERROR_CAS_CARD_INVALID:
status = V1_2::Status::ERROR_CAS_CARD_INVALID;
break;
case android::ERROR_CAS_BLACKOUT:
status = V1_2::Status::ERROR_CAS_BLACKOUT;
break;
}
}
return status;
}
String8 sessionIdToString(const CasSessionId& sessionId) {
String8 result;
for (size_t i = 0; i < sessionId.size(); i++) {
result.appendFormat("%02x ", sessionId[i]);
}
if (result.isEmpty()) {
result.append("(null)");
}
return result;
}
} // namespace implementation
} // namespace V1_1
} // namespace cas
} // namespace hardware
} // namespace android

46
cas/1.2/default/TypeConvert.h Normal file
View file

@ -0,0 +1,46 @@
/*
* Copyright (C) 2019 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 ANDROID_HARDWARE_CAS_V1_1_TYPE_CONVERT_H
#define ANDROID_HARDWARE_CAS_V1_1_TYPE_CONVERT_H
#include <android/hardware/cas/1.0/types.h>
#include <android/hardware/cas/1.2/types.h>
#include <media/cas/CasAPI.h>
#include <media/stagefright/MediaErrors.h>
#include <utils/String8.h>
namespace android {
namespace hardware {
namespace cas {
namespace V1_1 {
namespace implementation {
using ::android::hardware::cas::V1_0::Status;
Status toStatus(status_t legacyStatus);
V1_2::Status toStatus_1_2(status_t legacyStatus);
String8 sessionIdToString(const CasSessionId& sessionId);
} // namespace implementation
} // namespace V1_1
} // namespace cas
} // namespace hardware
} // namespace android
#endif // ANDROID_HARDWARE_CAS_V1_1_TYPE_CONVERT_H

11
cas/1.2/default/android.hardware.cas@1.2-service-lazy.rc Normal file
View file

@ -0,0 +1,11 @@
service vendor.cas-hal-1-2 /vendor/bin/hw/android.hardware.cas@1.2-service-lazy
interface android.hardware.cas@1.0::IMediaCasService default
interface android.hardware.cas@1.1::IMediaCasService default
interface android.hardware.cas@1.2::IMediaCasService default
oneshot
disabled
class hal
user media
group mediadrm drmrpc
ioprio rt 4
writepid /dev/cpuset/foreground/tasks

11
cas/1.2/default/android.hardware.cas@1.2-service-lazy.xml Normal file
View file

@ -0,0 +1,11 @@
<manifest version="1.0" type="device">
<hal format="hidl">
<name>android.hardware.cas</name>
<transport>hwbinder</transport>
<version>1.2</version>
<interface>
<name>IMediaCasService</name>
<instance>default</instance>
</interface>
</hal>
</manifest>

6
cas/1.2/default/android.hardware.cas@1.2-service.rc Normal file
View file

@ -0,0 +1,6 @@
service vendor.cas-hal-1-2 /vendor/bin/hw/android.hardware.cas@1.2-service
class hal
user media
group mediadrm drmrpc
ioprio rt 4
writepid /dev/cpuset/foreground/tasks

11
cas/1.2/default/android.hardware.cas@1.2-service.xml Normal file
View file

@ -0,0 +1,11 @@
<manifest version="1.0" type="device">
<hal format="hidl">
<name>android.hardware.cas</name>
<transport>hwbinder</transport>
<version>1.2</version>
<interface>
<name>IMediaCasService</name>
<instance>default</instance>
</interface>
</hal>
</manifest>

58
cas/1.2/default/service.cpp Normal file
View file

@ -0,0 +1,58 @@
/*
* Copyright 2017 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
#ifdef LAZY_SERVICE
#define LOG_TAG "android.hardware.cas@1.1-service-lazy"
#else
#define LOG_TAG "android.hardware.cas@1.1-service"
#endif
#include <binder/ProcessState.h>
#include <hidl/HidlTransportSupport.h>
#include <hidl/LegacySupport.h>
#include "MediaCasService.h"
using android::hardware::configureRpcThreadpool;
using android::hardware::joinRpcThreadpool;
using android::hardware::LazyServiceRegistrar;
using android::hardware::cas::V1_1::implementation::MediaCasService;
using android::hardware::cas::V1_2::IMediaCasService;
#ifdef LAZY_SERVICE
const bool kLazyService = true;
#else
const bool kLazyService = false;
#endif
int main() {
configureRpcThreadpool(8, true /* callerWillJoin */);
// Setup hwbinder service
android::sp<IMediaCasService> service = new MediaCasService();
android::status_t status;
if (kLazyService) {
auto serviceRegistrar = LazyServiceRegistrar::getInstance();
status = serviceRegistrar.registerService(service);
} else {
status = service->registerAsService();
}
LOG_ALWAYS_FATAL_IF(status != android::OK, "Error while registering cas service: %d", status);
joinRpcThreadpool();
return 0;
}

149
cas/1.2/types.hal Normal file
View file

@ -0,0 +1,149 @@
/*
* Copyright (C) 2019 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.
*/
package android.hardware.cas@1.2;
import android.hardware.cas@1.0;
import android.hardware.cas@1.1;
enum Status : @1.0::Status {
/**
* ERROR_CAS_NEED_ACTIVATION is used to trigger device activation process.
*/
ERROR_CAS_NEED_ACTIVATION,
/**
* ERROR_CAS_NEED_PAIRING is used to trigger pairing process.
*/
ERROR_CAS_NEED_PAIRING,
/**
* ERROR_CAS_NO_CARD is used to report no smart card for descrambling.
*/
ERROR_CAS_NO_CARD,
/**
* ERROR_CAS_CARD_MUTE is used to report smart card is muted for
* descrambling.
*/
ERROR_CAS_CARD_MUTE,
/**
* ERROR_CAS_CARD_INVALID is used to report smart card isn't valid.
*/
ERROR_CAS_CARD_INVALID,
/**
* ERROR_CAS_BLACKOUT is used to report geographical blackout.
*/
ERROR_CAS_BLACKOUT,
};
/**
* The intented usage for the session.
*/
enum SessionIntent : uint32_t {
/**
* Live Stream.
*/
LIVE,
/**
* Playback Recorded Stream.
*/
PLAYBACK,
/**
* Record Live Stream.
*/
RECORD,
/**
* View the content with Time Shift capability
*/
TIMESHIFT,
};
/**
* The Scrambling Mode.
*/
enum ScramblingMode : uint32_t {
RESERVED = 0,
/**
* DVB (Digital Video Broadcasting) CSA1 (Common Scrambling Algorithm 1) is
* the default mode and shall be used when the scrambling descriptor
* is not present in the program map section. DVB scrambling mode is
* specified in ETSI EN 300 468 specification.
*/
DVB_CSA1,
DVB_CSA2,
/**
* DVB-CSA3 in standard mode.
*/
DVB_CSA3_STANDARD,
/**
* DVB-CSA3 in minimally enhanced mode.
*/
DVB_CSA3_MINIMAL,
/**
* DVB-CSA3 in fully enhanced mode.
*/
DVB_CSA3_ENHANCE,
/**
* DVB-CISSA version 1.
*/
DVB_CISSA_V1,
/**
* ATIS-0800006 IIF Default Scrambling Algorithm (IDSA).
*/
DVB_IDSA,
/**
* a symmetric key algorithm.
*/
MULTI2,
/**
* Advanced Encryption System (AES) 128-bit Encryption mode.
*/
AES128,
/**
* Advanced Encryption System (AES) Electronic Code Book (ECB) mode.
*/
AES_ECB,
/**
* Advanced Encryption System (AES) Society of Cable Telecommunications
* Engineers (SCTE) 52 mode.
*/
AES_SCTE52,
/**
* Triple Data Encryption Algorithm (TDES) Electronic Code Book (ECB) mode.
*/
TDES_ECB,
/**
* Triple Data Encryption Algorithm (TDES) Society of Cable Telecommunications
* Engineers (SCTE) 52 mode.
*/
TDES_SCTE52,
};
/**
* The Event Type for status change.
*/
enum StatusEvent : uint8_t {
/**
* The status of CAS plugin was changed due to physical module insertion or
* removal. Client must call enumeratePlugins to update plugins' status.
*/
PLUGIN_PHYSICAL_MODULE_CHANGED,
/**
* The status of supported session number was changed due to physical module
* insertion or removal. Client must update session resource according to
* latest StatusMessage from the StatusEvent. The plugin supports unlimited
* sesssion by default.
*/
PLUGIN_SESSION_NUMBER_CHANGED,
};

36
cas/1.2/vts/functional/Android.bp Normal file
View file

@ -0,0 +1,36 @@
//
// Copyright (C) 2019 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.
//
cc_test {
name: "VtsHalCasV1_2TargetTest",
defaults: ["VtsHalTargetTestDefaults"],
srcs: ["VtsHalCasV1_2TargetTest.cpp"],
static_libs: [
"android.hardware.cas@1.0",
"android.hardware.cas@1.1",
"android.hardware.cas@1.2",
"android.hardware.cas.native@1.0",
"android.hidl.allocator@1.0",
"android.hidl.memory@1.0",
"libhidlallocatorutils",
"libhidlmemory",
],
shared_libs: [
"libbinder",
],
test_suites: ["general-tests"],
}

3
cas/1.2/vts/functional/OWNERS Normal file
View file

@ -0,0 +1,3 @@
nchalko@google.com
chz@google.com
quxiangfang@google.com

619
cas/1.2/vts/functional/VtsHalCasV1_2TargetTest.cpp Normal file
View file

@ -0,0 +1,619 @@
/*
* Copyright (C) 2019 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_TAG "mediacas_hidl_hal_test"
#include <VtsHalHidlTargetTestBase.h>
#include <VtsHalHidlTargetTestEnvBase.h>
#include <android-base/logging.h>
#include <android/hardware/cas/1.0/IDescramblerBase.h>
#include <android/hardware/cas/1.0/types.h>
#include <android/hardware/cas/1.2/ICas.h>
#include <android/hardware/cas/1.2/ICasListener.h>
#include <android/hardware/cas/1.2/IMediaCasService.h>
#include <android/hardware/cas/1.2/types.h>
#include <android/hardware/cas/native/1.0/IDescrambler.h>
#include <android/hardware/cas/native/1.0/types.h>
#include <binder/MemoryDealer.h>
#include <hidl/HidlSupport.h>
#include <hidl/HidlTransportSupport.h>
#include <hidl/Status.h>
#include <hidlmemory/FrameworkUtils.h>
#include <utils/Condition.h>
#include <utils/Mutex.h>
#define CLEAR_KEY_SYSTEM_ID 0xF6D8
#define INVALID_SYSTEM_ID 0
#define WAIT_TIMEOUT 3000000000
#define PROVISION_STR \
"{ " \
" \"id\": 21140844, " \
" \"name\": \"Test Title\", " \
" \"lowercase_organization_name\": \"Android\", " \
" \"asset_key\": { " \
" \"encryption_key\": \"nezAr3CHFrmBR9R8Tedotw==\" " \
" }, " \
" \"cas_type\": 1, " \
" \"track_types\": [ ] " \
"} "
using android::Condition;
using android::IMemory;
using android::IMemoryHeap;
using android::MemoryDealer;
using android::Mutex;
using android::sp;
using android::hardware::fromHeap;
using android::hardware::hidl_string;
using android::hardware::hidl_vec;
using android::hardware::HidlMemory;
using android::hardware::Return;
using android::hardware::Void;
using android::hardware::cas::native::V1_0::BufferType;
using android::hardware::cas::native::V1_0::DestinationBuffer;
using android::hardware::cas::native::V1_0::IDescrambler;
using android::hardware::cas::native::V1_0::ScramblingControl;
using android::hardware::cas::native::V1_0::SharedBuffer;
using android::hardware::cas::native::V1_0::SubSample;
using android::hardware::cas::V1_0::HidlCasPluginDescriptor;
using android::hardware::cas::V1_0::IDescramblerBase;
using android::hardware::cas::V1_0::Status;
using android::hardware::cas::V1_2::ICas;
using android::hardware::cas::V1_2::ICasListener;
using android::hardware::cas::V1_2::IMediaCasService;
using android::hardware::cas::V1_2::ScramblingMode;
using android::hardware::cas::V1_2::SessionIntent;
using android::hardware::cas::V1_2::StatusEvent;
namespace {
const uint8_t kEcmBinaryBuffer[] = {
0x00, 0x00, 0x01, 0xf0, 0x00, 0x50, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x46, 0x00,
0x00, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x27, 0x10, 0x02, 0x00,
0x01, 0x77, 0x01, 0x42, 0x95, 0x6c, 0x0e, 0xe3, 0x91, 0xbc, 0xfd, 0x05, 0xb1, 0x60, 0x4f,
0x17, 0x82, 0xa4, 0x86, 0x9b, 0x23, 0x56, 0x00, 0x01, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00,
0x27, 0x10, 0x02, 0x00, 0x01, 0x77, 0x01, 0x42, 0x95, 0x6c, 0xd7, 0x43, 0x62, 0xf8, 0x1c,
0x62, 0x19, 0x05, 0xc7, 0x3a, 0x42, 0xcd, 0xfd, 0xd9, 0x13, 0x48,
};
const SubSample kSubSamples[] = {{162, 0}, {0, 184}, {0, 184}};
const uint8_t kInBinaryBuffer[] = {
0x00, 0x00, 0x00, 0x01, 0x09, 0xf0, 0x00, 0x00, 0x00, 0x01, 0x67, 0x42, 0xc0, 0x1e, 0xdb,
0x01, 0x40, 0x16, 0xec, 0x04, 0x40, 0x00, 0x00, 0x03, 0x00, 0x40, 0x00, 0x00, 0x0f, 0x03,
0xc5, 0x8b, 0xb8, 0x00, 0x00, 0x00, 0x01, 0x68, 0xca, 0x8c, 0xb2, 0x00, 0x00, 0x01, 0x06,
0x05, 0xff, 0xff, 0x70, 0xdc, 0x45, 0xe9, 0xbd, 0xe6, 0xd9, 0x48, 0xb7, 0x96, 0x2c, 0xd8,
0x20, 0xd9, 0x23, 0xee, 0xef, 0x78, 0x32, 0x36, 0x34, 0x20, 0x2d, 0x20, 0x63, 0x6f, 0x72,
0x65, 0x20, 0x31, 0x34, 0x32, 0x20, 0x2d, 0x20, 0x48, 0x2e, 0x32, 0x36, 0x34, 0x2f, 0x4d,
0x50, 0x45, 0x47, 0x2d, 0x34, 0x20, 0x41, 0x56, 0x43, 0x20, 0x63, 0x6f, 0x64, 0x65, 0x63,
0x20, 0x2d, 0x20, 0x43, 0x6f, 0x70, 0x79, 0x6c, 0x65, 0x66, 0x74, 0x20, 0x32, 0x30, 0x30,
0x33, 0x2d, 0x32, 0x30, 0x31, 0x34, 0x20, 0x2d, 0x20, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f,
0x2f, 0x77, 0x77, 0x77, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x6c, 0x61, 0x6e, 0x2e, 0x6f,
0x72, 0x67, 0x2f, 0x78, 0x32, 0x36, 0x34, 0x2e, 0x68, 0x74, 0x6d, 0x6c, 0x6e, 0x45, 0x21,
0x82, 0x38, 0xf0, 0x9d, 0x7d, 0x96, 0xe6, 0x94, 0xae, 0xe2, 0x87, 0x8f, 0x04, 0x49, 0xe5,
0xf6, 0x8c, 0x8b, 0x9a, 0x10, 0x18, 0xba, 0x94, 0xe9, 0x22, 0x31, 0x04, 0x7e, 0x60, 0x5b,
0xc4, 0x24, 0x00, 0x90, 0x62, 0x0d, 0xdc, 0x85, 0x74, 0x75, 0x78, 0xd0, 0x14, 0x08, 0xcb,
0x02, 0x1d, 0x7d, 0x9d, 0x34, 0xe8, 0x81, 0xb9, 0xf7, 0x09, 0x28, 0x79, 0x29, 0x8d, 0xe3,
0x14, 0xed, 0x5f, 0xca, 0xaf, 0xf4, 0x1c, 0x49, 0x15, 0xe1, 0x80, 0x29, 0x61, 0x76, 0x80,
0x43, 0xf8, 0x58, 0x53, 0x40, 0xd7, 0x31, 0x6d, 0x61, 0x81, 0x41, 0xe9, 0x77, 0x9f, 0x9c,
0xe1, 0x6d, 0xf2, 0xee, 0xd9, 0xc8, 0x67, 0xd2, 0x5f, 0x48, 0x73, 0xe3, 0x5c, 0xcd, 0xa7,
0x45, 0x58, 0xbb, 0xdd, 0x28, 0x1d, 0x68, 0xfc, 0xb4, 0xc6, 0xf6, 0x92, 0xf6, 0x30, 0x03,
0xaa, 0xe4, 0x32, 0xf6, 0x34, 0x51, 0x4b, 0x0f, 0x8c, 0xf9, 0xac, 0x98, 0x22, 0xfb, 0x49,
0xc8, 0xbf, 0xca, 0x8c, 0x80, 0x86, 0x5d, 0xd7, 0xa4, 0x52, 0xb1, 0xd9, 0xa6, 0x04, 0x4e,
0xb3, 0x2d, 0x1f, 0xb8, 0x35, 0xcc, 0x45, 0x6d, 0x9c, 0x20, 0xa7, 0xa4, 0x34, 0x59, 0x72,
0xe3, 0xae, 0xba, 0x49, 0xde, 0xd1, 0xaa, 0xee, 0x3d, 0x77, 0xfc, 0x5d, 0xc6, 0x1f, 0x9d,
0xac, 0xc2, 0x15, 0x66, 0xb8, 0xe1, 0x54, 0x4e, 0x74, 0x93, 0xdb, 0x9a, 0x24, 0x15, 0x6e,
0x20, 0xa3, 0x67, 0x3e, 0x5a, 0x24, 0x41, 0x5e, 0xb0, 0xe6, 0x35, 0x87, 0x1b, 0xc8, 0x7a,
0xf9, 0x77, 0x65, 0xe0, 0x01, 0xf2, 0x4c, 0xe4, 0x2b, 0xa9, 0x64, 0x96, 0x96, 0x0b, 0x46,
0xca, 0xea, 0x79, 0x0e, 0x78, 0xa3, 0x5f, 0x43, 0xfc, 0x47, 0x6a, 0x12, 0xfa, 0xc4, 0x33,
0x0e, 0x88, 0x1c, 0x19, 0x3a, 0x00, 0xc3, 0x4e, 0xb5, 0xd8, 0xfa, 0x8e, 0xf1, 0xbc, 0x3d,
0xb2, 0x7e, 0x50, 0x8d, 0x67, 0xc3, 0x6b, 0xed, 0xe2, 0xea, 0xa6, 0x1f, 0x25, 0x24, 0x7c,
0x94, 0x74, 0x50, 0x49, 0xe3, 0xc6, 0x58, 0x2e, 0xfd, 0x28, 0xb4, 0xc6, 0x73, 0xb1, 0x53,
0x74, 0x27, 0x94, 0x5c, 0xdf, 0x69, 0xb7, 0xa1, 0xd7, 0xf5, 0xd3, 0x8a, 0x2c, 0x2d, 0xb4,
0x5e, 0x8a, 0x16, 0x14, 0x54, 0x64, 0x6e, 0x00, 0x6b, 0x11, 0x59, 0x8a, 0x63, 0x38, 0x80,
0x76, 0xc3, 0xd5, 0x59, 0xf7, 0x3f, 0xd2, 0xfa, 0xa5, 0xca, 0x82, 0xff, 0x4a, 0x62, 0xf0,
0xe3, 0x42, 0xf9, 0x3b, 0x38, 0x27, 0x8a, 0x89, 0xaa, 0x50, 0x55, 0x4b, 0x29, 0xf1, 0x46,
0x7c, 0x75, 0xef, 0x65, 0xaf, 0x9b, 0x0d, 0x6d, 0xda, 0x25, 0x94, 0x14, 0xc1, 0x1b, 0xf0,
0xc5, 0x4c, 0x24, 0x0e, 0x65,
};
const uint8_t kOutRefBinaryBuffer[] = {
0x00, 0x00, 0x00, 0x01, 0x09, 0xf0, 0x00, 0x00, 0x00, 0x01, 0x67, 0x42, 0xc0, 0x1e, 0xdb,
0x01, 0x40, 0x16, 0xec, 0x04, 0x40, 0x00, 0x00, 0x03, 0x00, 0x40, 0x00, 0x00, 0x0f, 0x03,
0xc5, 0x8b, 0xb8, 0x00, 0x00, 0x00, 0x01, 0x68, 0xca, 0x8c, 0xb2, 0x00, 0x00, 0x01, 0x06,
0x05, 0xff, 0xff, 0x70, 0xdc, 0x45, 0xe9, 0xbd, 0xe6, 0xd9, 0x48, 0xb7, 0x96, 0x2c, 0xd8,
0x20, 0xd9, 0x23, 0xee, 0xef, 0x78, 0x32, 0x36, 0x34, 0x20, 0x2d, 0x20, 0x63, 0x6f, 0x72,
0x65, 0x20, 0x31, 0x34, 0x32, 0x20, 0x2d, 0x20, 0x48, 0x2e, 0x32, 0x36, 0x34, 0x2f, 0x4d,
0x50, 0x45, 0x47, 0x2d, 0x34, 0x20, 0x41, 0x56, 0x43, 0x20, 0x63, 0x6f, 0x64, 0x65, 0x63,
0x20, 0x2d, 0x20, 0x43, 0x6f, 0x70, 0x79, 0x6c, 0x65, 0x66, 0x74, 0x20, 0x32, 0x30, 0x30,
0x33, 0x2d, 0x32, 0x30, 0x31, 0x34, 0x20, 0x2d, 0x20, 0x68, 0x74, 0x74, 0x70, 0x3a, 0x2f,
0x2f, 0x77, 0x77, 0x77, 0x2e, 0x76, 0x69, 0x64, 0x65, 0x6f, 0x6c, 0x61, 0x6e, 0x2e, 0x6f,
0x72, 0x67, 0x2f, 0x78, 0x32, 0x36, 0x34, 0x2e, 0x68, 0x74, 0x6d, 0x6c, 0x20, 0x2d, 0x20,
0x6f, 0x70, 0x74, 0x69, 0x6f, 0x6e, 0x73, 0x3a, 0x20, 0x63, 0x61, 0x62, 0x61, 0x63, 0x3d,
0x30, 0x20, 0x72, 0x65, 0x66, 0x3d, 0x32, 0x20, 0x64, 0x65, 0x62, 0x6c, 0x6f, 0x63, 0x6b,
0x3d, 0x31, 0x3a, 0x30, 0x3a, 0x30, 0x20, 0x61, 0x6e, 0x61, 0x6c, 0x79, 0x73, 0x65, 0x3d,
0x30, 0x78, 0x31, 0x3a, 0x30, 0x78, 0x31, 0x31, 0x31, 0x20, 0x6d, 0x65, 0x3d, 0x68, 0x65,
0x78, 0x20, 0x73, 0x75, 0x62, 0x6d, 0x65, 0x3d, 0x37, 0x20, 0x70, 0x73, 0x79, 0x3d, 0x31,
0x20, 0x70, 0x73, 0x79, 0x5f, 0x72, 0x64, 0x3d, 0x31, 0x2e, 0x30, 0x30, 0x3a, 0x30, 0x2e,
0x30, 0x30, 0x20, 0x6d, 0x69, 0x78, 0x65, 0x64, 0x5f, 0x72, 0x65, 0x66, 0x3d, 0x31, 0x20,
0x6d, 0x65, 0x5f, 0x72, 0x61, 0x6e, 0x67, 0x65, 0x3d, 0x31, 0x36, 0x20, 0x63, 0x68, 0x72,
0x6f, 0x6d, 0x61, 0x5f, 0x6d, 0x65, 0x3d, 0x31, 0x20, 0x74, 0x72, 0x65, 0x6c, 0x6c, 0x69,
0x73, 0x3d, 0x31, 0x20, 0x38, 0x78, 0x38, 0x64, 0x63, 0x74, 0x3d, 0x30, 0x20, 0x63, 0x71,
0x6d, 0x3d, 0x30, 0x20, 0x64, 0x65, 0x61, 0x64, 0x7a, 0x6f, 0x6e, 0x65, 0x3d, 0x32, 0x31,
0x2c, 0x31, 0x31, 0x20, 0x66, 0x61, 0x73, 0x74, 0x5f, 0x70, 0x73, 0x6b, 0x69, 0x70, 0x3d,
0x31, 0x20, 0x63, 0x68, 0x72, 0x6f, 0x6d, 0x61, 0x5f, 0x71, 0x70, 0x5f, 0x6f, 0x66, 0x66,
0x73, 0x65, 0x74, 0x3d, 0x2d, 0x32, 0x20, 0x74, 0x68, 0x72, 0x65, 0x61, 0x64, 0x73, 0x3d,
0x36, 0x30, 0x20, 0x6c, 0x6f, 0x6f, 0x6b, 0x61, 0x68, 0x65, 0x61, 0x64, 0x5f, 0x74, 0x68,
0x72, 0x65, 0x61, 0x64, 0x73, 0x3d, 0x35, 0x20, 0x73, 0x6c, 0x69, 0x63, 0x65, 0x64, 0x5f,
0x74, 0x68, 0x72, 0x65, 0x61, 0x64, 0x73, 0x3d, 0x30, 0x20, 0x6e, 0x72, 0x3d, 0x30, 0x20,
0x64, 0x65, 0x63, 0x69, 0x6d, 0x61, 0x74, 0x65, 0x3d, 0x31, 0x20, 0x69, 0x6e, 0x74, 0x65,
0x72, 0x6c, 0x61, 0x63, 0x65, 0x64, 0x3d, 0x30, 0x20, 0x62, 0x6c, 0x75, 0x72, 0x61, 0x79,
0x5f, 0x63, 0x6f, 0x6d, 0x70, 0x61, 0x74, 0x3d, 0x30, 0x20, 0x63, 0x6f, 0x6e, 0x73, 0x74,
0x72, 0x61, 0x69, 0x6e, 0x65, 0x64, 0x5f, 0x69, 0x6e, 0x74, 0x72, 0x61, 0x3d, 0x30, 0x20,
0x62, 0x66, 0x72, 0x61, 0x6d, 0x65, 0x73, 0x3d, 0x30, 0x20, 0x77, 0x65, 0x69, 0x67, 0x68,
0x74, 0x70, 0x3d, 0x30, 0x20, 0x6b, 0x65, 0x79, 0x69, 0x6e, 0x74, 0x3d, 0x32, 0x35, 0x30,
0x20, 0x6b, 0x65, 0x79, 0x69, 0x6e, 0x74, 0x5f, 0x6d, 0x69, 0x6e, 0x3d, 0x32, 0x35, 0x20,
0x73, 0x63, 0x65, 0x6e, 0x65,
};
class MediaCasListener : public ICasListener {
public:
virtual Return<void> onEvent(int32_t event, int32_t arg,
const hidl_vec<uint8_t>& data) override {
android::Mutex::Autolock autoLock(mMsgLock);
mEvent = event;
mEventArg = arg;
mEventData = data;
mEventReceived = true;
mMsgCondition.signal();
return Void();
}
virtual Return<void> onSessionEvent(const hidl_vec<uint8_t>& sessionId, int32_t event,
int32_t arg, const hidl_vec<uint8_t>& data) override {
android::Mutex::Autolock autoLock(mMsgLock);
mSessionId = sessionId;
mEvent = event;
mEventArg = arg;
mEventData = data;
mEventReceived = true;
mMsgCondition.signal();
return Void();
}
virtual Return<void> onStatusUpdate(StatusEvent event, int32_t arg) override {
android::Mutex::Autolock autoLock(mMsgLock);
mStatusEvent = event;
mEventArg = arg;
mEventReceived = true;
mMsgCondition.signal();
return Void();
}
void testEventEcho(sp<ICas>& mediaCas, int32_t& event, int32_t& eventArg,
hidl_vec<uint8_t>& eventData);
void testSessionEventEcho(sp<ICas>& mediaCas, const hidl_vec<uint8_t>& sessionId,
int32_t& event, int32_t& eventArg, hidl_vec<uint8_t>& eventData);
void testStatusUpdate(sp<ICas>& mediaCas, std::vector<uint8_t>* sessionId, SessionIntent intent,
ScramblingMode mode);
private:
int32_t mEvent = -1;
int32_t mEventArg = -1;
StatusEvent mStatusEvent;
bool mEventReceived = false;
hidl_vec<uint8_t> mEventData;
hidl_vec<uint8_t> mSessionId;
android::Mutex mMsgLock;
android::Condition mMsgCondition;
};
void MediaCasListener::testEventEcho(sp<ICas>& mediaCas, int32_t& event, int32_t& eventArg,
hidl_vec<uint8_t>& eventData) {
mEventReceived = false;
auto returnStatus = mediaCas->sendEvent(event, eventArg, eventData);
EXPECT_TRUE(returnStatus.isOk());
EXPECT_EQ(Status::OK, returnStatus);
android::Mutex::Autolock autoLock(mMsgLock);
while (!mEventReceived) {
if (-ETIMEDOUT == mMsgCondition.waitRelative(mMsgLock, WAIT_TIMEOUT)) {
EXPECT_TRUE(false) << "event not received within timeout";
return;
}
}
EXPECT_EQ(mEvent, event);
EXPECT_EQ(mEventArg, eventArg);
EXPECT_TRUE(mEventData == eventData);
}
void MediaCasListener::testSessionEventEcho(sp<ICas>& mediaCas, const hidl_vec<uint8_t>& sessionId,
int32_t& event, int32_t& eventArg,
hidl_vec<uint8_t>& eventData) {
mEventReceived = false;
auto returnStatus = mediaCas->sendSessionEvent(sessionId, event, eventArg, eventData);
EXPECT_TRUE(returnStatus.isOk());
EXPECT_EQ(Status::OK, returnStatus);
android::Mutex::Autolock autoLock(mMsgLock);
while (!mEventReceived) {
if (-ETIMEDOUT == mMsgCondition.waitRelative(mMsgLock, WAIT_TIMEOUT)) {
EXPECT_TRUE(false) << "event not received within timeout";
return;
}
}
EXPECT_TRUE(mSessionId == sessionId);
EXPECT_EQ(mEvent, event);
EXPECT_EQ(mEventArg, eventArg);
EXPECT_TRUE(mEventData == eventData);
}
void MediaCasListener::testStatusUpdate(sp<ICas>& mediaCas, std::vector<uint8_t>* sessionId,
SessionIntent intent, ScramblingMode mode) {
mEventReceived = false;
android::hardware::cas::V1_2::Status sessionStatus;
auto returnVoid = mediaCas->openSession_1_2(
intent, mode,
[&](android::hardware::cas::V1_2::Status status, const hidl_vec<uint8_t>& id) {
sessionStatus = status;
*sessionId = id;
});
EXPECT_TRUE(returnVoid.isOk());
EXPECT_EQ(android::hardware::cas::V1_2::Status::OK, sessionStatus);
android::Mutex::Autolock autoLock(mMsgLock);
while (!mEventReceived) {
if (-ETIMEDOUT == mMsgCondition.waitRelative(mMsgLock, WAIT_TIMEOUT)) {
EXPECT_TRUE(false) << "event not received within timeout";
return;
}
}
EXPECT_EQ(mStatusEvent, static_cast<StatusEvent>(intent));
EXPECT_EQ(mEventArg, static_cast<int32_t>(mode));
}
// Test environment for Cas HIDL HAL.
class CasHidlEnvironment : public ::testing::VtsHalHidlTargetTestEnvBase {
public:
// get the test environment singleton
static CasHidlEnvironment* Instance() {
static CasHidlEnvironment* instance = new CasHidlEnvironment;
return instance;
}
virtual void registerTestServices() override { registerTestService<IMediaCasService>(); }
};
class MediaCasHidlTest : public ::testing::VtsHalHidlTargetTestBase {
public:
virtual void SetUp() override {
mService = ::testing::VtsHalHidlTargetTestBase::getService<IMediaCasService>(
CasHidlEnvironment::Instance()->getServiceName<IMediaCasService>());
ASSERT_NE(mService, nullptr);
}
sp<IMediaCasService> mService;
protected:
static void description(const std::string& description) {
RecordProperty("description", description);
}
sp<ICas> mMediaCas;
sp<IDescramblerBase> mDescramblerBase;
sp<MediaCasListener> mCasListener;
typedef struct _OobInputTestParams {
const SubSample* subSamples;
uint32_t numSubSamples;
size_t imemSizeActual;
uint64_t imemOffset;
uint64_t imemSize;
uint64_t srcOffset;
uint64_t dstOffset;
} OobInputTestParams;
::testing::AssertionResult createCasPlugin(int32_t caSystemId);
::testing::AssertionResult openCasSession(std::vector<uint8_t>* sessionId);
::testing::AssertionResult openCasSession_1_2(std::vector<uint8_t>* sessionId,
SessionIntent intent, ScramblingMode mode);
::testing::AssertionResult descrambleTestInputBuffer(const sp<IDescrambler>& descrambler,
Status* descrambleStatus,
sp<IMemory>* hidlInMemory);
::testing::AssertionResult descrambleTestOobInput(const sp<IDescrambler>& descrambler,
Status* descrambleStatus,
const OobInputTestParams& params);
};
::testing::AssertionResult MediaCasHidlTest::createCasPlugin(int32_t caSystemId) {
auto status = mService->isSystemIdSupported(caSystemId);
if (!status.isOk() || !status) {
return ::testing::AssertionFailure();
}
status = mService->isDescramblerSupported(caSystemId);
if (!status.isOk() || !status) {
return ::testing::AssertionFailure();
}
mCasListener = new MediaCasListener();
auto pluginStatus = mService->createPluginExt(caSystemId, mCasListener);
if (!pluginStatus.isOk()) {
return ::testing::AssertionFailure();
}
mMediaCas = ICas::castFrom(pluginStatus);
if (mMediaCas == nullptr) {
return ::testing::AssertionFailure();
}
auto descramblerStatus = mService->createDescrambler(caSystemId);
if (!descramblerStatus.isOk()) {
return ::testing::AssertionFailure();
}
mDescramblerBase = descramblerStatus;
return ::testing::AssertionResult(mDescramblerBase != nullptr);
}
::testing::AssertionResult MediaCasHidlTest::openCasSession(std::vector<uint8_t>* sessionId) {
Status sessionStatus;
auto returnVoid = mMediaCas->openSession([&](Status status, const hidl_vec<uint8_t>& id) {
sessionStatus = status;
*sessionId = id;
});
return ::testing::AssertionResult(returnVoid.isOk() && (Status::OK == sessionStatus));
}
::testing::AssertionResult MediaCasHidlTest::descrambleTestInputBuffer(
const sp<IDescrambler>& descrambler, Status* descrambleStatus, sp<IMemory>* inMemory) {
hidl_vec<SubSample> hidlSubSamples;
hidlSubSamples.setToExternal(const_cast<SubSample*>(kSubSamples),
(sizeof(kSubSamples) / sizeof(SubSample)), false /*own*/);
sp<MemoryDealer> dealer = new MemoryDealer(sizeof(kInBinaryBuffer), "vts-cas");
if (nullptr == dealer.get()) {
ALOGE("couldn't get MemoryDealer!");
return ::testing::AssertionFailure();
}
sp<IMemory> mem = dealer->allocate(sizeof(kInBinaryBuffer));
if (nullptr == mem.get()) {
ALOGE("couldn't allocate IMemory!");
return ::testing::AssertionFailure();
}
*inMemory = mem;
// build HidlMemory from memory heap
ssize_t offset;
size_t size;
sp<IMemoryHeap> heap = mem->getMemory(&offset, &size);
if (nullptr == heap.get()) {
ALOGE("couldn't get memory heap!");
return ::testing::AssertionFailure();
}
uint8_t* ipBuffer = static_cast<uint8_t*>(static_cast<void*>(mem->unsecurePointer()));
memcpy(ipBuffer, kInBinaryBuffer, sizeof(kInBinaryBuffer));
// hidlMemory is not to be passed out of scope!
sp<HidlMemory> hidlMemory = fromHeap(heap);
SharedBuffer srcBuffer = {
.heapBase = *hidlMemory, .offset = (uint64_t)offset, .size = (uint64_t)size};
DestinationBuffer dstBuffer;
dstBuffer.type = BufferType::SHARED_MEMORY;
dstBuffer.nonsecureMemory = srcBuffer;
uint32_t outBytes;
hidl_string detailedError;
auto returnVoid = descrambler->descramble(
ScramblingControl::EVENKEY /*2*/, hidlSubSamples, srcBuffer, 0, dstBuffer, 0,
[&](Status status, uint32_t bytesWritten, const hidl_string& detailedErr) {
*descrambleStatus = status;
outBytes = bytesWritten;
detailedError = detailedErr;
});
if (!returnVoid.isOk() || *descrambleStatus != Status::OK) {
ALOGI("descramble failed, trans=%s, status=%d, outBytes=%u, error=%s",
returnVoid.description().c_str(), *descrambleStatus, outBytes, detailedError.c_str());
}
return ::testing::AssertionResult(returnVoid.isOk());
}
::testing::AssertionResult MediaCasHidlTest::descrambleTestOobInput(
const sp<IDescrambler>& descrambler, Status* descrambleStatus,
const OobInputTestParams& params) {
hidl_vec<SubSample> hidlSubSamples;
hidlSubSamples.setToExternal(const_cast<SubSample*>(params.subSamples), params.numSubSamples,
false /*own*/);
sp<MemoryDealer> dealer = new MemoryDealer(params.imemSizeActual, "vts-cas");
if (nullptr == dealer.get()) {
ALOGE("couldn't get MemoryDealer!");
return ::testing::AssertionFailure();
}
sp<IMemory> mem = dealer->allocate(params.imemSizeActual);
if (nullptr == mem.get()) {
ALOGE("couldn't allocate IMemory!");
return ::testing::AssertionFailure();
}
// build HidlMemory from memory heap
ssize_t offset;
size_t size;
sp<IMemoryHeap> heap = mem->getMemory(&offset, &size);
if (nullptr == heap.get()) {
ALOGE("couldn't get memory heap!");
return ::testing::AssertionFailure();
}
// hidlMemory is not to be passed out of scope!
sp<HidlMemory> hidlMemory = fromHeap(heap);
SharedBuffer srcBuffer = {
.heapBase = *hidlMemory,
.offset = (uint64_t)offset + params.imemOffset,
.size = (uint64_t)params.imemSize,
};
DestinationBuffer dstBuffer;
dstBuffer.type = BufferType::SHARED_MEMORY;
dstBuffer.nonsecureMemory = srcBuffer;
uint32_t outBytes;
hidl_string detailedError;
auto returnVoid = descrambler->descramble(
ScramblingControl::EVENKEY /*2*/, hidlSubSamples, srcBuffer, params.srcOffset,
dstBuffer, params.dstOffset,
[&](Status status, uint32_t bytesWritten, const hidl_string& detailedErr) {
*descrambleStatus = status;
outBytes = bytesWritten;
detailedError = detailedErr;
});
if (!returnVoid.isOk() || *descrambleStatus != Status::OK) {
ALOGI("descramble failed, trans=%s, status=%d, outBytes=%u, error=%s",
returnVoid.description().c_str(), *descrambleStatus, outBytes, detailedError.c_str());
}
return ::testing::AssertionResult(returnVoid.isOk());
}
TEST_F(MediaCasHidlTest, TestClearKeyApisWithSession) {
description("Test that valid call sequences with SessionEvent send and receive");
ASSERT_TRUE(createCasPlugin(CLEAR_KEY_SYSTEM_ID));
auto returnStatus = mMediaCas->provision(hidl_string(PROVISION_STR));
EXPECT_TRUE(returnStatus.isOk());
EXPECT_EQ(Status::OK, returnStatus);
hidl_vec<uint8_t> hidlPvtData;
hidlPvtData.resize(256);
returnStatus = mMediaCas->setPrivateData(hidlPvtData);
EXPECT_TRUE(returnStatus.isOk());
EXPECT_EQ(Status::OK, returnStatus);
std::vector<uint8_t> sessionId;
ASSERT_TRUE(openCasSession(&sessionId));
returnStatus = mMediaCas->setSessionPrivateData(sessionId, hidlPvtData);
EXPECT_TRUE(returnStatus.isOk());
EXPECT_EQ(Status::OK, returnStatus);
std::vector<uint8_t> streamSessionId;
ASSERT_TRUE(openCasSession(&streamSessionId));
returnStatus = mMediaCas->setSessionPrivateData(streamSessionId, hidlPvtData);
EXPECT_TRUE(returnStatus.isOk());
EXPECT_EQ(Status::OK, returnStatus);
returnStatus = mDescramblerBase->setMediaCasSession(sessionId);
EXPECT_TRUE(returnStatus.isOk());
EXPECT_EQ(Status::OK, returnStatus);
returnStatus = mDescramblerBase->setMediaCasSession(streamSessionId);
EXPECT_TRUE(returnStatus.isOk());
EXPECT_EQ(Status::OK, returnStatus);
hidl_vec<uint8_t> hidlNullPtr;
hidlNullPtr.setToExternal(static_cast<uint8_t*>(nullptr), 0);
returnStatus = mMediaCas->refreshEntitlements(3, hidlNullPtr);
EXPECT_TRUE(returnStatus.isOk());
EXPECT_EQ(Status::OK, returnStatus);
uint8_t refreshData[] = {0, 1, 2, 3};
hidl_vec<uint8_t> hidlRefreshData;
hidlRefreshData.setToExternal(static_cast<uint8_t*>(refreshData), sizeof(refreshData));
returnStatus = mMediaCas->refreshEntitlements(10, hidlRefreshData);
EXPECT_TRUE(returnStatus.isOk());
EXPECT_EQ(Status::OK, returnStatus);
int32_t eventID = 1;
int32_t eventArg = 2;
mCasListener->testEventEcho(mMediaCas, eventID, eventArg, hidlNullPtr);
mCasListener->testSessionEventEcho(mMediaCas, sessionId, eventID, eventArg, hidlNullPtr);
eventID = 3;
eventArg = 4;
uint8_t eventData[] = {'e', 'v', 'e', 'n', 't', 'd', 'a', 't', 'a'};
hidl_vec<uint8_t> hidlEventData;
hidlEventData.setToExternal(static_cast<uint8_t*>(eventData), sizeof(eventData));
mCasListener->testEventEcho(mMediaCas, eventID, eventArg, hidlEventData);
mCasListener->testSessionEventEcho(mMediaCas, sessionId, eventID, eventArg, hidlEventData);
SessionIntent intent = SessionIntent::LIVE;
ScramblingMode mode = ScramblingMode::DVB_CSA1;
mCasListener->testStatusUpdate(mMediaCas, &sessionId, intent, mode);
uint8_t clearKeyEmmData[] = {'c', 'l', 'e', 'a', 'r', 'k', 'e', 'y', 'e', 'm', 'm'};
hidl_vec<uint8_t> hidlClearKeyEmm;
hidlClearKeyEmm.setToExternal(static_cast<uint8_t*>(clearKeyEmmData), sizeof(clearKeyEmmData));
returnStatus = mMediaCas->processEmm(hidlClearKeyEmm);
EXPECT_TRUE(returnStatus.isOk());
EXPECT_EQ(Status::OK, returnStatus);
hidl_vec<uint8_t> hidlEcm;
hidlEcm.setToExternal(const_cast<uint8_t*>(kEcmBinaryBuffer), sizeof(kEcmBinaryBuffer));
returnStatus = mMediaCas->processEcm(sessionId, hidlEcm);
EXPECT_TRUE(returnStatus.isOk());
EXPECT_EQ(Status::OK, returnStatus);
returnStatus = mMediaCas->processEcm(streamSessionId, hidlEcm);
EXPECT_TRUE(returnStatus.isOk());
EXPECT_EQ(Status::OK, returnStatus);
EXPECT_FALSE(mDescramblerBase->requiresSecureDecoderComponent("video/avc"));
sp<IDescrambler> descrambler;
descrambler = IDescrambler::castFrom(mDescramblerBase);
ASSERT_NE(descrambler, nullptr);
Status descrambleStatus = Status::OK;
sp<IMemory> dataMemory;
ASSERT_TRUE(descrambleTestInputBuffer(descrambler, &descrambleStatus, &dataMemory));
EXPECT_EQ(Status::OK, descrambleStatus);
ASSERT_NE(nullptr, dataMemory.get());
uint8_t* opBuffer = static_cast<uint8_t*>(static_cast<void*>(dataMemory->unsecurePointer()));
int compareResult =
memcmp(static_cast<const void*>(opBuffer),
static_cast<const void*>(kOutRefBinaryBuffer), sizeof(kOutRefBinaryBuffer));
EXPECT_EQ(0, compareResult);
returnStatus = mDescramblerBase->release();
EXPECT_TRUE(returnStatus.isOk());
EXPECT_EQ(Status::OK, returnStatus);
returnStatus = mMediaCas->release();
EXPECT_TRUE(returnStatus.isOk());
EXPECT_EQ(Status::OK, returnStatus);
}
} // anonymous namespace
int main(int argc, char** argv) {
::testing::AddGlobalTestEnvironment(CasHidlEnvironment::Instance());
::testing::InitGoogleTest(&argc, argv);
CasHidlEnvironment::Instance()->init(&argc, argv);
int status = RUN_ALL_TESTS();
LOG(INFO) << "Test result = " << status;
return status;
}