Merge "Merge Android 14 QPR3 to AOSP main" into main
diff --git a/media/eco/Android.bp b/media/eco/Android.bp
index 7fcb676..2a9e2a8 100644
--- a/media/eco/Android.bp
+++ b/media/eco/Android.bp
@@ -17,15 +17,16 @@
unstable: true,
backend: {
cpp: {
+ enabled: false,
+ },
+ ndk: {
enabled: true,
+ apps_enabled: false,
additional_shared_libraries: [
"libmedia_ecoservice_ecodata",
"libbinder_ndk",
],
},
- ndk: {
- enabled: false,
- },
java: {
enabled: false,
},
@@ -49,7 +50,6 @@
shared_libs: [
"libbase",
- "libbinder",
"libbinder_ndk",
"liblog",
"libutils",
@@ -90,10 +90,9 @@
],
whole_static_libs: [
"libmedia_ecoservice_ecodata",
- "libmedia_ecoservice_aidl-cpp",
+ "libmedia_ecoservice_aidl-ndk",
],
shared_libs: [
- "libbinder",
"libbinder_ndk",
"libcutils",
"liblog",
@@ -101,7 +100,6 @@
"libcodec2_hidl@1.0",
],
export_shared_lib_headers: [
- "libbinder",
"libbinder_ndk",
],
diff --git a/media/eco/ECOData.cpp b/media/eco/ECOData.cpp
index 3d7b533..4010112 100644
--- a/media/eco/ECOData.cpp
+++ b/media/eco/ECOData.cpp
@@ -19,7 +19,8 @@
#include "eco/ECOData.h"
-#include <binder/Parcel.h>
+#include <android/binder_parcel.h>
+#include <android/binder_parcel_utils.h>
#include <inttypes.h>
#include <utils/Errors.h>
#include <utils/Log.h>
@@ -29,81 +30,76 @@
#include "eco/ECODataKey.h"
#include "eco/ECOUtils.h"
+namespace aidl {
namespace android {
namespace media {
namespace eco {
using namespace ::android;
-status_t ECOData::readFromParcel(const Parcel* parcel) {
+binder_status_t ECOData::readFromParcel(const AParcel* parcel) {
if (parcel == nullptr) {
ALOGE("readFromParcel failed. Parcel pointer can not be null");
return BAD_VALUE;
}
// Reads the data type and time.
- RETURN_STATUS_IF_ERROR(parcel->readInt32(&mDataType));
- RETURN_STATUS_IF_ERROR(parcel->readInt64(&mDataTimeUs));
+ RETURN_STATUS_IF_ERROR(AParcel_readInt32(parcel, &mDataType));
+ RETURN_STATUS_IF_ERROR(AParcel_readInt64(parcel, &mDataTimeUs));
// Reads the number of items.
uint32_t numOfItems = 0;
- RETURN_STATUS_IF_ERROR(parcel->readUint32(&numOfItems));
+ RETURN_STATUS_IF_ERROR(AParcel_readUint32(parcel, &numOfItems));
// Reads the key-value pairs one by one.
for (size_t i = 0; i < numOfItems; ++i) {
// Reads the name of the key.
- const char* name = parcel->readCString();
- if (name == NULL) {
- ALOGE("Failed reading name for the key. Parsing aborted.");
- return NAME_NOT_FOUND;
- }
+ std::string name;
+ AParcel_readString(parcel, &name, ndk::AParcel_stdStringAllocator);
int32_t type;
- RETURN_STATUS_IF_ERROR(parcel->readInt32(&type));
+ RETURN_STATUS_IF_ERROR(AParcel_readInt32(parcel, &type));
switch (static_cast<ValueType>(type)) {
case kTypeInt32: {
int32_t value32;
- RETURN_STATUS_IF_ERROR(parcel->readInt32(&value32));
- setInt32(std::string(name), value32);
+ RETURN_STATUS_IF_ERROR(AParcel_readInt32(parcel, &value32));
+ setInt32(name, value32);
break;
}
case kTypeInt64: {
int64_t value64;
- RETURN_STATUS_IF_ERROR(parcel->readInt64(&value64));
- setInt64(std::string(name), value64);
+ RETURN_STATUS_IF_ERROR(AParcel_readInt64(parcel, &value64));
+ setInt64(name, value64);
break;
}
case kTypeSize: {
int32_t valueSize;
- RETURN_STATUS_IF_ERROR(parcel->readInt32(&valueSize));
- setInt32(std::string(name), valueSize);
+ RETURN_STATUS_IF_ERROR(AParcel_readInt32(parcel, &valueSize));
+ setInt32(name, valueSize);
break;
}
case kTypeFloat: {
float valueFloat;
- RETURN_STATUS_IF_ERROR(parcel->readFloat(&valueFloat));
- setFloat(std::string(name), valueFloat);
+ RETURN_STATUS_IF_ERROR(AParcel_readFloat(parcel, &valueFloat));
+ setFloat(name, valueFloat);
break;
}
case kTypeDouble: {
double valueDouble;
- RETURN_STATUS_IF_ERROR(parcel->readDouble(&valueDouble));
- setDouble(std::string(name), valueDouble);
+ RETURN_STATUS_IF_ERROR(AParcel_readDouble(parcel, &valueDouble));
+ setDouble(name, valueDouble);
break;
}
case kTypeString: {
- const char* valueStr = parcel->readCString();
- if (valueStr == NULL) {
- ALOGE("Failed reading name for the key. Parsing aborted.");
- return NAME_NOT_FOUND;
- }
- setString(std::string(name), valueStr);
+ std::string valueString;
+ AParcel_readString(parcel, &valueString, ndk::AParcel_stdStringAllocator);
+ setString(name, valueString);
break;
}
case kTypeInt8: {
int8_t value8;
- RETURN_STATUS_IF_ERROR(parcel->readByte(&value8));
- setInt8(std::string(name), value8);
+ RETURN_STATUS_IF_ERROR(AParcel_readByte(parcel, &value8));
+ setInt8(name, value8);
break;
}
default: {
@@ -115,54 +111,57 @@
return NO_ERROR;
}
-status_t ECOData::writeToParcel(Parcel* parcel) const {
+binder_status_t ECOData::writeToParcel(AParcel* parcel) const {
if (parcel == nullptr) {
ALOGE("writeToParcel failed. Parcel pointer can not be null");
return BAD_VALUE;
}
// Writes out the data type and time.
- RETURN_STATUS_IF_ERROR(parcel->writeInt32(mDataType));
- RETURN_STATUS_IF_ERROR(parcel->writeInt64(mDataTimeUs));
+ RETURN_STATUS_IF_ERROR(AParcel_writeInt32(parcel, mDataType));
+ RETURN_STATUS_IF_ERROR(AParcel_writeInt64(parcel, mDataTimeUs));
// Writes out number of items.
- RETURN_STATUS_IF_ERROR(parcel->writeUint32(int32_t(mKeyValueStore.size())));
+ RETURN_STATUS_IF_ERROR(AParcel_writeUint32(parcel, int32_t(mKeyValueStore.size())));
// Writes out the key-value pairs one by one.
for (const auto& it : mKeyValueStore) {
// Writes out the key.
- RETURN_STATUS_IF_ERROR(parcel->writeCString(it.first.c_str()));
+ RETURN_STATUS_IF_ERROR(AParcel_writeString(parcel, it.first.c_str(),
+ static_cast<int32_t>(it.first.size())));
// Writes out the data type.
const ECODataValueType& value = it.second;
- RETURN_STATUS_IF_ERROR(parcel->writeInt32(static_cast<int32_t>(value.index())));
+ RETURN_STATUS_IF_ERROR(AParcel_writeInt32(parcel, static_cast<int32_t>(value.index())));
switch (static_cast<ValueType>(value.index())) {
case kTypeInt32:
- RETURN_STATUS_IF_ERROR(parcel->writeInt32(std::get<int32_t>(it.second)));
+ RETURN_STATUS_IF_ERROR(AParcel_writeInt32(parcel, std::get<int32_t>(it.second)));
break;
case kTypeInt64:
- RETURN_STATUS_IF_ERROR(parcel->writeInt64(std::get<int64_t>(it.second)));
+ RETURN_STATUS_IF_ERROR(AParcel_writeInt64(parcel, std::get<int64_t>(it.second)));
break;
case kTypeSize:
- RETURN_STATUS_IF_ERROR(parcel->writeUint32(std::get<size_t>(it.second)));
+ RETURN_STATUS_IF_ERROR(AParcel_writeUint32(parcel, std::get<size_t>(it.second)));
break;
case kTypeFloat:
- RETURN_STATUS_IF_ERROR(parcel->writeFloat(std::get<float>(it.second)));
+ RETURN_STATUS_IF_ERROR(AParcel_writeFloat(parcel, std::get<float>(it.second)));
break;
case kTypeDouble:
- RETURN_STATUS_IF_ERROR(parcel->writeDouble(std::get<double>(it.second)));
+ RETURN_STATUS_IF_ERROR(AParcel_writeDouble(parcel, std::get<double>(it.second)));
break;
case kTypeString:
- RETURN_STATUS_IF_ERROR(parcel->writeCString(std::get<std::string>(it.second).c_str()));
+ RETURN_STATUS_IF_ERROR(AParcel_writeString(
+ parcel, std::get<std::string>(it.second).c_str(),
+ static_cast<int32_t>(std::get<std::string>(it.second).size())));
break;
case kTypeInt8:
- RETURN_STATUS_IF_ERROR(parcel->writeByte(std::get<int8_t>(it.second)));
+ RETURN_STATUS_IF_ERROR(AParcel_writeByte(parcel, std::get<int8_t>(it.second)));
break;
default:
@@ -423,3 +422,4 @@
} // namespace eco
} // namespace media
} // namespace android
+} // namespace aidl
diff --git a/media/eco/ECODebug.cpp b/media/eco/ECODebug.cpp
index 5ed08ab..4b82025 100644
--- a/media/eco/ECODebug.cpp
+++ b/media/eco/ECODebug.cpp
@@ -16,6 +16,8 @@
#include "eco/ECODebug.h"
+#include <utils/Log.h>
+
namespace android {
namespace media {
namespace eco {
diff --git a/media/eco/ECOService.cpp b/media/eco/ECOService.cpp
index 434485f..557e24a 100644
--- a/media/eco/ECOService.cpp
+++ b/media/eco/ECOService.cpp
@@ -42,9 +42,9 @@
updateLogLevel();
}
-/*virtual*/ ::android::binder::Status ECOService::obtainSession(
+/*virtual*/ ::ndk::ScopedAStatus ECOService::obtainSession(
int32_t width, int32_t height, bool isCameraRecording,
- ::android::sp<::android::media::eco::IECOSession>* _aidl_return) {
+ std::shared_ptr<::android::media::eco::IECOSession>* _aidl_return) {
ECOLOGI("ECOService::obtainSession w: %d, h: %d, isCameraRecording: %d", width, height,
isCameraRecording);
@@ -72,18 +72,19 @@
// invalid sessions.
SanitizeSession([&](MapIterType iter) {
if (iter->first == newCfg) {
- sp<ECOSession> session = iter->second.promote();
+ std::shared_ptr<ECOSession> session = iter->second.lock();
foundSession = true;
*_aidl_return = session;
}
});
if (foundSession) {
- return binder::Status::ok();
+ return ndk::ScopedAStatus::ok();
}
// Create a new session and add it to the record.
- sp<ECOSession> newSession = ECOSession::createECOSession(width, height, isCameraRecording);
+ std::shared_ptr<ECOSession> newSession =
+ ECOSession::createECOSession(width, height, isCameraRecording);
if (newSession == nullptr) {
ECOLOGE("ECOService failed to create ECOSession w: %d, h: %d, isCameraRecording: %d", width,
height, isCameraRecording);
@@ -94,36 +95,36 @@
mSessionConfigToSessionMap[newCfg] = newSession;
ECOLOGD("session count after is %zu", mSessionConfigToSessionMap.size());
- return binder::Status::ok();
+ return ndk::ScopedAStatus::ok();
}
-/*virtual*/ ::android::binder::Status ECOService::getNumOfSessions(int32_t* _aidl_return) {
+/*virtual*/ ::ndk::ScopedAStatus ECOService::getNumOfSessions(int32_t* _aidl_return) {
Mutex::Autolock lock(mServiceLock);
SanitizeSession(std::function<void(MapIterType it)>()); // empty callback
*_aidl_return = mSessionConfigToSessionMap.size();
- return binder::Status::ok();
+ return ndk::ScopedAStatus::ok();
}
-/*virtual*/ ::android::binder::Status ECOService::getSessions(
- ::std::vector<::android::sp<::android::IBinder>>* _aidl_return) {
+/*virtual*/ ::ndk::ScopedAStatus ECOService::getSessions(
+ std::vector<::ndk::SpAIBinder>* _aidl_return) {
// Clear all the entries in the vector.
_aidl_return->clear();
Mutex::Autolock lock(mServiceLock);
SanitizeSession([&](MapIterType iter) {
- sp<ECOSession> session = iter->second.promote();
- _aidl_return->push_back(IInterface::asBinder(session));
+ std::shared_ptr<ECOSession> session = iter->second.lock();
+ _aidl_return->push_back(session->asBinder());
});
- return binder::Status::ok();
+ return ndk::ScopedAStatus::ok();
}
-inline bool isEmptySession(const android::wp<ECOSession>& entry) {
- sp<ECOSession> session = entry.promote();
+inline bool isEmptySession(const std::weak_ptr<ECOSession>& entry) {
+ std::shared_ptr<ECOSession> session = entry.lock();
return session == nullptr;
}
void ECOService::SanitizeSession(
- const std::function<void(std::unordered_map<SessionConfig, wp<ECOSession>,
+ const std::function<void(std::unordered_map<SessionConfig, std::weak_ptr<ECOSession>,
SessionConfigHash>::iterator it)>& callback) {
for (auto it = mSessionConfigToSessionMap.begin(), end = mSessionConfigToSessionMap.end();
it != end;) {
@@ -138,15 +139,15 @@
}
}
-/*virtual*/ void ECOService::binderDied(const wp<IBinder>& /*who*/) {}
+/*virtual*/ void ECOService::binderDied(const std::weak_ptr<AIBinder>& /*who*/) {}
-status_t ECOService::dump(int fd, const Vector<String16>& args) {
+status_t ECOService::dump(int fd, const std::vector<std::string>& args) {
Mutex::Autolock lock(mServiceLock);
dprintf(fd, "\n== ECO Service info: ==\n\n");
dprintf(fd, "Number of ECOServices: %zu\n", mSessionConfigToSessionMap.size());
for (auto it = mSessionConfigToSessionMap.begin(), end = mSessionConfigToSessionMap.end();
it != end; it++) {
- sp<ECOSession> session = it->second.promote();
+ std::shared_ptr<ECOSession> session = std::shared_ptr<ECOSession>(it->second);
if (session != nullptr) {
session->dump(fd, args);
}
diff --git a/media/eco/ECOServiceStatsProvider.cpp b/media/eco/ECOServiceStatsProvider.cpp
index 90f1a23..683b7a1 100644
--- a/media/eco/ECOServiceStatsProvider.cpp
+++ b/media/eco/ECOServiceStatsProvider.cpp
@@ -16,18 +16,18 @@
//#define LOG_NDEBUG 0
#define LOG_TAG "ECOServiceStatsProvider"
+#include <android/binder_manager.h>
#include <eco/ECOServiceStatsProvider.h>
-
-#include <binder/IServiceManager.h>
#include <utils/Timers.h>
namespace android {
namespace media {
namespace eco {
-ECOServiceStatsProvider::ECOServiceStatsProvider(
- int32_t width, int32_t height, bool isCameraRecording,
- android::sp<IECOSession>& session, const char* name)
+ECOServiceStatsProvider::ECOServiceStatsProvider(int32_t width, int32_t height,
+ bool isCameraRecording,
+ std::shared_ptr<IECOSession>& session,
+ const char* name)
: BnECOServiceStatsProvider(),
mWidth(width),
mHeight(height),
@@ -38,32 +38,32 @@
__func__, mWidth, mHeight, isCameraRecording, name);
}
-Status ECOServiceStatsProvider::getType(int32_t* _aidl_return) {
+ScopedAStatus ECOServiceStatsProvider::getType(int32_t* _aidl_return) {
*_aidl_return = STATS_PROVIDER_TYPE_VIDEO_ENCODER;
- return Status::ok();
+ return ScopedAStatus::ok();
}
-Status ECOServiceStatsProvider::getName(::android::String16* _aidl_return) {
- *_aidl_return = String16(mProviderName);
- return Status::ok();
+ScopedAStatus ECOServiceStatsProvider::getName(std::string* _aidl_return) {
+ *_aidl_return = std::string(mProviderName);
+ return ScopedAStatus::ok();
}
-Status ECOServiceStatsProvider::getECOSession(android::sp<::android::IBinder>* _aidl_return) {
- *_aidl_return = IInterface::asBinder(mECOSession);
- return Status::ok();
+ScopedAStatus ECOServiceStatsProvider::getECOSession(::ndk::SpAIBinder* _aidl_return) {
+ *_aidl_return = mECOSession->asBinder();
+ return ScopedAStatus::ok();
}
-Status ECOServiceStatsProvider::isCameraRecording(bool* _aidl_return) {
+ScopedAStatus ECOServiceStatsProvider::isCameraRecording(bool* _aidl_return) {
*_aidl_return = mIsCameraRecording;
- return Status::ok();
+ return ScopedAStatus::ok();
}
-void ECOServiceStatsProvider::binderDied(const wp<IBinder>& /* who */) {}
+void ECOServiceStatsProvider::binderDied(const std::weak_ptr<AIBinder>& /* who */) {}
bool ECOServiceStatsProvider::updateStats(const ECOData& data) {
bool ret = false;
if (mECOSession) {
- Status status = mECOSession->pushNewStats(data, &ret);
+ ScopedAStatus status = mECOSession->pushNewStats(data, &ret);
return ret;
}
return ret;
@@ -73,7 +73,7 @@
bool ret = false;
if (mECOSession) {
ECOData providerConfig(ECOData::DATA_TYPE_STATS_PROVIDER_CONFIG, systemTime() / 1000);
- mECOSession->addStatsProvider(this, providerConfig, &ret);
+ mECOSession->addStatsProvider(fromBinder(asBinder()), providerConfig, &ret);
return ret;
}
return ret;
@@ -82,28 +82,27 @@
bool ECOServiceStatsProvider::removeProvider() {
bool ret = false;
if (mECOSession) {
- mECOSession->removeStatsProvider(this, &ret);
+ mECOSession->removeStatsProvider(fromBinder(asBinder()), &ret);
return ret;
}
return ret;
}
-android::sp<ECOServiceStatsProvider> ECOServiceStatsProvider::create(
- int32_t width, int32_t height, bool isCameraRecording, const char* name) {
-
- android::sp<android::IServiceManager> sm = android::defaultServiceManager();
- android::sp<android::IBinder> binder = sm->getService(String16("media.ecoservice"));
-
- if (binder == nullptr) {
+std::shared_ptr<ECOServiceStatsProvider> ECOServiceStatsProvider::create(int32_t width,
+ int32_t height,
+ bool isCameraRecording,
+ const char* name) {
+ std::shared_ptr<IECOService> service = IECOService::fromBinder(
+ ndk::SpAIBinder(AServiceManager_waitForService("media.ecoservice")));
+ if (service == nullptr) {
ALOGE("Failed to connect to ecoservice");
return nullptr;
}
- android::sp<IECOService> service = android::interface_cast<IECOService>(binder);
ALOGI("Connected to ecoservice");
// Obtain the ECOSession and add the listener to the service.
- android::sp<IECOSession> session = nullptr;
+ std::shared_ptr<IECOSession> session = nullptr;
service->obtainSession(width, height, isCameraRecording, &session);
@@ -113,7 +112,8 @@
}
ALOGI("Obtained an ECO session");
- return new ECOServiceStatsProvider(width, height, isCameraRecording, session, name);
+ return ndk::SharedRefBase::make<ECOServiceStatsProvider>(width, height, isCameraRecording,
+ session, name);
}
float ECOServiceStatsProvider::getFramerate(int64_t currTimestamp) {
diff --git a/media/eco/ECOSession.cpp b/media/eco/ECOSession.cpp
index db85571..ca90b0c 100644
--- a/media/eco/ECOSession.cpp
+++ b/media/eco/ECOSession.cpp
@@ -41,8 +41,8 @@
namespace media {
namespace eco {
-using android::binder::Status;
-using android::sp;
+using ::aidl::android::media::eco::ECODataKeyValueIterator;
+using ndk::ScopedAStatus;
#define RETURN_IF_ERROR(expr) \
{ \
@@ -53,7 +53,8 @@
}
// static
-sp<ECOSession> ECOSession::createECOSession(int32_t width, int32_t height, bool isCameraRecording) {
+std::shared_ptr<ECOSession> ECOSession::createECOSession(int32_t width, int32_t height,
+ bool isCameraRecording) {
// Only support up to 1080P.
// TODO: Support the same resolution as in EAF.
if (width <= 0 || height <= 0 || width > 5120 || height > 5120 ||
@@ -62,7 +63,7 @@
height, isCameraRecording);
return nullptr;
}
- return new ECOSession(width, height, isCameraRecording);
+ return ndk::SharedRefBase::make<ECOSession>(width, height, isCameraRecording);
}
ECOSession::ECOSession(int32_t width, int32_t height, bool isCameraRecording)
@@ -124,7 +125,7 @@
// Check if there is any session info available.
ECOData sessionInfo = generateLatestSessionInfoEcoData();
if (!sessionInfo.isEmpty()) {
- Status status = mListener->onNewInfo(sessionInfo);
+ ScopedAStatus status = mListener->onNewInfo(sessionInfo);
if (!status.isOk()) {
ECOLOGE("%s: Failed to publish info: %s due to binder error", __FUNCTION__,
sessionInfo.debugString().c_str());
@@ -237,7 +238,7 @@
}
if (mListener != nullptr) {
- Status status = mListener->onNewInfo(info);
+ ScopedAStatus status = mListener->onNewInfo(info);
if (!status.isOk()) {
ECOLOGE("%s: Failed to publish info: %s due to binder error", __FUNCTION__,
info.debugString().c_str());
@@ -354,7 +355,7 @@
}
if (needToNotifyListener && mListener != nullptr) {
- Status status = mListener->onNewInfo(info);
+ ScopedAStatus status = mListener->onNewInfo(info);
if (!status.isOk()) {
ECOLOGE("%s: Failed to publish info: %s due to binder error", __FUNCTION__,
info.debugString().c_str());
@@ -364,17 +365,17 @@
}
}
-Status ECOSession::getIsCameraRecording(bool* _aidl_return) {
+ScopedAStatus ECOSession::getIsCameraRecording(bool* _aidl_return) {
std::scoped_lock<std::mutex> lock(mSessionLock);
*_aidl_return = mIsCameraRecording;
- return binder::Status::ok();
+ return ndk::ScopedAStatus::ok();
}
-Status ECOSession::addStatsProvider(
- const sp<::android::media::eco::IECOServiceStatsProvider>& provider,
+ScopedAStatus ECOSession::addStatsProvider(
+ const std::shared_ptr<::android::media::eco::IECOServiceStatsProvider>& provider,
const ::android::media::eco::ECOData& config, bool* status) {
- ::android::String16 name;
- Status result = provider->getName(&name);
+ std::string name;
+ ScopedAStatus result = provider->getName(&name);
if (!result.isOk()) {
// This binder transaction failure may due to permission issue.
*status = false;
@@ -382,7 +383,7 @@
return STATUS_ERROR(ERROR_PERMISSION_DENIED, "Failed to get provider name");
}
- ECOLOGV("Try to add stats provider name: %s uid: %d pid %d", ::android::String8(name).c_str(),
+ ECOLOGV("Try to add stats provider name: %s uid: %d pid %d", name.c_str(),
AIBinder_getCallingUid(), AIBinder_getCallingPid());
if (provider == nullptr) {
@@ -394,11 +395,10 @@
std::scoped_lock<std::mutex> lock(mSessionLock);
if (mProvider != nullptr) {
- ::android::String16 name;
+ std::string name;
mProvider->getName(&name);
- String8 errorMsg = String8::format(
- "ECOService 1.0 only supports one stats provider, current provider: %s",
- ::android::String8(name).c_str());
+ std::string errorMsg =
+ "ECOService 1.0 only supports one stats provider, current provider: " + name;
ECOLOGE("%s", errorMsg.c_str());
*status = false;
return STATUS_ERROR(ERROR_ALREADY_EXISTS, errorMsg.c_str());
@@ -414,14 +414,15 @@
mProvider = provider;
mProviderName = name;
*status = true;
- return binder::Status::ok();
+ return ndk::ScopedAStatus::ok();
}
-Status ECOSession::removeStatsProvider(
- const sp<::android::media::eco::IECOServiceStatsProvider>& provider, bool* status) {
+ScopedAStatus ECOSession::removeStatsProvider(
+ const std::shared_ptr<::android::media::eco::IECOServiceStatsProvider>& provider,
+ bool* status) {
std::scoped_lock<std::mutex> lock(mSessionLock);
// Check if the provider is the same as current provider for the session.
- if (IInterface::asBinder(provider) != IInterface::asBinder(mProvider)) {
+ if (provider->asBinder() != mProvider->asBinder()) {
*status = false;
ECOLOGE("Failed to remove provider");
return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, "Provider does not match");
@@ -429,17 +430,17 @@
mProvider = nullptr;
*status = true;
- return binder::Status::ok();
+ return ndk::ScopedAStatus::ok();
}
-Status ECOSession::addInfoListener(
- const sp<::android::media::eco::IECOServiceInfoListener>& listener,
+ScopedAStatus ECOSession::addInfoListener(
+ const std::shared_ptr<::android::media::eco::IECOServiceInfoListener>& listener,
const ::android::media::eco::ECOData& config, bool* status) {
ALOGV("%s: Add listener %p", __FUNCTION__, listener.get());
std::scoped_lock<std::mutex> lock(mSessionLock);
- ::android::String16 name;
- Status result = listener->getName(&name);
+ std::string name;
+ ScopedAStatus result = listener->getName(&name);
if (!result.isOk()) {
// This binder transaction failure may due to permission issue.
*status = false;
@@ -483,7 +484,7 @@
return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, "listener config is not valid");
}
- ECOLOGD("Info listener name: %s uid: %d pid %d", ::android::String8(name).c_str(),
+ ECOLOGD("Info listener name: %s uid: %d pid %d", name.c_str(),
AIBinder_getCallingUid(), AIBinder_getCallingPid());
mListener = listener;
@@ -492,14 +493,15 @@
mWorkerWaitCV.notify_all();
*status = true;
- return binder::Status::ok();
+ return ndk::ScopedAStatus::ok();
}
-Status ECOSession::removeInfoListener(
- const sp<::android::media::eco::IECOServiceInfoListener>& listener, bool* _aidl_return) {
+ScopedAStatus ECOSession::removeInfoListener(
+ const std::shared_ptr<::android::media::eco::IECOServiceInfoListener>& listener,
+ bool* _aidl_return) {
std::scoped_lock<std::mutex> lock(mSessionLock);
// Check if the listener is the same as current listener for the session.
- if (IInterface::asBinder(listener) != IInterface::asBinder(mListener)) {
+ if (listener->asBinder() != mListener->asBinder()) {
*_aidl_return = false;
ECOLOGE("Failed to remove listener");
return STATUS_ERROR(ERROR_ILLEGAL_ARGUMENT, "Listener does not match");
@@ -508,47 +510,44 @@
mListener = nullptr;
mNewListenerAdded = false;
*_aidl_return = true;
- return binder::Status::ok();
+ return ndk::ScopedAStatus::ok();
}
-Status ECOSession::pushNewStats(const ::android::media::eco::ECOData& stats, bool* _aidl_return) {
+ScopedAStatus ECOSession::pushNewStats(const ::android::media::eco::ECOData& stats,
+ bool* _aidl_return) {
ECOLOGV("ECOSession get new stats type: %s", stats.getDataTypeString().c_str());
std::unique_lock<std::mutex> lock(mStatsQueueLock);
mStatsQueue.push_back(stats);
mWorkerWaitCV.notify_all();
*_aidl_return = true;
- return binder::Status::ok();
+ return ndk::ScopedAStatus::ok();
}
-Status ECOSession::getWidth(int32_t* _aidl_return) {
+ScopedAStatus ECOSession::getWidth(int32_t* _aidl_return) {
std::scoped_lock<std::mutex> lock(mSessionLock);
*_aidl_return = mWidth;
- return binder::Status::ok();
+ return ndk::ScopedAStatus::ok();
}
-Status ECOSession::getHeight(int32_t* _aidl_return) {
+ScopedAStatus ECOSession::getHeight(int32_t* _aidl_return) {
std::scoped_lock<std::mutex> lock(mSessionLock);
*_aidl_return = mHeight;
- return binder::Status::ok();
+ return ndk::ScopedAStatus::ok();
}
-Status ECOSession::getNumOfListeners(int32_t* _aidl_return) {
+ScopedAStatus ECOSession::getNumOfListeners(int32_t* _aidl_return) {
std::scoped_lock<std::mutex> lock(mSessionLock);
*_aidl_return = (mListener == nullptr ? 0 : 1);
- return binder::Status::ok();
+ return ndk::ScopedAStatus::ok();
}
-Status ECOSession::getNumOfProviders(int32_t* _aidl_return) {
+ScopedAStatus ECOSession::getNumOfProviders(int32_t* _aidl_return) {
std::scoped_lock<std::mutex> lock(mSessionLock);
*_aidl_return = (mProvider == nullptr ? 0 : 1);
- return binder::Status::ok();
+ return ndk::ScopedAStatus::ok();
}
-/*virtual*/ void ECOSession::binderDied(const wp<IBinder>& /*who*/) {
- ECOLOGV("binderDied");
-}
-
-status_t ECOSession::dump(int fd, const Vector<String16>& /*args*/) {
+status_t ECOSession::dump(int fd, const std::vector<std::string>& /*args*/) {
std::scoped_lock<std::mutex> lock(mSessionLock);
dprintf(fd, "\n== Session Info: ==\n\n");
dprintf(fd,
@@ -557,10 +556,10 @@
mWidth, mHeight, mIsCameraRecording, mTargetBitrateBps, mCodecType, mCodecProfile,
mCodecLevel);
if (mProvider != nullptr) {
- dprintf(fd, "Provider: %s \n", ::android::String8(mProviderName).c_str());
+ dprintf(fd, "Provider: %s \n", mProviderName.c_str());
}
if (mListener != nullptr) {
- dprintf(fd, "Listener: %s \n", ::android::String8(mListenerName).c_str());
+ dprintf(fd, "Listener: %s \n", mListenerName.c_str());
}
dprintf(fd, "\n===================\n\n");
diff --git a/media/eco/ECOUtils.cpp b/media/eco/ECOUtils.cpp
index ab82252..93372bb 100644
--- a/media/eco/ECOUtils.cpp
+++ b/media/eco/ECOUtils.cpp
@@ -50,12 +50,6 @@
return data;
}
-bool copyKeyValue(const ECOData& src, ECOData* dst) {
- if (src.isEmpty() || dst == nullptr) return false;
- dst->mKeyValueStore = src.mKeyValueStore;
- return true;
-}
-
} // namespace eco
} // namespace media
} // namespace android
\ No newline at end of file
diff --git a/media/eco/aidl/android/media/eco/ECOData.aidl b/media/eco/aidl/android/media/eco/ECOData.aidl
index 162cd89..c34a57d 100644
--- a/media/eco/aidl/android/media/eco/ECOData.aidl
+++ b/media/eco/aidl/android/media/eco/ECOData.aidl
@@ -17,4 +17,4 @@
package android.media.eco;
/** @hide */
-parcelable ECOData cpp_header "eco/ECOData.h";
\ No newline at end of file
+parcelable ECOData ndk_header "eco/ECOData.h";
diff --git a/media/eco/aidl/android/media/eco/IECOServiceInfoListener.aidl b/media/eco/aidl/android/media/eco/IECOServiceInfoListener.aidl
index bf5bd88..12dc649 100644
--- a/media/eco/aidl/android/media/eco/IECOServiceInfoListener.aidl
+++ b/media/eco/aidl/android/media/eco/IECOServiceInfoListener.aidl
@@ -17,7 +17,6 @@
package android.media.eco;
import android.media.eco.ECOData;
-import android.os.IBinder;
/**
* Binder interface for ECO service information listener.
@@ -60,4 +59,4 @@
* Handle the new info from ECOSession. This should only be called by ECOSession.
*/
oneway void onNewInfo(in ECOData newInfo);
-}
\ No newline at end of file
+}
diff --git a/media/eco/aidl/android/media/eco/IECOServiceStatsProvider.aidl b/media/eco/aidl/android/media/eco/IECOServiceStatsProvider.aidl
index 6e2f9c3..32f23be 100644
--- a/media/eco/aidl/android/media/eco/IECOServiceStatsProvider.aidl
+++ b/media/eco/aidl/android/media/eco/IECOServiceStatsProvider.aidl
@@ -16,7 +16,6 @@
package android.media.eco;
-import android.os.IBinder;
/**
* An interface for providers that provides various statistics to ECO service.
diff --git a/media/eco/include/eco/ECOData.h b/media/eco/include/eco/ECOData.h
index 737235a..a06f0e6 100644
--- a/media/eco/include/eco/ECOData.h
+++ b/media/eco/include/eco/ECOData.h
@@ -17,13 +17,15 @@
#ifndef ANDROID_MEDIA_ECO_DATA_H_
#define ANDROID_MEDIA_ECO_DATA_H_
-#include <binder/Parcel.h>
-#include <binder/Parcelable.h>
+#include <android/binder_auto_utils.h>
+#include <android/binder_parcel.h>
+#include <android/binder_status.h>
#include <string>
#include <unordered_map>
#include <variant>
+namespace aidl {
namespace android {
namespace media {
namespace eco {
@@ -71,7 +73,7 @@
* // Set encoding bitrate.
* data->setInt32("stats-encoder-target-bitrate-bps", 22000000);
*/
-class ECOData : public Parcelable {
+class ECOData {
public:
using ECODataValueType =
std::variant<int32_t, int64_t, size_t, float, double, std::string, int8_t>;
@@ -130,8 +132,8 @@
/**
* Serialization over Binder
*/
- status_t readFromParcel(const Parcel* parcel) override;
- status_t writeToParcel(Parcel* parcel) const override;
+ binder_status_t readFromParcel(const AParcel* parcel);
+ binder_status_t writeToParcel(AParcel* parcel) const;
/* Returns the type of the data. */
int32_t getDataType() const;
@@ -191,6 +193,12 @@
template <typename T>
ECODataStatus findValue(const std::string& key, T* out) const;
+
+ static bool copyKeyValue(const ECOData& src, ECOData* dst) {
+ if (src.isEmpty() || dst == nullptr) return false;
+ dst->mKeyValueStore = src.mKeyValueStore;
+ return true;
+ }
};
// A simple ECOData iterator that will iterate over all the key value paris in ECOData.
@@ -217,5 +225,6 @@
} // namespace eco
} // namespace media
} // namespace android
+} // namespace aidl
#endif // ANDROID_MEDIA_ECO_DATA_H_
diff --git a/media/eco/include/eco/ECODataKey.h b/media/eco/include/eco/ECODataKey.h
index c70c328..bcae6c9 100644
--- a/media/eco/include/eco/ECODataKey.h
+++ b/media/eco/include/eco/ECODataKey.h
@@ -17,8 +17,8 @@
#define ANDROID_MEDIA_ECO_DATA_KEY_H_
#include <android-base/unique_fd.h>
-#include <binder/Parcel.h>
-#include <binder/Parcelable.h>
+#include <android/binder_auto_utils.h>
+#include <android/binder_parcel.h>
#include <stdint.h>
#include <sys/mman.h>
diff --git a/media/eco/include/eco/ECODebug.h b/media/eco/include/eco/ECODebug.h
index ff0e8b5..520a013 100644
--- a/media/eco/include/eco/ECODebug.h
+++ b/media/eco/include/eco/ECODebug.h
@@ -25,6 +25,8 @@
namespace android {
namespace media {
namespace eco {
+using aidl::android::media::eco::ECOData;
+using aidl::android::media::eco::ECODataStatus;
static const char* kDisableEcoServiceProperty = "vendor.media.ecoservice.disable";
static const char* kDebugLogsLevelProperty = "vendor.media.ecoservice.log.level";
@@ -52,14 +54,10 @@
void updateLogLevel();
// Convenience methods for constructing binder::Status objects for error returns
-#define STATUS_ERROR(errorCode, errorString) \
- binder::Status::fromServiceSpecificError( \
- errorCode, String8::format("%s:%d: %s", __FUNCTION__, __LINE__, errorString))
+#define STATUS_ERROR(errorCode, errorString) ndk::ScopedAStatus::fromServiceSpecificError(errorCode)
#define STATUS_ERROR_FMT(errorCode, errorString, ...) \
- binder::Status::fromServiceSpecificError( \
- errorCode, \
- String8::format("%s:%d: " errorString, __FUNCTION__, __LINE__, __VA_ARGS__))
+ ndk::ScopedAStatus::fromServiceSpecificError(errorCode)
} // namespace eco
} // namespace media
diff --git a/media/eco/include/eco/ECOService.h b/media/eco/include/eco/ECOService.h
index d0d732a..f528949 100644
--- a/media/eco/include/eco/ECOService.h
+++ b/media/eco/include/eco/ECOService.h
@@ -17,8 +17,10 @@
#ifndef ANDROID_MEDIA_ECO_SERVICE_H_
#define ANDROID_MEDIA_ECO_SERVICE_H_
-#include <android/media/eco/BnECOService.h>
-#include <binder/IServiceManager.h>
+#include <aidl/android/media/eco/BnECOService.h>
+#include <android/binder_manager.h>
+#include <android/binder_process.h>
+#include <utils/Log.h>
#include <utils/Mutex.h>
#include <list>
@@ -30,9 +32,11 @@
namespace media {
namespace eco {
-using android::sp;
-using android::binder::Status;
+using aidl::android::media::eco::BnECOService;
+using aidl::android::media::eco::ECOData;
+using aidl::android::media::eco::ECODataStatus;
using android::media::eco::ECOSession;
+using ndk::ScopedAStatus;
/**
* ECO (Encoder Camera Optimization) service.
@@ -50,36 +54,36 @@
* ECOServiceStatsProvider and ECOServiceInfoListener should remove themselves from ECOSession.
* Then ECOService will safely destroy the ECOSession.
*/
-class ECOService : public BnECOService,
- public virtual IBinder::DeathRecipient {
+class ECOService : public BnECOService {
+ using ::ndk::ICInterface::dump;
public:
ECOService();
virtual ~ECOService() = default;
- virtual Status obtainSession(int32_t width, int32_t height, bool isCameraRecording,
- sp<IECOSession>* _aidl_return);
+ virtual ScopedAStatus obtainSession(int32_t width, int32_t height, bool isCameraRecording,
+ std::shared_ptr<IECOSession>* _aidl_return);
- virtual Status getNumOfSessions(int32_t* _aidl_return);
+ virtual ScopedAStatus getNumOfSessions(int32_t* _aidl_return);
- virtual Status getSessions(::std::vector<sp<IBinder>>* _aidl_return);
+ virtual ScopedAStatus getSessions(std::vector<::ndk::SpAIBinder>* _aidl_return);
static status_t instantiate() {
- bool allowIsolated = false;
- int dumpFlags = IServiceManager::DUMP_FLAG_PRIORITY_DEFAULT;
- sp<IServiceManager> sm(defaultServiceManager());
- return sm->addService(String16(getServiceName()), new ECOService(), allowIsolated,
- dumpFlags);
+ std::shared_ptr<ECOService> service = ::ndk::SharedRefBase::make<ECOService>();
+ binder_status_t status =
+ AServiceManager_addService(service->asBinder().get(), getServiceName());
+ ABinderProcess_startThreadPool();
+ return (status == EX_NONE) ? STATUS_OK : STATUS_UNKNOWN_ERROR;
}
// Implementation of BinderService<T>
static char const* getServiceName() { return "media.ecoservice"; }
// IBinder::DeathRecipient implementation
- virtual void binderDied(const wp<IBinder>& who);
+ virtual void binderDied(const std::weak_ptr<AIBinder>& who);
- virtual status_t dump(int fd, const Vector<String16>& args);
+ virtual status_t dump(int fd, const std::vector<std::string>& args);
private:
// Lock guarding ECO service state
@@ -114,10 +118,11 @@
};
// Map from SessionConfig to session.
- std::unordered_map<SessionConfig, wp<ECOSession>, SessionConfigHash> mSessionConfigToSessionMap;
+ std::unordered_map<SessionConfig, std::weak_ptr<ECOSession>, SessionConfigHash>
+ mSessionConfigToSessionMap;
- using MapIterType =
- std::unordered_map<SessionConfig, wp<ECOSession>, SessionConfigHash>::iterator;
+ using MapIterType = std::unordered_map<SessionConfig, std::weak_ptr<ECOSession>,
+ SessionConfigHash>::iterator;
// A helpful function to traverse the mSessionConfigToSessionMap, remove the entry that
// does not exist any more and call |callback| when the entry is valid.
diff --git a/media/eco/include/eco/ECOServiceInfoListener.h b/media/eco/include/eco/ECOServiceInfoListener.h
index 86d379f..448bab2 100644
--- a/media/eco/include/eco/ECOServiceInfoListener.h
+++ b/media/eco/include/eco/ECOServiceInfoListener.h
@@ -17,8 +17,8 @@
#ifndef ANDROID_MEDIA_ECO_SERVICE_INFO_LISTENER_H_
#define ANDROID_MEDIA_ECO_SERVICE_INFO_LISTENER_H_
-#include <android/media/eco/BnECOServiceInfoListener.h>
-#include <android/media/eco/IECOSession.h>
+#include <aidl/android/media/eco/BnECOServiceInfoListener.h>
+#include <aidl/android/media/eco/IECOSession.h>
#include <condition_variable>
#include <memory>
@@ -31,27 +31,28 @@
namespace media {
namespace eco {
-using ::android::binder::Status;
+using aidl::android::media::eco::BnECOServiceInfoListener;
+using aidl::android::media::eco::ECOData;
+using aidl::android::media::eco::ECODataStatus;
+using ::ndk::ScopedAStatus;
/**
* ECOServiceInfoListener interface class.
*/
-class ECOServiceInfoListener : public BnECOServiceInfoListener,
- public virtual IBinder::DeathRecipient {
-
+class ECOServiceInfoListener : public BnECOServiceInfoListener {
public:
// Create a ECOServiceInfoListener with specifed width, height and isCameraRecording.
ECOServiceInfoListener(int32_t width, int32_t height, bool isCameraRecording);
virtual ~ECOServiceInfoListener() {}
- virtual Status getType(int32_t* _aidl_return) = 0;
- virtual Status getName(::android::String16* _aidl_return) = 0;
- virtual Status getECOSession(::android::sp<::android::IBinder>* _aidl_return) = 0;
- virtual Status onNewInfo(const ::android::media::eco::ECOData& newInfo) = 0;
+ virtual ScopedAStatus getType(int32_t* _aidl_return) = 0;
+ virtual ScopedAStatus getName(std::string* _aidl_return) = 0;
+ virtual ScopedAStatus getECOSession(::ndk::SpAIBinder* _aidl_return) = 0;
+ virtual ScopedAStatus onNewInfo(const ::android::media::eco::ECOData& newInfo) = 0;
// IBinder::DeathRecipient implementation.
- virtual void binderDied(const wp<IBinder>& who);
+ virtual void binderDied(const std::weak_ptr<AIBinder>& who);
private:
};
diff --git a/media/eco/include/eco/ECOServiceStatsProvider.h b/media/eco/include/eco/ECOServiceStatsProvider.h
index c81f0b8..b7cf4f2 100644
--- a/media/eco/include/eco/ECOServiceStatsProvider.h
+++ b/media/eco/include/eco/ECOServiceStatsProvider.h
@@ -17,9 +17,10 @@
#ifndef ANDROID_MEDIA_ECO_SERVICE_STATS_PROVIDER_H_
#define ANDROID_MEDIA_ECO_SERVICE_STATS_PROVIDER_H_
-#include <android/media/eco/BnECOServiceStatsProvider.h>
-#include <android/media/eco/IECOSession.h>
-#include <android/media/eco/IECOService.h>
+#include <aidl/android/media/eco/BnECOServiceStatsProvider.h>
+#include <aidl/android/media/eco/IECOService.h>
+#include <aidl/android/media/eco/IECOSession.h>
+#include <utils/Log.h>
#include <condition_variable>
#include <memory>
@@ -33,39 +34,43 @@
namespace media {
namespace eco {
-using ::android::binder::Status;
+using aidl::android::media::eco::BnECOServiceStatsProvider;
+using aidl::android::media::eco::ECOData;
+using aidl::android::media::eco::ECODataStatus;
+using aidl::android::media::eco::IECOService;
+using aidl::android::media::eco::IECOSession;
+using ::ndk::ScopedAStatus;
/**
* ECOServiceStatsProvider interface class.
*/
-class ECOServiceStatsProvider : public BnECOServiceStatsProvider,
- public virtual IBinder::DeathRecipient {
-
+class ECOServiceStatsProvider : public BnECOServiceStatsProvider {
public:
+ ECOServiceStatsProvider(int32_t width, int32_t height, bool isCameraRecording,
+ std::shared_ptr<IECOSession>& session, const char* name);
virtual ~ECOServiceStatsProvider() {}
- virtual Status getType(int32_t* _aidl_return);
- virtual Status getName(::android::String16* _aidl_return);
- virtual Status getECOSession(::android::sp<::android::IBinder>* _aidl_return);
- virtual Status isCameraRecording(bool* _aidl_return);
+ virtual ScopedAStatus getType(int32_t* _aidl_return);
+ virtual ScopedAStatus getName(std::string* _aidl_return);
+ virtual ScopedAStatus getECOSession(::ndk::SpAIBinder* _aidl_return);
+ virtual ScopedAStatus isCameraRecording(bool* _aidl_return);
// IBinder::DeathRecipient implementation
- virtual void binderDied(const wp<IBinder>& who);
+ virtual void binderDied(const std::weak_ptr<AIBinder>& who);
bool updateStats(const ECOData& data);
bool addProvider();
bool removeProvider();
float getFramerate(int64_t currTimestamp);
- static android::sp<ECOServiceStatsProvider> create(
- int32_t width, int32_t height, bool isCameraRecording, const char* name);
+ static std::shared_ptr<ECOServiceStatsProvider> create(int32_t width, int32_t height,
+ bool isCameraRecording,
+ const char* name);
private:
- ECOServiceStatsProvider(int32_t width, int32_t height, bool isCameraRecording,
- android::sp<IECOSession>& session, const char* name);
int32_t mWidth = 0;
int32_t mHeight = 0;
bool mIsCameraRecording = false;
- android::sp<IECOSession> mECOSession = nullptr;
+ std::shared_ptr<IECOSession> mECOSession = nullptr;
const char* mProviderName = nullptr;
int64_t mLastFrameTimestamp = 0;
};
diff --git a/media/eco/include/eco/ECOSession.h b/media/eco/include/eco/ECOSession.h
index 9fb0bdc..57965a7 100644
--- a/media/eco/include/eco/ECOSession.h
+++ b/media/eco/include/eco/ECOSession.h
@@ -17,8 +17,9 @@
#ifndef ANDROID_MEDIA_ECO_SESSION_H_
#define ANDROID_MEDIA_ECO_SESSION_H_
-#include <android/media/eco/BnECOSession.h>
-#include <android/media/eco/IECOServiceStatsProvider.h>
+#include <aidl/android/media/eco/BnECOSession.h>
+#include <aidl/android/media/eco/IECOServiceInfoListener.h>
+#include <aidl/android/media/eco/IECOServiceStatsProvider.h>
#include <condition_variable>
#include <deque>
@@ -36,8 +37,12 @@
namespace media {
namespace eco {
-using ::android::binder::Status;
-
+using aidl::android::media::eco::BnECOSession;
+using aidl::android::media::eco::ECOData;
+using aidl::android::media::eco::ECODataStatus;
+using aidl::android::media::eco::IECOServiceInfoListener;
+using aidl::android::media::eco::IECOServiceStatsProvider;
+using ::ndk::ScopedAStatus;
/**
* ECO Session.
*
@@ -46,37 +51,40 @@
* it only supports resolution of up to 720P and only for camera recording use case. Also, it only
* supports encoder as the provider and camera as listener.
*/
-class ECOSession : public BnECOSession,
- public virtual IBinder::DeathRecipient {
+class ECOSession : public BnECOSession {
+ using ::ndk::ICInterface::dump;
public:
+ // Only the ECOService could create ECOSession.
+ ECOSession(int32_t width, int32_t height, bool isCameraRecording);
+
virtual ~ECOSession();
- virtual Status addStatsProvider(const sp<IECOServiceStatsProvider>& provider,
- const ECOData& statsConfig, /*out*/ bool* status);
+ virtual ScopedAStatus addStatsProvider(
+ const std::shared_ptr<IECOServiceStatsProvider>& provider, const ECOData& statsConfig,
+ /*out*/ bool* status);
- virtual Status removeStatsProvider(const sp<IECOServiceStatsProvider>&, bool*);
+ virtual ScopedAStatus removeStatsProvider(const std::shared_ptr<IECOServiceStatsProvider>&,
+ bool*);
- virtual Status addInfoListener(const sp<IECOServiceInfoListener>&,
- const ECOData& listenerConfig,
- /*out*/ bool* status);
+ virtual ScopedAStatus addInfoListener(const std::shared_ptr<IECOServiceInfoListener>&,
+ const ECOData& listenerConfig,
+ /*out*/ bool* status);
- virtual Status removeInfoListener(const sp<IECOServiceInfoListener>&, bool*);
+ virtual ScopedAStatus removeInfoListener(const std::shared_ptr<IECOServiceInfoListener>&,
+ bool*);
- virtual Status pushNewStats(const ECOData&, bool*);
+ virtual ScopedAStatus pushNewStats(const ECOData&, bool*);
- virtual Status getWidth(int32_t* _aidl_return);
+ virtual ScopedAStatus getWidth(int32_t* _aidl_return);
- virtual Status getHeight(int32_t* _aidl_return);
+ virtual ScopedAStatus getHeight(int32_t* _aidl_return);
- virtual Status getIsCameraRecording(bool*);
+ virtual ScopedAStatus getIsCameraRecording(bool*);
- virtual Status getNumOfListeners(int32_t*);
+ virtual ScopedAStatus getNumOfListeners(int32_t*);
- virtual Status getNumOfProviders(int32_t*);
-
- // IBinder::DeathRecipient implementation
- virtual void binderDied(const wp<IBinder>& who);
+ virtual ScopedAStatus getNumOfProviders(int32_t*);
// Grant permission to EcoSessionTest to run test.
friend class EcoSessionTest;
@@ -85,14 +93,11 @@
friend class ECOService;
protected:
- static android::sp<ECOSession> createECOSession(int32_t width, int32_t height,
- bool isCameraRecording);
+ static std::shared_ptr<ECOSession> createECOSession(int32_t width, int32_t height,
+ bool isCameraRecording);
private:
- // Only the ECOService could create ECOSession.
- ECOSession(int32_t width, int32_t height, bool isCameraRecording);
-
- virtual status_t dump(int fd, const Vector<String16>& args);
+ virtual status_t dump(int fd, const std::vector<std::string>& args);
// Start the main thread for processing the stats and pushing info to listener.
static void startThread(ECOSession* session);
@@ -133,11 +138,11 @@
} QpCondition;
QpCondition mListenerQpCondition;
- android::sp<IECOServiceInfoListener> mListener;
- String16 mListenerName;
+ std::shared_ptr<IECOServiceInfoListener> mListener;
+ std::string mListenerName;
- android::sp<IECOServiceStatsProvider> mProvider;
- String16 mProviderName;
+ std::shared_ptr<IECOServiceStatsProvider> mProvider;
+ std::string mProviderName;
// Main thread for processing the events from provider.
std::thread mThread;
diff --git a/media/eco/include/eco/ECOUtils.h b/media/eco/include/eco/ECOUtils.h
index e5bbfcc..1a266c9 100644
--- a/media/eco/include/eco/ECOUtils.h
+++ b/media/eco/include/eco/ECOUtils.h
@@ -28,6 +28,8 @@
namespace android {
namespace media {
namespace eco {
+using aidl::android::media::eco::ECOData;
+using aidl::android::media::eco::ECODataStatus;
#define RETURN_STATUS_IF_ERROR(expr) \
{ \
@@ -121,8 +123,6 @@
ECOData toEcoData(ECOData::ECODatatype dataType);
};
-bool copyKeyValue(const ECOData& src, ECOData* dst);
-
} // namespace eco
} // namespace media
} // namespace android
diff --git a/media/eco/tests/Android.bp b/media/eco/tests/Android.bp
index 99c93cd..54ca426 100644
--- a/media/eco/tests/Android.bp
+++ b/media/eco/tests/Android.bp
@@ -10,8 +10,8 @@
"-Wall",
"-Werror",
],
+
shared_libs: [
- "libbinder",
"libbinder_ndk",
"libcutils",
"libutils",
diff --git a/media/eco/tests/EcoDataTest.cpp b/media/eco/tests/EcoDataTest.cpp
index f93b692..835e4f7 100644
--- a/media/eco/tests/EcoDataTest.cpp
+++ b/media/eco/tests/EcoDataTest.cpp
@@ -20,8 +20,8 @@
#define LOG_TAG "ECODataTest"
#include <android-base/unique_fd.h>
-#include <binder/Parcel.h>
-#include <binder/Parcelable.h>
+#include <android/binder_parcel.h>
+#include <android/binder_status.h>
#include <cutils/ashmem.h>
#include <gtest/gtest.h>
#include <math.h>
@@ -35,6 +35,8 @@
namespace android {
namespace media {
namespace eco {
+using aidl::android::media::eco::ECOData;
+using aidl::android::media::eco::ECODataStatus;
TEST(EcoDataTest, TestConstructor1) {
std::unique_ptr<ECOData> data = std::make_unique<ECOData>();
@@ -302,16 +304,16 @@
sourceData->set(it->first, it->second);
}
- std::unique_ptr<Parcel> parcel = std::make_unique<Parcel>();
- EXPECT_TRUE(sourceData->writeToParcel(parcel.get()) == NO_ERROR);
+ AParcel* parcel = AParcel_create();
+ EXPECT_TRUE(sourceData->writeToParcel(parcel) == STATUS_OK);
// Rewind the data position of the parcel for this test. Otherwise, the following read will not
// start from the beginning.
- parcel->setDataPosition(0);
+ AParcel_setDataPosition(parcel, 0);
// Reads the parcel back into a new ECOData
std::unique_ptr<ECOData> dstData = std::make_unique<ECOData>();
- EXPECT_TRUE(dstData->readFromParcel(parcel.get()) == NO_ERROR);
+ EXPECT_TRUE(dstData->readFromParcel(parcel) == STATUS_OK);
// Checks the data type, time and number of entries.
EXPECT_EQ(sourceData->getNumOfEntries(), dstData->getNumOfEntries());
@@ -331,8 +333,7 @@
std::unique_ptr<ECOData> sourceData = std::make_unique<ECOData>(kDataType, kDataTimeUs);
- std::unique_ptr<Parcel> parcel = std::make_unique<Parcel>();
- EXPECT_TRUE(sourceData->writeToParcel(nullptr) != NO_ERROR);
+ EXPECT_TRUE(sourceData->writeToParcel(nullptr) != STATUS_OK);
}
TEST(EcoDataTest, TestReadInvalidParcel) {
@@ -348,20 +349,21 @@
sourceData->set(it->first, it->second);
}
- std::unique_ptr<Parcel> parcel = std::make_unique<Parcel>();
- EXPECT_TRUE(sourceData->writeToParcel(parcel.get()) == NO_ERROR);
+ AParcel* parcel = AParcel_create();
+ EXPECT_TRUE(sourceData->writeToParcel(parcel) == STATUS_OK);
// Corrupt the parcel by write random data to the beginning.
- parcel->setDataPosition(4);
- parcel->writeCString("invalid-data");
+ AParcel_setDataPosition(parcel, 4);
+ char* invalid_string = (char*)"invalid-data";
+ AParcel_writeString(parcel, invalid_string, strlen(invalid_string));
- parcel->setDataPosition(0);
+ AParcel_setDataPosition(parcel, 0);
// Reads the parcel back into a new ECOData
std::unique_ptr<ECOData> dstData = std::make_unique<ECOData>();
- EXPECT_TRUE(dstData->readFromParcel(parcel.get()) != NO_ERROR);
+ EXPECT_TRUE(dstData->readFromParcel(parcel) != STATUS_OK);
}
} // namespace eco
} // namespace media
-} // namespace android
\ No newline at end of file
+} // namespace android
diff --git a/media/eco/tests/EcoServiceTest.cpp b/media/eco/tests/EcoServiceTest.cpp
index df54c53..8a8bbbf 100644
--- a/media/eco/tests/EcoServiceTest.cpp
+++ b/media/eco/tests/EcoServiceTest.cpp
@@ -20,9 +20,9 @@
#define LOG_TAG "ECOServiceTest"
#include <android-base/unique_fd.h>
-#include <binder/Parcel.h>
-#include <binder/Parcelable.h>
-#include <binder/IServiceManager.h>
+#include <android/binder_auto_utils.h>
+#include <android/binder_manager.h>
+#include <android/binder_parcel.h>
#include <cutils/ashmem.h>
#include <gtest/gtest.h>
#include <math.h>
@@ -40,9 +40,7 @@
namespace media {
namespace eco {
-using ::android::IBinder;
-using android::sp;
-using ::android::binder::Status;
+using ::ndk::ScopedAStatus;
namespace {
@@ -58,106 +56,101 @@
public:
EcoServiceTest() { ALOGD("EcoServiceTest created"); }
- sp<IECOService> createService() {
- android::sp<android::IServiceManager> sm = android::defaultServiceManager();
- assert(sm != 0);
- android::sp<android::IBinder> binder = sm->getService(String16("media.ecoservice"));
-
- if (binder == 0) {
+ std::shared_ptr<IECOService> createService() {
+ mECOService = IECOService::fromBinder(
+ ndk::SpAIBinder(AServiceManager_waitForService("media.ecoservice")));
+ if (mECOService == nullptr) {
ALOGE("Failed to connect to ecoservice");
return nullptr;
- } else {
- ALOGD("Successfully connect to ecoservice");
}
- mECOService = android::interface_cast<IECOService>(binder);
return mECOService;
}
~EcoServiceTest() { ALOGD("EcoServiceTest destroyed"); }
private:
- sp<IECOService> mECOService = nullptr;
+ std::shared_ptr<IECOService> mECOService = nullptr;
};
TEST_F(EcoServiceTest, NormalObtainSessionWithInvalidWidth) {
- sp<IECOService> service = createService();
+ std::shared_ptr<IECOService> service = createService();
EXPECT_TRUE(service != nullptr);
// Provider obtains the session from the service.
- sp<IECOSession> session = nullptr;
+ std::shared_ptr<IECOSession> session = nullptr;
service->obtainSession(-1 /* width */, kTestHeight, kIsCameraRecording, &session);
EXPECT_FALSE(session);
}
TEST_F(EcoServiceTest, NormalObtainSessionWithInvalidHeight) {
- sp<IECOService> service = createService();
+ std::shared_ptr<IECOService> service = createService();
// Provider obtains the session from the service.
- sp<IECOSession> session = nullptr;
+ std::shared_ptr<IECOSession> session = nullptr;
service->obtainSession(kTestWidth, -1 /* height */, kIsCameraRecording, &session);
EXPECT_FALSE(session);
}
TEST_F(EcoServiceTest, NormalObtainSessionWithCameraRecordingFalse) {
- sp<IECOService> service = createService();
+ std::shared_ptr<IECOService> service = createService();
// Provider obtains the session from the service.
- sp<IECOSession> session = nullptr;
+ std::shared_ptr<IECOSession> session = nullptr;
service->obtainSession(kTestWidth, kTestHeight, false /* isCameraRecording */, &session);
EXPECT_TRUE(session);
}
TEST_F(EcoServiceTest, NormalObtainSingleSession) {
- sp<IECOService> service = createService();
+ std::shared_ptr<IECOService> service = createService();
EXPECT_TRUE(service != nullptr);
// Provider obtains the session from the service.
- sp<IECOSession> session = nullptr;
+ std::shared_ptr<IECOSession> session = nullptr;
service->obtainSession(kTestWidth, kTestHeight, kIsCameraRecording, &session);
EXPECT_TRUE(session);
}
TEST_F(EcoServiceTest, NormalObtainSessionTwice) {
- sp<IECOService> service = createService();
+ std::shared_ptr<IECOService> service = createService();
EXPECT_TRUE(service != nullptr);
// Provider obtains the session from the service.
- sp<IECOSession> session1 = nullptr;
+ std::shared_ptr<IECOSession> session1 = nullptr;
service->obtainSession(kTestWidth, kTestHeight, kIsCameraRecording, &session1);
EXPECT_TRUE(session1);
- sp<IECOSession> session2 = nullptr;
+ std::shared_ptr<IECOSession> session2 = nullptr;
service->obtainSession(kTestWidth, kTestHeight, kIsCameraRecording, &session2);
EXPECT_TRUE(session2);
// The two session instances should be the same.
- EXPECT_TRUE(IInterface::asBinder(session1) == IInterface::asBinder(session2));
+ EXPECT_TRUE(session1->asBinder() == session2->asBinder());
}
TEST_F(EcoServiceTest, ObtainTwoSessions) {
- sp<IECOService> service = createService();
+ std::shared_ptr<IECOService> service = createService();
EXPECT_TRUE(service != nullptr);
// Provider obtains the session from the service.
- sp<IECOSession> session1 = nullptr;
+ std::shared_ptr<IECOSession> session1 = nullptr;
service->obtainSession(kTestWidth, kTestHeight, kIsCameraRecording, &session1);
EXPECT_TRUE(session1);
- sp<IECOSession> session2 = nullptr;
+ std::shared_ptr<IECOSession> session2 = nullptr;
service->obtainSession(kTestWidth - 1, kTestHeight - 1, kIsCameraRecording, &session2);
EXPECT_TRUE(session2);
// The two session instances must not be the same.
- EXPECT_TRUE(IInterface::asBinder(session1) != IInterface::asBinder(session2));
+ EXPECT_TRUE(session1->asBinder() != session2->asBinder());
// Check the session number.
int32_t count = 0;
@@ -165,16 +158,16 @@
EXPECT_EQ(count, 2);
// Get the list of sessions from service.
- std::vector<sp<IBinder>> sessionList;
+ std::vector<::ndk::SpAIBinder> sessionList;
service->getSessions(&sessionList);
bool foundFirstSession = false, foundSecondSession = false;
- for (std::vector<sp<IBinder>>::iterator it = sessionList.begin(); it != sessionList.end();
+ for (std::vector<::ndk::SpAIBinder>::iterator it = sessionList.begin(); it != sessionList.end();
++it) {
- if (IInterface::asBinder(session1) == it->get()) {
+ if (session1->asBinder() == it->get()) {
foundFirstSession = true;
}
- if (IInterface::asBinder(session2) == it->get()) {
+ if (session2->asBinder() == it->get()) {
foundSecondSession = true;
}
}
@@ -185,18 +178,19 @@
}
TEST_F(EcoServiceTest, TestNormalFlowWithOneListenerAndOneProvider) {
- sp<IECOService> service = createService();
+ std::shared_ptr<IECOService> service = createService();
EXPECT_TRUE(service != nullptr);
// Provider obtains the session from the service.
- sp<IECOSession> session = nullptr;
+ std::shared_ptr<IECOSession> session = nullptr;
service->obtainSession(kTestWidth, kTestHeight, kIsCameraRecording, &session);
EXPECT_TRUE(session);
// Create provider and add it to the session.
- sp<FakeECOServiceStatsProvider> fakeProvider = new FakeECOServiceStatsProvider(
- kTestWidth, kTestHeight, kIsCameraRecording, kFrameRate);
+ std::shared_ptr<FakeECOServiceStatsProvider> fakeProvider =
+ ndk::SharedRefBase::make<FakeECOServiceStatsProvider>(kTestWidth, kTestHeight,
+ kIsCameraRecording, kFrameRate);
fakeProvider->setECOSession(session);
ECOData providerConfig(ECOData::DATA_TYPE_STATS_PROVIDER_CONFIG,
@@ -205,11 +199,12 @@
providerConfig.setInt32(KEY_PROVIDER_TYPE,
ECOServiceStatsProvider::STATS_PROVIDER_TYPE_VIDEO_ENCODER);
bool res;
- Status status = session->addStatsProvider(fakeProvider, providerConfig, &res);
+ ScopedAStatus status = session->addStatsProvider(fakeProvider, providerConfig, &res);
// Create listener and add it to the session.
- sp<FakeECOServiceInfoListener> fakeListener =
- new FakeECOServiceInfoListener(kTestWidth, kTestHeight, kIsCameraRecording);
+ std::shared_ptr<FakeECOServiceInfoListener> fakeListener =
+ ndk::SharedRefBase::make<FakeECOServiceInfoListener>(kTestWidth, kTestHeight,
+ kIsCameraRecording);
fakeListener->setECOSession(session);
// Create the listener config.
diff --git a/media/eco/tests/EcoSessionTest.cpp b/media/eco/tests/EcoSessionTest.cpp
index 5c8826f..4c496ea 100644
--- a/media/eco/tests/EcoSessionTest.cpp
+++ b/media/eco/tests/EcoSessionTest.cpp
@@ -20,8 +20,8 @@
#define LOG_TAG "ECOSessionTest"
#include <android-base/unique_fd.h>
-#include <binder/Parcel.h>
-#include <binder/Parcelable.h>
+#include <android/binder_auto_utils.h>
+#include <android/binder_parcel.h>
#include <cutils/ashmem.h>
#include <gtest/gtest.h>
#include <math.h>
@@ -39,8 +39,7 @@
namespace media {
namespace eco {
-using android::sp;
-using ::android::binder::Status;
+using ::ndk::ScopedAStatus;
static constexpr uint32_t kTestWidth = 1280;
static constexpr uint32_t kTestHeight = 720;
@@ -54,14 +53,15 @@
public:
EcoSessionTest() { ALOGD("EcoSessionTest created"); }
- sp<ECOSession> createSession(int32_t width, int32_t height, bool isCameraRecording) {
+ std::shared_ptr<ECOSession> createSession(int32_t width, int32_t height,
+ bool isCameraRecording) {
mSession = ECOSession::createECOSession(width, height, isCameraRecording);
if (mSession == nullptr) return nullptr;
return mSession;
}
private:
- sp<ECOSession> mSession = nullptr;
+ std::shared_ptr<ECOSession> mSession = nullptr;
};
TEST_F(EcoSessionTest, TestConstructorWithInvalidParameters) {
@@ -91,106 +91,121 @@
}
TEST_F(EcoSessionTest, TestAddProviderWithoutSpecifyEcoDataType) {
- sp<ECOSession> ecoSession = createSession(kTestWidth, kTestHeight, kIsCameraRecording);
+ std::shared_ptr<ECOSession> ecoSession =
+ createSession(kTestWidth, kTestHeight, kIsCameraRecording);
EXPECT_TRUE(ecoSession);
- sp<FakeECOServiceStatsProvider> fakeProvider = new FakeECOServiceStatsProvider(
- kTestWidth, kTestHeight, kIsCameraRecording, kFrameRate, ecoSession);
+ std::shared_ptr<FakeECOServiceStatsProvider> fakeProvider =
+ ndk::SharedRefBase::make<FakeECOServiceStatsProvider>(
+ kTestWidth, kTestHeight, kIsCameraRecording, kFrameRate, ecoSession);
ECOData providerConfig;
bool res;
- Status status = ecoSession->addStatsProvider(fakeProvider, providerConfig, &res);
+ ScopedAStatus status = ecoSession->addStatsProvider(fakeProvider, providerConfig, &res);
EXPECT_FALSE(status.isOk());
}
TEST_F(EcoSessionTest, TestAddProviderWithWrongEcoDataType) {
- sp<ECOSession> ecoSession = createSession(kTestWidth, kTestHeight, kIsCameraRecording);
+ std::shared_ptr<ECOSession> ecoSession =
+ createSession(kTestWidth, kTestHeight, kIsCameraRecording);
EXPECT_TRUE(ecoSession);
- sp<FakeECOServiceStatsProvider> fakeProvider = new FakeECOServiceStatsProvider(
- kTestWidth, kTestHeight, kIsCameraRecording, kFrameRate, ecoSession);
+ std::shared_ptr<FakeECOServiceStatsProvider> fakeProvider =
+ ndk::SharedRefBase::make<FakeECOServiceStatsProvider>(
+ kTestWidth, kTestHeight, kIsCameraRecording, kFrameRate, ecoSession);
ECOData providerConfig(ECOData::DATA_TYPE_INFO_LISTENER_CONFIG,
systemTime(SYSTEM_TIME_BOOTTIME));
bool res;
- Status status = ecoSession->addStatsProvider(fakeProvider, providerConfig, &res);
+ ScopedAStatus status = ecoSession->addStatsProvider(fakeProvider, providerConfig, &res);
EXPECT_FALSE(status.isOk());
}
TEST_F(EcoSessionTest, TestAddNormalProvider) {
- sp<ECOSession> ecoSession = createSession(kTestWidth, kTestHeight, kIsCameraRecording);
+ std::shared_ptr<ECOSession> ecoSession =
+ createSession(kTestWidth, kTestHeight, kIsCameraRecording);
EXPECT_TRUE(ecoSession);
- sp<FakeECOServiceStatsProvider> fakeProvider = new FakeECOServiceStatsProvider(
- kTestWidth, kTestHeight, kIsCameraRecording, kFrameRate, ecoSession);
+ std::shared_ptr<FakeECOServiceStatsProvider> fakeProvider =
+ ndk::SharedRefBase::make<FakeECOServiceStatsProvider>(
+ kTestWidth, kTestHeight, kIsCameraRecording, kFrameRate, ecoSession);
ECOData providerConfig(ECOData::DATA_TYPE_STATS_PROVIDER_CONFIG,
systemTime(SYSTEM_TIME_BOOTTIME));
bool res;
- Status status = ecoSession->addStatsProvider(fakeProvider, providerConfig, &res);
+ ScopedAStatus status = ecoSession->addStatsProvider(fakeProvider, providerConfig, &res);
EXPECT_TRUE(status.isOk());
}
// Add two providers and expect failure as ECOService1.0 only supports one provider and one
// listener.
TEST_F(EcoSessionTest, TestAddTwoProvider) {
- sp<ECOSession> ecoSession = createSession(kTestWidth, kTestHeight, kIsCameraRecording);
+ std::shared_ptr<ECOSession> ecoSession =
+ createSession(kTestWidth, kTestHeight, kIsCameraRecording);
EXPECT_TRUE(ecoSession);
- sp<FakeECOServiceStatsProvider> fakeProvider1 = new FakeECOServiceStatsProvider(
- kTestWidth, kTestHeight, kIsCameraRecording, kFrameRate, ecoSession);
+ std::shared_ptr<FakeECOServiceStatsProvider> fakeProvider1 =
+ ndk::SharedRefBase::make<FakeECOServiceStatsProvider>(
+ kTestWidth, kTestHeight, kIsCameraRecording, kFrameRate, ecoSession);
ECOData providerConfig(ECOData::DATA_TYPE_STATS_PROVIDER_CONFIG,
systemTime(SYSTEM_TIME_BOOTTIME));
bool res;
- Status status = ecoSession->addStatsProvider(fakeProvider1, providerConfig, &res);
+ ScopedAStatus status = ecoSession->addStatsProvider(fakeProvider1, providerConfig, &res);
EXPECT_TRUE(status.isOk());
- sp<FakeECOServiceStatsProvider> fakeProvider2 = new FakeECOServiceStatsProvider(
- kTestWidth, kTestHeight, kIsCameraRecording, kFrameRate, ecoSession);
+ std::shared_ptr<FakeECOServiceStatsProvider> fakeProvider2 =
+ ndk::SharedRefBase::make<FakeECOServiceStatsProvider>(
+ kTestWidth, kTestHeight, kIsCameraRecording, kFrameRate, ecoSession);
status = ecoSession->addStatsProvider(fakeProvider2, providerConfig, &res);
EXPECT_FALSE(status.isOk());
}
TEST_F(EcoSessionTest, TestAddListenerWithDifferentHeight) {
- sp<ECOSession> ecoSession = createSession(kTestWidth, kTestHeight, kIsCameraRecording);
+ std::shared_ptr<ECOSession> ecoSession =
+ createSession(kTestWidth, kTestHeight, kIsCameraRecording);
EXPECT_TRUE(ecoSession);
- sp<FakeECOServiceInfoListener> fakeListener = new FakeECOServiceInfoListener(
- kTestWidth - 1, kTestHeight, kIsCameraRecording, ecoSession);
+ std::shared_ptr<FakeECOServiceInfoListener> fakeListener =
+ ndk::SharedRefBase::make<FakeECOServiceInfoListener>(kTestWidth - 1, kTestHeight,
+ kIsCameraRecording, ecoSession);
ECOData ListenerConfig(ECOData::DATA_TYPE_INFO_LISTENER_CONFIG,
systemTime(SYSTEM_TIME_BOOTTIME));
bool res;
- Status status = ecoSession->addInfoListener(fakeListener, ListenerConfig, &res);
+ ScopedAStatus status = ecoSession->addInfoListener(fakeListener, ListenerConfig, &res);
EXPECT_FALSE(status.isOk());
}
TEST_F(EcoSessionTest, TestAddListenerWithDifferentWidth) {
- sp<ECOSession> ecoSession = createSession(kTestWidth, kTestHeight, kIsCameraRecording);
+ std::shared_ptr<ECOSession> ecoSession =
+ createSession(kTestWidth, kTestHeight, kIsCameraRecording);
EXPECT_TRUE(ecoSession);
- sp<FakeECOServiceInfoListener> fakeListener = new FakeECOServiceInfoListener(
- kTestWidth, kTestHeight - 1, kIsCameraRecording, ecoSession);
+ std::shared_ptr<FakeECOServiceInfoListener> fakeListener =
+ ndk::SharedRefBase::make<FakeECOServiceInfoListener>(kTestWidth, kTestHeight - 1,
+ kIsCameraRecording, ecoSession);
ECOData ListenerConfig(ECOData::DATA_TYPE_INFO_LISTENER_CONFIG,
systemTime(SYSTEM_TIME_BOOTTIME));
bool res;
- Status status = ecoSession->addInfoListener(fakeListener, ListenerConfig, &res);
+ ScopedAStatus status = ecoSession->addInfoListener(fakeListener, ListenerConfig, &res);
EXPECT_FALSE(status.isOk());
}
TEST_F(EcoSessionTest, TestAddListenerWithCameraRecordingFalse) {
- sp<ECOSession> ecoSession = createSession(kTestWidth, kTestHeight, kIsCameraRecording);
+ std::shared_ptr<ECOSession> ecoSession =
+ createSession(kTestWidth, kTestHeight, kIsCameraRecording);
EXPECT_TRUE(ecoSession);
- sp<FakeECOServiceInfoListener> fakeListener = new FakeECOServiceInfoListener(
- kTestWidth, kTestHeight, !kIsCameraRecording, ecoSession);
+ std::shared_ptr<FakeECOServiceInfoListener> fakeListener =
+ ndk::SharedRefBase::make<FakeECOServiceInfoListener>(kTestWidth, kTestHeight,
+ !kIsCameraRecording, ecoSession);
ECOData ListenerConfig(ECOData::DATA_TYPE_INFO_LISTENER_CONFIG,
systemTime(SYSTEM_TIME_BOOTTIME));
bool res;
- Status status = ecoSession->addInfoListener(fakeListener, ListenerConfig, &res);
+ ScopedAStatus status = ecoSession->addInfoListener(fakeListener, ListenerConfig, &res);
EXPECT_FALSE(status.isOk());
}
@@ -202,22 +217,25 @@
static constexpr int kServiceWaitTimeMs = 10;
// Create the session.
- sp<ECOSession> ecoSession = createSession(kTestWidth, kTestHeight, kIsCameraRecording);
+ std::shared_ptr<ECOSession> ecoSession =
+ createSession(kTestWidth, kTestHeight, kIsCameraRecording);
// Add provider.
- sp<FakeECOServiceStatsProvider> fakeProvider = new FakeECOServiceStatsProvider(
- kTestWidth, kTestHeight, kIsCameraRecording, kFrameRate, ecoSession);
+ std::shared_ptr<FakeECOServiceStatsProvider> fakeProvider =
+ ndk::SharedRefBase::make<FakeECOServiceStatsProvider>(
+ kTestWidth, kTestHeight, kIsCameraRecording, kFrameRate, ecoSession);
ECOData providerConfig(ECOData::DATA_TYPE_STATS_PROVIDER_CONFIG,
systemTime(SYSTEM_TIME_BOOTTIME));
providerConfig.setString(KEY_PROVIDER_NAME, "FakeECOServiceStatsProvider");
providerConfig.setInt32(KEY_PROVIDER_TYPE,
ECOServiceStatsProvider::STATS_PROVIDER_TYPE_VIDEO_ENCODER);
bool res;
- Status status = ecoSession->addStatsProvider(fakeProvider, providerConfig, &res);
+ ScopedAStatus status = ecoSession->addStatsProvider(fakeProvider, providerConfig, &res);
// Create listener.
- sp<FakeECOServiceInfoListener> fakeListener =
- new FakeECOServiceInfoListener(kTestWidth, kTestHeight, kIsCameraRecording, ecoSession);
+ std::shared_ptr<FakeECOServiceInfoListener> fakeListener =
+ ndk::SharedRefBase::make<FakeECOServiceInfoListener>(kTestWidth, kTestHeight,
+ kIsCameraRecording, ecoSession);
// Create the listener config.
ECOData listenerConfig(ECOData::DATA_TYPE_INFO_LISTENER_CONFIG,
@@ -410,16 +428,18 @@
}
TEST_F(EcoSessionTest, TestRemoveMatchProvider) {
- sp<ECOSession> ecoSession = createSession(kTestWidth, kTestHeight, kIsCameraRecording);
+ std::shared_ptr<ECOSession> ecoSession =
+ createSession(kTestWidth, kTestHeight, kIsCameraRecording);
EXPECT_TRUE(ecoSession);
- sp<FakeECOServiceStatsProvider> fakeProvider1 = new FakeECOServiceStatsProvider(
- kTestWidth, kTestHeight, kIsCameraRecording, kFrameRate, ecoSession);
+ std::shared_ptr<FakeECOServiceStatsProvider> fakeProvider1 =
+ ndk::SharedRefBase::make<FakeECOServiceStatsProvider>(
+ kTestWidth, kTestHeight, kIsCameraRecording, kFrameRate, ecoSession);
ECOData providerConfig(ECOData::DATA_TYPE_STATS_PROVIDER_CONFIG,
systemTime(SYSTEM_TIME_BOOTTIME));
bool res;
- Status status = ecoSession->addStatsProvider(fakeProvider1, providerConfig, &res);
+ ScopedAStatus status = ecoSession->addStatsProvider(fakeProvider1, providerConfig, &res);
EXPECT_TRUE(res);
EXPECT_TRUE(status.isOk());
@@ -429,21 +449,24 @@
}
TEST_F(EcoSessionTest, TestRemoveMisMatchProvider) {
- sp<ECOSession> ecoSession = createSession(kTestWidth, kTestHeight, kIsCameraRecording);
+ std::shared_ptr<ECOSession> ecoSession =
+ createSession(kTestWidth, kTestHeight, kIsCameraRecording);
EXPECT_TRUE(ecoSession);
- sp<FakeECOServiceStatsProvider> fakeProvider1 = new FakeECOServiceStatsProvider(
- kTestWidth, kTestHeight, kIsCameraRecording, kFrameRate, ecoSession);
+ std::shared_ptr<FakeECOServiceStatsProvider> fakeProvider1 =
+ ndk::SharedRefBase::make<FakeECOServiceStatsProvider>(
+ kTestWidth, kTestHeight, kIsCameraRecording, kFrameRate, ecoSession);
ECOData providerConfig(ECOData::DATA_TYPE_STATS_PROVIDER_CONFIG,
systemTime(SYSTEM_TIME_BOOTTIME));
bool res;
- Status status = ecoSession->addStatsProvider(fakeProvider1, providerConfig, &res);
+ ScopedAStatus status = ecoSession->addStatsProvider(fakeProvider1, providerConfig, &res);
EXPECT_TRUE(res);
EXPECT_TRUE(status.isOk());
- sp<FakeECOServiceStatsProvider> fakeProvider2 = new FakeECOServiceStatsProvider(
- kTestWidth, kTestHeight, kIsCameraRecording, kFrameRate, ecoSession);
+ std::shared_ptr<FakeECOServiceStatsProvider> fakeProvider2 =
+ ndk::SharedRefBase::make<FakeECOServiceStatsProvider>(
+ kTestWidth, kTestHeight, kIsCameraRecording, kFrameRate, ecoSession);
status = ecoSession->removeStatsProvider(fakeProvider2, &res);
EXPECT_FALSE(res);
@@ -451,12 +474,14 @@
}
TEST_F(EcoSessionTest, TestRemoveMatchListener) {
- sp<ECOSession> ecoSession = createSession(kTestWidth, kTestHeight, kIsCameraRecording);
+ std::shared_ptr<ECOSession> ecoSession =
+ createSession(kTestWidth, kTestHeight, kIsCameraRecording);
EXPECT_TRUE(ecoSession);
// Create listener.
- sp<FakeECOServiceInfoListener> fakeListener =
- new FakeECOServiceInfoListener(kTestWidth, kTestHeight, kIsCameraRecording, ecoSession);
+ std::shared_ptr<FakeECOServiceInfoListener> fakeListener =
+ ndk::SharedRefBase::make<FakeECOServiceInfoListener>(kTestWidth, kTestHeight,
+ kIsCameraRecording, ecoSession);
// Create the listener config.
ECOData listenerConfig(ECOData::DATA_TYPE_INFO_LISTENER_CONFIG,
@@ -469,7 +494,7 @@
listenerConfig.setInt32(KEY_LISTENER_QP_CHANGE_THRESHOLD, 5);
bool res;
- Status status = ecoSession->addInfoListener(fakeListener, listenerConfig, &res);
+ ScopedAStatus status = ecoSession->addInfoListener(fakeListener, listenerConfig, &res);
status = ecoSession->removeInfoListener(fakeListener, &res);
EXPECT_TRUE(res);
@@ -477,12 +502,14 @@
}
TEST_F(EcoSessionTest, TestRemoveMisMatchListener) {
- sp<ECOSession> ecoSession = createSession(kTestWidth, kTestHeight, kIsCameraRecording);
+ std::shared_ptr<ECOSession> ecoSession =
+ createSession(kTestWidth, kTestHeight, kIsCameraRecording);
EXPECT_TRUE(ecoSession);
// Create listener.
- sp<FakeECOServiceInfoListener> fakeListener =
- new FakeECOServiceInfoListener(kTestWidth, kTestHeight, kIsCameraRecording, ecoSession);
+ std::shared_ptr<FakeECOServiceInfoListener> fakeListener =
+ ndk::SharedRefBase::make<FakeECOServiceInfoListener>(kTestWidth, kTestHeight,
+ kIsCameraRecording, ecoSession);
// Create the listener config.
ECOData listenerConfig(ECOData::DATA_TYPE_INFO_LISTENER_CONFIG,
@@ -495,11 +522,12 @@
listenerConfig.setInt32(KEY_LISTENER_QP_CHANGE_THRESHOLD, 5);
bool res;
- Status status = ecoSession->addInfoListener(fakeListener, listenerConfig, &res);
+ ScopedAStatus status = ecoSession->addInfoListener(fakeListener, listenerConfig, &res);
// Create listener.
- sp<FakeECOServiceInfoListener> fakeListener2 =
- new FakeECOServiceInfoListener(kTestWidth, kTestHeight, kIsCameraRecording, ecoSession);
+ std::shared_ptr<FakeECOServiceInfoListener> fakeListener2 =
+ ndk::SharedRefBase::make<FakeECOServiceInfoListener>(kTestWidth, kTestHeight,
+ kIsCameraRecording, ecoSession);
status = ecoSession->removeInfoListener(fakeListener2, &res);
EXPECT_FALSE(res);
@@ -513,18 +541,20 @@
static constexpr int kServiceWaitTimeMs = 10;
// Create the session.
- sp<ECOSession> ecoSession = createSession(kTestWidth, kTestHeight, kIsCameraRecording);
+ std::shared_ptr<ECOSession> ecoSession =
+ createSession(kTestWidth, kTestHeight, kIsCameraRecording);
// Add provider.
- sp<FakeECOServiceStatsProvider> fakeProvider = new FakeECOServiceStatsProvider(
- kTestWidth, kTestHeight, kIsCameraRecording, kFrameRate, ecoSession);
+ std::shared_ptr<FakeECOServiceStatsProvider> fakeProvider =
+ ndk::SharedRefBase::make<FakeECOServiceStatsProvider>(
+ kTestWidth, kTestHeight, kIsCameraRecording, kFrameRate, ecoSession);
ECOData providerConfig(ECOData::DATA_TYPE_STATS_PROVIDER_CONFIG,
systemTime(SYSTEM_TIME_BOOTTIME));
providerConfig.setString(KEY_PROVIDER_NAME, "FakeECOServiceStatsProvider");
providerConfig.setInt32(KEY_PROVIDER_TYPE,
ECOServiceStatsProvider::STATS_PROVIDER_TYPE_VIDEO_ENCODER);
bool res;
- Status status = ecoSession->addStatsProvider(fakeProvider, providerConfig, &res);
+ ScopedAStatus status = ecoSession->addStatsProvider(fakeProvider, providerConfig, &res);
// Inject the session stats into the ECOSession through fakeProvider.
SimpleEncoderConfig sessionEncoderConfig("google-avc", CodecTypeAVC, AVCProfileHigh, AVCLevel52,
@@ -546,8 +576,9 @@
// =======================================================================================
// Create and add the listener to the ECOSession. Expect to receive the session infor right
// after addInfoListener.
- sp<FakeECOServiceInfoListener> fakeListener =
- new FakeECOServiceInfoListener(kTestWidth, kTestHeight, kIsCameraRecording, ecoSession);
+ std::shared_ptr<FakeECOServiceInfoListener> fakeListener =
+ ndk::SharedRefBase::make<FakeECOServiceInfoListener>(kTestWidth, kTestHeight,
+ kIsCameraRecording, ecoSession);
// Create the listener config.
ECOData listenerConfig(ECOData::DATA_TYPE_INFO_LISTENER_CONFIG,
diff --git a/media/eco/tests/FakeECOServiceInfoListener.cpp b/media/eco/tests/FakeECOServiceInfoListener.cpp
index 10a6851..8a58f7d 100644
--- a/media/eco/tests/FakeECOServiceInfoListener.cpp
+++ b/media/eco/tests/FakeECOServiceInfoListener.cpp
@@ -20,8 +20,7 @@
#include "FakeECOServiceInfoListener.h"
#include <android-base/unique_fd.h>
-#include <binder/Parcel.h>
-#include <binder/Parcelable.h>
+#include <android/binder_parcel.h>
#include <cutils/ashmem.h>
#include <gtest/gtest.h>
#include <math.h>
@@ -35,7 +34,7 @@
FakeECOServiceInfoListener::FakeECOServiceInfoListener(int32_t width, int32_t height,
bool isCameraRecording,
- android::sp<IECOSession> session)
+ std::shared_ptr<IECOSession> session)
: mWidth(width),
mHeight(height),
mIsCameraRecording(isCameraRecording),
@@ -55,28 +54,29 @@
ALOGD("FakeECOServiceInfoListener destructor");
}
-Status FakeECOServiceInfoListener::getType(int32_t* /*_aidl_return*/) {
- return binder::Status::ok();
+ndk::ScopedAStatus FakeECOServiceInfoListener::getType(int32_t* /*_aidl_return*/) {
+ return ndk::ScopedAStatus::ok();
}
-Status FakeECOServiceInfoListener::getName(::android::String16* _aidl_return) {
- *_aidl_return = String16("FakeECOServiceInfoListener");
- return binder::Status::ok();
+ndk::ScopedAStatus FakeECOServiceInfoListener::getName(std::string* _aidl_return) {
+ *_aidl_return = std::string("FakeECOServiceInfoListener");
+ return ndk::ScopedAStatus::ok();
}
-Status FakeECOServiceInfoListener::getECOSession(sp<::android::IBinder>* _aidl_return) {
- *_aidl_return = IInterface::asBinder(mECOSession);
- return binder::Status::ok();
+ndk::ScopedAStatus FakeECOServiceInfoListener::getECOSession(::ndk::SpAIBinder* _aidl_return) {
+ *_aidl_return = mECOSession->asBinder();
+ return ndk::ScopedAStatus::ok();
}
-Status FakeECOServiceInfoListener::onNewInfo(const ::android::media::eco::ECOData& newInfo) {
+ndk::ScopedAStatus FakeECOServiceInfoListener::onNewInfo(
+ const ::android::media::eco::ECOData& newInfo) {
ALOGD("FakeECOServiceInfoListener get new info");
mInfoAvaiableCallback(newInfo);
- return binder::Status::ok();
+ return ndk::ScopedAStatus::ok();
}
// IBinder::DeathRecipient implementation
-void FakeECOServiceInfoListener::binderDied(const wp<IBinder>& /*who*/) {}
+void FakeECOServiceInfoListener::binderDied(const std::weak_ptr<AIBinder>& /*who*/) {}
} // namespace eco
} // namespace media
diff --git a/media/eco/tests/FakeECOServiceInfoListener.h b/media/eco/tests/FakeECOServiceInfoListener.h
index 7c23275..f49bd60 100644
--- a/media/eco/tests/FakeECOServiceInfoListener.h
+++ b/media/eco/tests/FakeECOServiceInfoListener.h
@@ -16,11 +16,11 @@
// A fake ECOServiceInfoListener for testing ECOService and ECOSession.
+#include <aidl/android/media/eco/BnECOServiceInfoListener.h>
+#include <aidl/android/media/eco/IECOSession.h>
#include <android-base/unique_fd.h>
-#include <android/media/eco/BnECOServiceInfoListener.h>
-#include <android/media/eco/IECOSession.h>
-#include <binder/Parcel.h>
-#include <binder/Parcelable.h>
+#include <android/binder_auto_utils.h>
+#include <android/binder_parcel.h>
#include <cutils/ashmem.h>
#include <gtest/gtest.h>
#include <math.h>
@@ -35,8 +35,11 @@
namespace media {
namespace eco {
-using ::android::sp;
-using ::android::binder::Status;
+using aidl::android::media::eco::BnECOServiceInfoListener;
+using aidl::android::media::eco::ECOData;
+using aidl::android::media::eco::ECODataStatus;
+using aidl::android::media::eco::IECOSession;
+using ::ndk::ScopedAStatus;
/**
* A fake ECOServiceInfoListener.
@@ -51,18 +54,18 @@
std::function<void(const ::android::media::eco::ECOData& newInfo)>;
FakeECOServiceInfoListener(int32_t width, int32_t height, bool isCameraRecording,
- sp<IECOSession> session);
+ std::shared_ptr<IECOSession> session);
FakeECOServiceInfoListener(int32_t width, int32_t height, bool isCameraRecording);
- void setECOSession(android::sp<IECOSession> session) { mECOSession = session; }
+ void setECOSession(std::shared_ptr<IECOSession> session) { mECOSession = session; }
virtual ~FakeECOServiceInfoListener();
- virtual Status getType(int32_t* _aidl_return);
- virtual Status getName(::android::String16* _aidl_return);
- virtual Status getECOSession(::android::sp<::android::IBinder>* _aidl_return);
- virtual Status onNewInfo(const ::android::media::eco::ECOData& newInfo);
+ virtual ScopedAStatus getType(int32_t* _aidl_return);
+ virtual ScopedAStatus getName(std::string* _aidl_return);
+ virtual ScopedAStatus getECOSession(::ndk::SpAIBinder* _aidl_return);
+ virtual ScopedAStatus onNewInfo(const ::android::media::eco::ECOData& newInfo);
// Helper callback to send the info to the test.
void setInfoAvailableCallback(InfoAvailableCallback callback) {
@@ -70,13 +73,13 @@
}
// IBinder::DeathRecipient implementation
- virtual void binderDied(const wp<IBinder>& who);
+ virtual void binderDied(const std::weak_ptr<AIBinder>& who);
private:
int32_t mWidth;
int32_t mHeight;
bool mIsCameraRecording;
- android::sp<IECOSession> mECOSession;
+ std::shared_ptr<IECOSession> mECOSession;
InfoAvailableCallback mInfoAvaiableCallback;
};
diff --git a/media/eco/tests/FakeECOServiceStatsProvider.cpp b/media/eco/tests/FakeECOServiceStatsProvider.cpp
index 4bf0ca4..9410889 100644
--- a/media/eco/tests/FakeECOServiceStatsProvider.cpp
+++ b/media/eco/tests/FakeECOServiceStatsProvider.cpp
@@ -20,8 +20,8 @@
#include "FakeECOServiceStatsProvider.h"
#include <android-base/unique_fd.h>
-#include <binder/Parcel.h>
-#include <binder/Parcelable.h>
+#include <android/binder_auto_utils.h>
+#include <android/binder_parcel.h>
#include <cutils/ashmem.h>
#include <gtest/gtest.h>
#include <math.h>
@@ -35,7 +35,7 @@
FakeECOServiceStatsProvider::FakeECOServiceStatsProvider(int32_t width, int32_t height,
bool isCameraRecording, float frameRate,
- android::sp<IECOSession> session)
+ std::shared_ptr<IECOSession> session)
: mWidth(width),
mHeight(height),
mIsCameraRecording(isCameraRecording),
@@ -63,18 +63,18 @@
ALOGD("FakeECOServiceStatsProvider destructor");
}
-Status FakeECOServiceStatsProvider::getType(int32_t* /*_aidl_return*/) {
- return binder::Status::ok();
+ndk::ScopedAStatus FakeECOServiceStatsProvider::getType(int32_t* /*_aidl_return*/) {
+ return ndk::ScopedAStatus::ok();
}
-Status FakeECOServiceStatsProvider::getName(::android::String16* _aidl_return) {
- *_aidl_return = String16("FakeECOServiceStatsProvider");
- return binder::Status::ok();
+ndk::ScopedAStatus FakeECOServiceStatsProvider::getName(std::string* _aidl_return) {
+ *_aidl_return = std::string("FakeECOServiceStatsProvider");
+ return ndk::ScopedAStatus::ok();
}
-Status FakeECOServiceStatsProvider::getECOSession(sp<::android::IBinder>* _aidl_return) {
- *_aidl_return = IInterface::asBinder(mECOSession);
- return binder::Status::ok();
+ndk::ScopedAStatus FakeECOServiceStatsProvider::getECOSession(::ndk::SpAIBinder* _aidl_return) {
+ *_aidl_return = mECOSession->asBinder();
+ return ndk::ScopedAStatus::ok();
}
bool FakeECOServiceStatsProvider::injectSessionStats(const ECOData& stats) {
@@ -94,7 +94,7 @@
}
// IBinder::DeathRecipient implementation
-void FakeECOServiceStatsProvider::binderDied(const wp<IBinder>& /*who*/) {}
+void FakeECOServiceStatsProvider::binderDied(const std::weak_ptr<AIBinder>& /*who*/) {}
} // namespace eco
} // namespace media
diff --git a/media/eco/tests/FakeECOServiceStatsProvider.h b/media/eco/tests/FakeECOServiceStatsProvider.h
index bf14a53..6dfd3a6 100644
--- a/media/eco/tests/FakeECOServiceStatsProvider.h
+++ b/media/eco/tests/FakeECOServiceStatsProvider.h
@@ -16,10 +16,10 @@
// A fake ECOServiceStatsProvider for testing ECOService and ECOSession.
+#include <aidl/android/media/eco/BnECOServiceStatsProvider.h>
#include <android-base/unique_fd.h>
-#include <android/media/eco/BnECOServiceStatsProvider.h>
-#include <binder/Parcel.h>
-#include <binder/Parcelable.h>
+#include <android/binder_auto_utils.h>
+#include <android/binder_parcel.h>
#include <cutils/ashmem.h>
#include <gtest/gtest.h>
#include <math.h>
@@ -42,8 +42,7 @@
namespace media {
namespace eco {
-using ::android::sp;
-using ::android::binder::Status;
+using ::ndk::ScopedAStatus;
/**
* A fake ECOServiceStatsProvider.
@@ -54,12 +53,12 @@
class FakeECOServiceStatsProvider : public BnECOServiceStatsProvider {
public:
FakeECOServiceStatsProvider(int32_t width, int32_t height, bool isCameraRecording,
- float frameRate, android::sp<IECOSession> session);
+ float frameRate, std::shared_ptr<IECOSession> session);
FakeECOServiceStatsProvider(int32_t width, int32_t height, bool isCameraRecording,
float frameRate);
- void setECOSession(android::sp<IECOSession> session) { mECOSession = session; }
+ void setECOSession(std::shared_ptr<IECOSession> session) { mECOSession = session; }
// Helper function to inject session stats to the FakeECOServiceStatsProvider so provider
// could push to the service.
@@ -77,12 +76,12 @@
virtual ~FakeECOServiceStatsProvider();
- virtual Status getType(int32_t* _aidl_return);
- virtual Status getName(::android::String16* _aidl_return);
- virtual Status getECOSession(::android::sp<::android::IBinder>* _aidl_return);
+ virtual ScopedAStatus getType(int32_t* _aidl_return);
+ virtual ScopedAStatus getName(std::string* _aidl_return);
+ virtual ScopedAStatus getECOSession(::ndk::SpAIBinder* _aidl_return);
// IBinder::DeathRecipient implementation
- virtual void binderDied(const wp<IBinder>& who);
+ virtual void binderDied(const std::weak_ptr<AIBinder>& who);
private:
int32_t mWidth;
@@ -91,7 +90,7 @@
float mFrameRate;
uint32_t mFrameNumber;
- android::sp<IECOSession> mECOSession;
+ std::shared_ptr<IECOSession> mECOSession;
};
} // namespace eco
