media/eco/ECOData.cpp - platform/hardware/google/av - Gitiles

 /*
  * 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 "ECOData"

 #include "eco/ECOData.h"

 #include <binder/Parcel.h>
 #include <inttypes.h>
 #include <utils/Errors.h>
 #include <utils/Log.h>

 #include <string>

 #include "eco/ECODataKey.h"
 #include "eco/ECOUtils.h"

 namespace android {
 namespace media {
 namespace eco {

 using namespace ::android;

 status_t ECOData::readFromParcel(const Parcel* 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));

     // Reads the number of items.
     uint32_t numOfItems = 0;
     RETURN_STATUS_IF_ERROR(parcel->readUint32(&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;
         }

         int32_t type;
         RETURN_STATUS_IF_ERROR(parcel->readInt32(&type));
         switch (static_cast<ValueType>(type)) {
         case kTypeInt32: {
             int32_t value32;
             RETURN_STATUS_IF_ERROR(parcel->readInt32(&value32));
             setInt32(std::string(name), value32);
             break;
         }
         case kTypeInt64: {
             int64_t value64;
             RETURN_STATUS_IF_ERROR(parcel->readInt64(&value64));
             setInt64(std::string(name), value64);
             break;
         }
         case kTypeSize: {
             int32_t valueSize;
             RETURN_STATUS_IF_ERROR(parcel->readInt32(&valueSize));
             setInt32(std::string(name), valueSize);
             break;
         }
         case kTypeFloat: {
             float valueFloat;
             RETURN_STATUS_IF_ERROR(parcel->readFloat(&valueFloat));
             setFloat(std::string(name), valueFloat);
             break;
         }
         case kTypeDouble: {
             double valueDouble;
             RETURN_STATUS_IF_ERROR(parcel->readDouble(&valueDouble));
             setDouble(std::string(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);
             break;
         }
         case kTypeInt8: {
             int8_t value8;
             RETURN_STATUS_IF_ERROR(parcel->readByte(&value8));
             setInt8(std::string(name), value8);
             break;
         }
         default: {
             return BAD_TYPE;
         }
         }
     }

     return NO_ERROR;
 }

 status_t ECOData::writeToParcel(Parcel* 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));

     // Writes out number of items.
     RETURN_STATUS_IF_ERROR(parcel->writeUint32(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()));

         // Writes out the data type.
         const ECODataValueType& value = it.second;
         RETURN_STATUS_IF_ERROR(parcel->writeInt32(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)));
             break;

         case kTypeInt64:
             RETURN_STATUS_IF_ERROR(parcel->writeInt64(std::get<int64_t>(it.second)));
             break;

         case kTypeSize:
             RETURN_STATUS_IF_ERROR(parcel->writeUint32(std::get<size_t>(it.second)));
             break;

         case kTypeFloat:
             RETURN_STATUS_IF_ERROR(parcel->writeFloat(std::get<float>(it.second)));
             break;

         case kTypeDouble:
             RETURN_STATUS_IF_ERROR(parcel->writeDouble(std::get<double>(it.second)));
             break;

         case kTypeString:
             RETURN_STATUS_IF_ERROR(parcel->writeCString(std::get<std::string>(it.second).c_str()));
             break;

         case kTypeInt8:
             RETURN_STATUS_IF_ERROR(parcel->writeByte(std::get<int8_t>(it.second)));
             break;

         default:
             return BAD_TYPE;
         }
     }

     return NO_ERROR;
 }

 int32_t ECOData::getDataType() const {
     return mDataType;
 }

 int64_t ECOData::getDataTimeUs() const {
     return mDataTimeUs;
 }

 // Inserts a new key into store if the key does not exist yet. Otherwise, this will override the
 // existing key's value.
 ECODataStatus ECOData::setString(const std::string& key, const std::string& value) {
     if (key.empty() || value.empty()) {
         return ECODataStatus::INVALID_ARGUMENT;
     }

     mKeyValueStore[key] = value;

     // TODO(hkuang): Check the valueType is valid for the key.
     return ECODataStatus::OK;
 }

 ECODataStatus ECOData::findString(const std::string& key, std::string* value) const {
     if (key.empty()) {
         return ECODataStatus::INVALID_ARGUMENT;
     }

     // Check if the key exists.
     if (mKeyValueStore.find(key) == mKeyValueStore.end()) {
         return ECODataStatus::KEY_NOT_EXIST;
     }

     // Safely access the value.
     const std::string& entryValue = std::get<std::string>(mKeyValueStore.at(key));
     value->assign(entryValue);

     return ECODataStatus::OK;
 }

 // Inserts a new key into store if the key does not exist yet. Otherwise, this will override the
 // existing key's value.
 template <typename T>
 ECODataStatus ECOData::setValue(const std::string& key, T value) {
     if (key.empty()) {
         return ECODataStatus::INVALID_ARGUMENT;
     }

     mKeyValueStore[key] = value;
     return ECODataStatus::OK;
 }

 template <typename T>
 ECODataStatus ECOData::findValue(const std::string& key, T* out) const {
     if (key.empty() || out == nullptr) {
         return ECODataStatus::INVALID_ARGUMENT;
     }

     if (mKeyValueStore.find(key) == mKeyValueStore.end()) {
         return ECODataStatus::KEY_NOT_EXIST;
     }

     // Safely access the value.
     *out = std::get<T>(mKeyValueStore.at(key));

     return ECODataStatus::OK;
 }

 ECODataStatus ECOData::setInt32(const std::string& key, int32_t value) {
     return setValue<int32_t>(key, value);
 }

 ECODataStatus ECOData::findInt32(const std::string& key, int32_t* out) const {
     return findValue<int32_t>(key, out);
 }

 ECODataStatus ECOData::setInt64(const std::string& key, int64_t value) {
     return setValue<int64_t>(key, value);
 }

 ECODataStatus ECOData::findInt64(const std::string& key, int64_t* out) const {
     return findValue<int64_t>(key, out);
 }

 ECODataStatus ECOData::setDouble(const std::string& key, double value) {
     return setValue<double>(key, value);
 }

 ECODataStatus ECOData::findDouble(const std::string& key, double* out) const {
     return findValue<double>(key, out);
 }

 ECODataStatus ECOData::setSize(const std::string& key, size_t value) {
     return setValue<size_t>(key, value);
 }

 ECODataStatus ECOData::findSize(const std::string& key, size_t* out) const {
     return findValue<size_t>(key, out);
 }

 ECODataStatus ECOData::setFloat(const std::string& key, float value) {
     return setValue<float>(key, value);
 }

 ECODataStatus ECOData::findFloat(const std::string& key, float* out) const {
     return findValue<float>(key, out);
 }

 ECODataStatus ECOData::setInt8(const std::string& key, int8_t value) {
     return setValue<int8_t>(key, value);
 }

 ECODataStatus ECOData::findInt8(const std::string& key, int8_t* out) const {
     return findValue<int8_t>(key, out);
 }

 ECODataStatus ECOData::set(const std::string& key, const ECOData::ECODataValueType& value) {
     if (key.empty()) {
         return ECODataStatus::INVALID_ARGUMENT;
     }
     mKeyValueStore[key] = value;
     return ECODataStatus::OK;
 }

 ECODataStatus ECOData::find(const std::string& key, ECOData::ECODataValueType* out) const {
     if (key.empty() || out == nullptr) {
         return ECODataStatus::INVALID_ARGUMENT;
     }

     if (mKeyValueStore.find(key) == mKeyValueStore.end()) {
         return ECODataStatus::KEY_NOT_EXIST;
     }

     // Safely access the value.
     *out = mKeyValueStore.at(key);

     return ECODataStatus::OK;
 }

 std::string ECOData::getDataTypeString() const {
     switch (mDataType) {
     case DATA_TYPE_UNKNOWN:
         return "DATA_TYPE_UNKNOWN";
     case DATA_TYPE_STATS:
         return "DATA_TYPE_STATS";
     case DATA_TYPE_INFO:
         return "DATA_TYPE_INFO";
     case DATA_TYPE_STATS_PROVIDER_CONFIG:
         return "DATA_TYPE_STATS_PROVIDER_CONFIG";
     case DATA_TYPE_INFO_LISTENER_CONFIG:
         return "DATA_TYPE_INFO_LISTENER_CONFIG";
     }
     return {};
 }

 // TODO(hkuang): Add test for this.
 bool ECODataKeyValueIterator::hasNext() {
     if (mIterator == mKeyValueStore.end()) return false;

     if (!mBeginReturned) {
         // mIterator has been initialized to the beginning and
         // hasn't been returned. Do not advance:
         mBeginReturned = true;
     } else {
         std::advance(mIterator, 1);
     }
     return mIterator != mKeyValueStore.end();
 }

 // TODO(hkuang): Add test for this.
 ECOData::ECODataKeyValuePair ECODataKeyValueIterator::next() const {
     return ECOData::ECODataKeyValuePair(mIterator->first, mIterator->second);
 }

 std::string ECOData::debugString() const {
     std::string s = "ECOData(type = ";

     std::string tmp;
     switch (mDataType) {
     case DATA_TYPE_UNKNOWN:
         tmp = "Unknown";
         break;
     case DATA_TYPE_STATS:
         tmp = "Stats";
         break;
     case DATA_TYPE_INFO:
         tmp = "Info";
         break;
     case DATA_TYPE_STATS_PROVIDER_CONFIG:
         tmp = "Stats provider config";
         break;
     case DATA_TYPE_INFO_LISTENER_CONFIG:
         tmp = "Info listener config";
         break;
     default:
         break;
     }
     s.append(tmp);
     s.append(") = {\n  ");

     // Writes out the key-value pairs one by one.
     for (const auto& it : mKeyValueStore) {
         const size_t SIZE = 100;
         char keyValue[SIZE];
         const ECODataValueType& value = it.second;
         switch (static_cast<ValueType>(value.index())) {
         case kTypeInt32:
             snprintf(keyValue, SIZE, "int32_t %s = %d, ", it.first.c_str(),
                      std::get<int32_t>(it.second));
             break;
         case kTypeInt64:
             snprintf(keyValue, SIZE, "int64_t %s = %" PRId64 ", ", it.first.c_str(),
                      std::get<int64_t>(it.second));
             break;
         case kTypeSize:
             snprintf(keyValue, SIZE, "size_t %s = %zu, ", it.first.c_str(),
                      std::get<size_t>(it.second));
             break;
         case kTypeFloat:
             snprintf(keyValue, SIZE, "float %s = %f, ", it.first.c_str(),
                      std::get<float>(it.second));
             break;
         case kTypeDouble:
             snprintf(keyValue, SIZE, "double %s = %f, ", it.first.c_str(),
                      std::get<double>(it.second));
             break;
         case kTypeString:
             snprintf(keyValue, SIZE, "string %s = %s, ", it.first.c_str(),
                      std::get<std::string>(it.second).c_str());
             break;
         case kTypeInt8:
             snprintf(keyValue, SIZE, "int8_t %s = %d, ", it.first.c_str(),
                      std::get<int8_t>(it.second));
             break;
         default:
             break;
         }
         s.append(keyValue);
     }

     s.append("\n }");

     return s;
 }

 }  // namespace eco
 }  // namespace media
 }  // namespace android
	/*
	* 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 "ECOData"

	#include "eco/ECOData.h"

	#include <binder/Parcel.h>
	#include <inttypes.h>
	#include <utils/Errors.h>
	#include <utils/Log.h>

	#include <string>

	#include "eco/ECODataKey.h"
	#include "eco/ECOUtils.h"

	namespace android {
	namespace media {
	namespace eco {

	using namespace ::android;

	status_t ECOData::readFromParcel(const Parcel* 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));

	// Reads the number of items.
	uint32_t numOfItems = 0;
	RETURN_STATUS_IF_ERROR(parcel->readUint32(&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;
	}

	int32_t type;
	RETURN_STATUS_IF_ERROR(parcel->readInt32(&type));
	switch (static_cast<ValueType>(type)) {
	case kTypeInt32: {
	int32_t value32;
	RETURN_STATUS_IF_ERROR(parcel->readInt32(&value32));
	setInt32(std::string(name), value32);
	break;
	}
	case kTypeInt64: {
	int64_t value64;
	RETURN_STATUS_IF_ERROR(parcel->readInt64(&value64));
	setInt64(std::string(name), value64);
	break;
	}
	case kTypeSize: {
	int32_t valueSize;
	RETURN_STATUS_IF_ERROR(parcel->readInt32(&valueSize));
	setInt32(std::string(name), valueSize);
	break;
	}
	case kTypeFloat: {
	float valueFloat;
	RETURN_STATUS_IF_ERROR(parcel->readFloat(&valueFloat));
	setFloat(std::string(name), valueFloat);
	break;
	}
	case kTypeDouble: {
	double valueDouble;
	RETURN_STATUS_IF_ERROR(parcel->readDouble(&valueDouble));
	setDouble(std::string(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);
	break;
	}
	case kTypeInt8: {
	int8_t value8;
	RETURN_STATUS_IF_ERROR(parcel->readByte(&value8));
	setInt8(std::string(name), value8);
	break;
	}
	default: {
	return BAD_TYPE;
	}
	}
	}

	return NO_ERROR;
	}

	status_t ECOData::writeToParcel(Parcel* 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));

	// Writes out number of items.
	RETURN_STATUS_IF_ERROR(parcel->writeUint32(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()));

	// Writes out the data type.
	const ECODataValueType& value = it.second;
	RETURN_STATUS_IF_ERROR(parcel->writeInt32(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)));
	break;

	case kTypeInt64:
	RETURN_STATUS_IF_ERROR(parcel->writeInt64(std::get<int64_t>(it.second)));
	break;

	case kTypeSize:
	RETURN_STATUS_IF_ERROR(parcel->writeUint32(std::get<size_t>(it.second)));
	break;

	case kTypeFloat:
	RETURN_STATUS_IF_ERROR(parcel->writeFloat(std::get<float>(it.second)));
	break;

	case kTypeDouble:
	RETURN_STATUS_IF_ERROR(parcel->writeDouble(std::get<double>(it.second)));
	break;

	case kTypeString:
	RETURN_STATUS_IF_ERROR(parcel->writeCString(std::get<std::string>(it.second).c_str()));
	break;

	case kTypeInt8:
	RETURN_STATUS_IF_ERROR(parcel->writeByte(std::get<int8_t>(it.second)));
	break;

	default:
	return BAD_TYPE;
	}
	}

	return NO_ERROR;
	}

	int32_t ECOData::getDataType() const {
	return mDataType;
	}

	int64_t ECOData::getDataTimeUs() const {
	return mDataTimeUs;
	}

	// Inserts a new key into store if the key does not exist yet. Otherwise, this will override the
	// existing key's value.
	ECODataStatus ECOData::setString(const std::string& key, const std::string& value) {
	if (key.empty() \|\| value.empty()) {
	return ECODataStatus::INVALID_ARGUMENT;
	}

	mKeyValueStore[key] = value;

	// TODO(hkuang): Check the valueType is valid for the key.
	return ECODataStatus::OK;
	}

	ECODataStatus ECOData::findString(const std::string& key, std::string* value) const {
	if (key.empty()) {
	return ECODataStatus::INVALID_ARGUMENT;
	}

	// Check if the key exists.
	if (mKeyValueStore.find(key) == mKeyValueStore.end()) {
	return ECODataStatus::KEY_NOT_EXIST;
	}

	// Safely access the value.
	const std::string& entryValue = std::get<std::string>(mKeyValueStore.at(key));
	value->assign(entryValue);

	return ECODataStatus::OK;
	}

	// Inserts a new key into store if the key does not exist yet. Otherwise, this will override the
	// existing key's value.
	template <typename T>
	ECODataStatus ECOData::setValue(const std::string& key, T value) {
	if (key.empty()) {
	return ECODataStatus::INVALID_ARGUMENT;
	}

	mKeyValueStore[key] = value;
	return ECODataStatus::OK;
	}

	template <typename T>
	ECODataStatus ECOData::findValue(const std::string& key, T* out) const {
	if (key.empty() \|\| out == nullptr) {
	return ECODataStatus::INVALID_ARGUMENT;
	}

	if (mKeyValueStore.find(key) == mKeyValueStore.end()) {
	return ECODataStatus::KEY_NOT_EXIST;
	}

	// Safely access the value.
	*out = std::get<T>(mKeyValueStore.at(key));

	return ECODataStatus::OK;
	}

	ECODataStatus ECOData::setInt32(const std::string& key, int32_t value) {
	return setValue<int32_t>(key, value);
	}

	ECODataStatus ECOData::findInt32(const std::string& key, int32_t* out) const {
	return findValue<int32_t>(key, out);
	}

	ECODataStatus ECOData::setInt64(const std::string& key, int64_t value) {
	return setValue<int64_t>(key, value);
	}

	ECODataStatus ECOData::findInt64(const std::string& key, int64_t* out) const {
	return findValue<int64_t>(key, out);
	}

	ECODataStatus ECOData::setDouble(const std::string& key, double value) {
	return setValue<double>(key, value);
	}

	ECODataStatus ECOData::findDouble(const std::string& key, double* out) const {
	return findValue<double>(key, out);
	}

	ECODataStatus ECOData::setSize(const std::string& key, size_t value) {
	return setValue<size_t>(key, value);
	}

	ECODataStatus ECOData::findSize(const std::string& key, size_t* out) const {
	return findValue<size_t>(key, out);
	}

	ECODataStatus ECOData::setFloat(const std::string& key, float value) {
	return setValue<float>(key, value);
	}

	ECODataStatus ECOData::findFloat(const std::string& key, float* out) const {
	return findValue<float>(key, out);
	}

	ECODataStatus ECOData::setInt8(const std::string& key, int8_t value) {
	return setValue<int8_t>(key, value);
	}

	ECODataStatus ECOData::findInt8(const std::string& key, int8_t* out) const {
	return findValue<int8_t>(key, out);
	}

	ECODataStatus ECOData::set(const std::string& key, const ECOData::ECODataValueType& value) {
	if (key.empty()) {
	return ECODataStatus::INVALID_ARGUMENT;
	}
	mKeyValueStore[key] = value;
	return ECODataStatus::OK;
	}

	ECODataStatus ECOData::find(const std::string& key, ECOData::ECODataValueType* out) const {
	if (key.empty() \|\| out == nullptr) {
	return ECODataStatus::INVALID_ARGUMENT;
	}

	if (mKeyValueStore.find(key) == mKeyValueStore.end()) {
	return ECODataStatus::KEY_NOT_EXIST;
	}

	// Safely access the value.
	*out = mKeyValueStore.at(key);

	return ECODataStatus::OK;
	}

	std::string ECOData::getDataTypeString() const {
	switch (mDataType) {
	case DATA_TYPE_UNKNOWN:
	return "DATA_TYPE_UNKNOWN";
	case DATA_TYPE_STATS:
	return "DATA_TYPE_STATS";
	case DATA_TYPE_INFO:
	return "DATA_TYPE_INFO";
	case DATA_TYPE_STATS_PROVIDER_CONFIG:
	return "DATA_TYPE_STATS_PROVIDER_CONFIG";
	case DATA_TYPE_INFO_LISTENER_CONFIG:
	return "DATA_TYPE_INFO_LISTENER_CONFIG";
	}
	return {};
	}

	// TODO(hkuang): Add test for this.
	bool ECODataKeyValueIterator::hasNext() {
	if (mIterator == mKeyValueStore.end()) return false;

	if (!mBeginReturned) {
	// mIterator has been initialized to the beginning and
	// hasn't been returned. Do not advance:
	mBeginReturned = true;
	} else {
	std::advance(mIterator, 1);
	}
	return mIterator != mKeyValueStore.end();
	}

	// TODO(hkuang): Add test for this.
	ECOData::ECODataKeyValuePair ECODataKeyValueIterator::next() const {
	return ECOData::ECODataKeyValuePair(mIterator->first, mIterator->second);
	}

	std::string ECOData::debugString() const {
	std::string s = "ECOData(type = ";

	std::string tmp;
	switch (mDataType) {
	case DATA_TYPE_UNKNOWN:
	tmp = "Unknown";
	break;
	case DATA_TYPE_STATS:
	tmp = "Stats";
	break;
	case DATA_TYPE_INFO:
	tmp = "Info";
	break;
	case DATA_TYPE_STATS_PROVIDER_CONFIG:
	tmp = "Stats provider config";
	break;
	case DATA_TYPE_INFO_LISTENER_CONFIG:
	tmp = "Info listener config";
	break;
	default:
	break;
	}
	s.append(tmp);
	s.append(") = {\n ");

	// Writes out the key-value pairs one by one.
	for (const auto& it : mKeyValueStore) {
	const size_t SIZE = 100;
	char keyValue[SIZE];
	const ECODataValueType& value = it.second;
	switch (static_cast<ValueType>(value.index())) {
	case kTypeInt32:
	snprintf(keyValue, SIZE, "int32_t %s = %d, ", it.first.c_str(),
	std::get<int32_t>(it.second));
	break;
	case kTypeInt64:
	snprintf(keyValue, SIZE, "int64_t %s = %" PRId64 ", ", it.first.c_str(),
	std::get<int64_t>(it.second));
	break;
	case kTypeSize:
	snprintf(keyValue, SIZE, "size_t %s = %zu, ", it.first.c_str(),
	std::get<size_t>(it.second));
	break;
	case kTypeFloat:
	snprintf(keyValue, SIZE, "float %s = %f, ", it.first.c_str(),
	std::get<float>(it.second));
	break;
	case kTypeDouble:
	snprintf(keyValue, SIZE, "double %s = %f, ", it.first.c_str(),
	std::get<double>(it.second));
	break;
	case kTypeString:
	snprintf(keyValue, SIZE, "string %s = %s, ", it.first.c_str(),
	std::get<std::string>(it.second).c_str());
	break;
	case kTypeInt8:
	snprintf(keyValue, SIZE, "int8_t %s = %d, ", it.first.c_str(),
	std::get<int8_t>(it.second));
	break;
	default:
	break;
	}
	s.append(keyValue);
	}

	s.append("\n }");

	return s;
	}

	} // namespace eco
	} // namespace media
	} // namespace android