Update a default HIDL EVS HAL implementation (33ba66bb) · Commits · e / os / android_hardware_interfaces

automotive/evs/1.1/default/Android.bp

+16 −18

Original line number	Diff line number	Diff line
		@@ -13,48 +13,46 @@ cc_binary {
		proprietary: true,
		relative_install_path: "hw",
		srcs: [
		"service.cpp",
		"EvsCamera.cpp",
		"EvsEnumerator.cpp",
		"EvsDisplay.cpp",
		"ConfigManager.cpp",
		"ConfigManagerUtil.cpp",
		"EvsUltrasonicsArray.cpp",
		"*.cpp",
		],
		init_rc: ["android.hardware.automotive.evs@1.1-service.rc"],

		shared_libs: [
		"android.frameworks.automotive.display@1.0",
		"android.hardware.automotive.evs@1.0",
		"android.hardware.automotive.evs@1.1",
		"android.hardware.camera.device@3.3",
		"android.hardware.graphics.bufferqueue@1.0",
		"android.hardware.graphics.bufferqueue@2.0",
		"android.hidl.allocator@1.0",
		"android.hidl.memory@1.0",
		"android.hidl.token@1.0-utils",
		"libEGL",
		"libGLESv2",
		"libbase",
		"libbinder",
		"liblog",
		"libbufferqueueconverter",
		"libcamera_metadata",
		"libhardware",
		"libhidlbase",
		"libhidlmemory",
		"liblog",
		"libtinyxml2",
		"libui",
		"libutils",
		"libcamera_metadata",
		"libtinyxml2",
		"android.hidl.token@1.0-utils",
		"android.frameworks.automotive.display@1.0",
		"android.hardware.graphics.bufferqueue@1.0",
		"android.hardware.graphics.bufferqueue@2.0",
		],

		cflags: [
		"-O0",
		"-g",
		"-DLOG_TAG=\"MockEvsDriver\"",
		"-DGL_GLEXT_PROTOTYPES",
		"-DEGL_EGLEXT_PROTOTYPES",
		],
		include_dirs: [
		"frameworks/native/include/",
		],

		required: [
		"evs_default_configuration.xml",
		],

		vintf_fragments: [
		"manifest_android.hardware.automotive.evs@1.1-service.xml",
		],

automotive/evs/1.1/default/ConfigManager.cpp

+100 −146

Original line number	Diff line number	Diff line
		@@ -14,24 +14,26 @@
		* limitations under the License.
		*/

		#include <sstream>
		#include <fstream>
		#include <thread>
		#include "ConfigManager.h"

		#include <android/hardware/camera/device/3.2/ICameraDevice.h>
		#include <hardware/gralloc.h>
		#include <utils/SystemClock.h>
		#include <android/hardware/camera/device/3.2/ICameraDevice.h>

		#include "ConfigManager.h"
		#include <fstream>
		#include <sstream>
		#include <thread>

		using ::android::hardware::camera::device::V3_2::StreamRotation;
		namespace android::hardware::automotive::evs::V1_1::implementation {

		using namespace std;
		using namespace tinyxml2;
		using hardware::camera::device::V3_2::StreamRotation;

		ConfigManager::~ConfigManager() {
		/* Nothing to do */
		}


		void ConfigManager::readCameraInfo(const XMLElement* const aCameraElem) {
		if (aCameraElem == nullptr) {
		ALOGW("XML file does not have required camera element");
		@@ -57,11 +59,9 @@ void ConfigManager::readCameraInfo(const XMLElement * const aCameraElem) {
		/* camera group synchronization */
		const char* sync = curElem->FindAttribute("synchronized")->Value();
		if (!strcmp(sync, "CALIBRATED")) {
		aCamera->synchronized =
		ANDROID_LOGICAL_MULTI_CAMERA_SENSOR_SYNC_TYPE_CALIBRATED;
		aCamera->synchronized = ANDROID_LOGICAL_MULTI_CAMERA_SENSOR_SYNC_TYPE_CALIBRATED;
		} else if (!strcmp(sync, "APPROXIMATE")) {
		aCamera->synchronized =
		ANDROID_LOGICAL_MULTI_CAMERA_SENSOR_SYNC_TYPE_APPROXIMATE;
		aCamera->synchronized = ANDROID_LOGICAL_MULTI_CAMERA_SENSOR_SYNC_TYPE_APPROXIMATE;
		} else {
		aCamera->synchronized = 0; // Not synchronized
		}
		@@ -99,10 +99,7 @@ void ConfigManager::readCameraInfo(const XMLElement * const aCameraElem) {
		}
		}


		bool
		ConfigManager::readCameraDeviceInfo(CameraInfo *aCamera,
		const XMLElement *aDeviceElem) {
		bool ConfigManager::readCameraDeviceInfo(CameraInfo* aCamera, const XMLElement* aDeviceElem) {
		if (aCamera == nullptr \|\| aDeviceElem == nullptr) {
		return false;
		}
		@@ -113,15 +110,10 @@ ConfigManager::readCameraDeviceInfo(CameraInfo *aCamera,

		/* read device capabilities */
		totalEntries +=
		readCameraCapabilities(aDeviceElem->FirstChildElement("caps"),
		aCamera,
		totalDataSize);

		readCameraCapabilities(aDeviceElem->FirstChildElement("caps"), aCamera, totalDataSize);

		/* read camera metadata */
		totalEntries +=
		readCameraMetadata(aDeviceElem->FirstChildElement("characteristics"),
		aCamera,
		totalEntries += readCameraMetadata(aDeviceElem->FirstChildElement("characteristics"), aCamera,
		totalDataSize);

		/* construct camera_metadata_t */
		@@ -133,10 +125,7 @@ ConfigManager::readCameraDeviceInfo(CameraInfo *aCamera,
		return true;
		}


		size_t
		ConfigManager::readCameraCapabilities(const XMLElement * const aCapElem,
		CameraInfo *aCamera,
		size_t ConfigManager::readCameraCapabilities(const XMLElement* const aCapElem, CameraInfo* aCamera,
		size_t& dataSize) {
		if (aCapElem == nullptr \|\| aCamera == nullptr) {
		return 0;
		@@ -150,7 +139,8 @@ ConfigManager::readCameraCapabilities(const XMLElement * const aCapElem,
		if (curElem != nullptr) {
		const XMLElement* ctrlElem = curElem->FirstChildElement("control");
		while (ctrlElem != nullptr) {
		const char *nameAttr = ctrlElem->FindAttribute("name")->Value();;
		const char* nameAttr = ctrlElem->FindAttribute("name")->Value();
		;
		const int32_t minVal = stoi(ctrlElem->FindAttribute("min")->Value());
		const int32_t maxVal = stoi(ctrlElem->FindAttribute("max")->Value());

		@@ -161,12 +151,8 @@ ConfigManager::readCameraCapabilities(const XMLElement * const aCapElem,
		}

		CameraParam aParam;
		if (ConfigManagerUtil::convertToEvsCameraParam(nameAttr,
		aParam)) {
		aCamera->controls.emplace(
		aParam,
		make_tuple(minVal, maxVal, stepVal)
		);
		if (ConfigManagerUtil::convertToEvsCameraParam(nameAttr, aParam)) {
		aCamera->controls.emplace(aParam, make_tuple(minVal, maxVal, stepVal));
		}

		ctrlElem = ctrlElem->NextSiblingElement("control");
		@@ -190,16 +176,13 @@ ConfigManager::readCameraCapabilities(const XMLElement * const aCapElem,
		}

		int32_t pixFormat;
		if (ConfigManagerUtil::convertToPixelFormat(fmtAttr->Value(),
		pixFormat)) {
		RawStreamConfiguration cfg = {
		id,
		if (ConfigManagerUtil::convertToPixelFormat(fmtAttr->Value(), pixFormat)) {
		RawStreamConfiguration cfg = {id,
		stoi(widthAttr->Value()),
		stoi(heightAttr->Value()),
		pixFormat,
		ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS_OUTPUT,
		framerate
		};
		framerate};
		aCamera->streamConfigurations.insert_or_assign(id, cfg);
		}

		@@ -207,20 +190,14 @@ ConfigManager::readCameraCapabilities(const XMLElement * const aCapElem,
		}

		dataSize = calculate_camera_metadata_entry_data_size(
		get_camera_metadata_tag_type(
		ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS
		),
		aCamera->streamConfigurations.size() * kStreamCfgSz
		);
		get_camera_metadata_tag_type(ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS),
		aCamera->streamConfigurations.size() * kStreamCfgSz);

		/* a single camera metadata entry contains multiple stream configurations */
		return dataSize > 0 ? 1 : 0;
		}


		size_t
		ConfigManager::readCameraMetadata(const XMLElement * const aParamElem,
		CameraInfo *aCamera,
		size_t ConfigManager::readCameraMetadata(const XMLElement* const aParamElem, CameraInfo* aCamera,
		size_t& dataSize) {
		if (aParamElem == nullptr \|\| aCamera == nullptr) {
		return 0;
		@@ -241,18 +218,14 @@ ConfigManager::readCameraMetadata(const XMLElement * const aParamElem,
		size_t count = 0;
		void* data = ConfigManagerUtil::convertFloatArray(
		curElem->FindAttribute("size")->Value(),
		curElem->FindAttribute("value")->Value(),
		count
		);
		curElem->FindAttribute("value")->Value(), count);

		aCamera->cameraMetadata.insert_or_assign(
		tag, make_pair(make_unique<void *>(data), count)
		);
		tag, make_pair(make_unique<void*>(data), count));

		++numEntries;
		dataSize += calculate_camera_metadata_entry_data_size(
		get_camera_metadata_tag_type(tag), count
		);
		get_camera_metadata_tag_type(tag), count);

		break;
		}
		@@ -264,13 +237,11 @@ ConfigManager::readCameraMetadata(const XMLElement * const aParamElem,
		curElem->FindAttribute("value")->Value(), *data)) {
		curElem->FindAttribute("value")->Value(),
		aCamera->cameraMetadata.insert_or_assign(
		tag, make_pair(make_unique<void *>(data), 1)
		);
		tag, make_pair(make_unique<void*>(data), 1));

		++numEntries;
		dataSize += calculate_camera_metadata_entry_data_size(
		get_camera_metadata_tag_type(tag), 1
		);
		get_camera_metadata_tag_type(tag), 1);
		}
		break;
		}
		@@ -279,9 +250,7 @@ ConfigManager::readCameraMetadata(const XMLElement * const aParamElem,
		/* a comma-separated list of physical camera devices */
		size_t len = strlen(curElem->FindAttribute("value")->Value());
		char* data = new char[len + 1];
		memcpy(data,
		curElem->FindAttribute("value")->Value(),
		len * sizeof(char));
		memcpy(data, curElem->FindAttribute("value")->Value(), len * sizeof(char));

		/* replace commas with null char */
		char* p = data;
		@@ -293,19 +262,16 @@ ConfigManager::readCameraMetadata(const XMLElement * const aParamElem,
		}

		aCamera->cameraMetadata.insert_or_assign(
		tag, make_pair(make_unique<void *>(data), len)
		);
		tag, make_pair(make_unique<void*>(data), len));

		++numEntries;
		dataSize += calculate_camera_metadata_entry_data_size(
		get_camera_metadata_tag_type(tag), len
		);
		get_camera_metadata_tag_type(tag), len);
		break;
		}

		default:
		ALOGW("Parameter %s is not supported",
		curElem->FindAttribute("name")->Value());
		ALOGW("Parameter %s is not supported", curElem->FindAttribute("name")->Value());
		break;
		}
		}
		@@ -316,10 +282,7 @@ ConfigManager::readCameraMetadata(const XMLElement * const aParamElem,
		return numEntries;
		}


		bool
		ConfigManager::constructCameraMetadata(CameraInfo *aCamera,
		const size_t totalEntries,
		bool ConfigManager::constructCameraMetadata(CameraInfo* aCamera, const size_t totalEntries,
		const size_t totalDataSize) {
		if (aCamera == nullptr \|\| !aCamera->allocate(totalEntries, totalDataSize)) {
		ALOGE("Failed to allocate memory for camera metadata");
		@@ -336,8 +299,7 @@ ConfigManager::constructCameraMetadata(CameraInfo *aCamera,
		}
		int32_t err = add_camera_metadata_entry(aCamera->characteristics,
		ANDROID_SCALER_AVAILABLE_STREAM_CONFIGURATIONS,
		data.get(),
		numStreamConfigs * kStreamCfgSz);
		data.get(), numStreamConfigs * kStreamCfgSz);

		if (err) {
		ALOGE("Failed to add stream configurations to metadata, ignored");
		@@ -347,9 +309,7 @@ ConfigManager::constructCameraMetadata(CameraInfo *aCamera,
		bool success = true;
		for (auto& [tag, entry] : aCamera->cameraMetadata) {
		/* try to add new camera metadata entry */
		int32_t err = add_camera_metadata_entry(aCamera->characteristics,
		tag,
		entry.first.get(),
		int32_t err = add_camera_metadata_entry(aCamera->characteristics, tag, entry.first.get(),
		entry.second);
		if (err) {
		ALOGE("Failed to add an entry with a tag 0x%X", tag);
		@@ -376,7 +336,6 @@ ConfigManager::constructCameraMetadata(CameraInfo *aCamera,
		return success;
		}


		void ConfigManager::readSystemInfo(const XMLElement* const aSysElem) {
		if (aSysElem == nullptr) {
		return;
		@@ -391,12 +350,10 @@ void ConfigManager::readSystemInfo(const XMLElement * const aSysElem) {
		/* read number of cameras available in the system */
		const XMLElement* xmlElem = aSysElem->FirstChildElement("num_cameras");
		if (xmlElem != nullptr) {
		mSystemInfo.numCameras =
		stoi(xmlElem->FindAttribute("value")->Value());
		mSystemInfo.numCameras = stoi(xmlElem->FindAttribute("value")->Value());
		}
		}


		void ConfigManager::readDisplayInfo(const XMLElement* const aDisplayElem) {
		if (aDisplayElem == nullptr) {
		ALOGW("XML file does not have required camera element");
		@@ -426,8 +383,7 @@ void ConfigManager::readDisplayInfo(const XMLElement * const aDisplayElem) {

		const int32_t id = stoi(idAttr->Value());
		int32_t pixFormat;
		if (ConfigManagerUtil::convertToPixelFormat(fmtAttr->Value(),
		pixFormat)) {
		if (ConfigManagerUtil::convertToPixelFormat(fmtAttr->Value(), pixFormat)) {
		RawStreamConfiguration cfg = {
		id,
		stoi(widthAttr->Value()),
		@@ -450,7 +406,6 @@ void ConfigManager::readDisplayInfo(const XMLElement * const aDisplayElem) {
		return;
		}


		bool ConfigManager::readConfigDataFromXML() noexcept {
		XMLDocument xmlDoc;

		@@ -487,11 +442,9 @@ bool ConfigManager::readConfigDataFromXML() noexcept {
		ALOGI("Parsing configuration file takes %lf (ms)",
		(double)(parsingEnd - parsingStart) / 1000000.0);


		return true;
		}


		std::unique_ptr<ConfigManager> ConfigManager::Create(const char* path) {
		unique_ptr<ConfigManager> cfgMgr(new ConfigManager(path));

		@@ -510,3 +463,4 @@ std::unique_ptr<ConfigManager> ConfigManager::Create(const char *path) {
		}
		}

		} // namespace android::hardware::automotive::evs::V1_1::implementation

automotive/evs/1.1/default/ConfigManager.h

+57 −73

Original line number	Diff line number	Diff line
		@@ -13,28 +13,26 @@
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*/
		#ifndef CONFIG_MANAGER_H
		#define CONFIG_MANAGER_H
		#ifndef ANDROID_HARDWARE_AUTOMOTIVE_EVS_V1_1_CONFIGMANAGER_H
		#define ANDROID_HARDWARE_AUTOMOTIVE_EVS_V1_1_CONFIGMANAGER_H

		#include <vector>
		#include <string>
		#include <unordered_map>
		#include <unordered_set>

		#include <tinyxml2.h>
		#include "ConfigManagerUtil.h"

		#include <system/camera_metadata.h>
		#include <log/log.h>
		#include <android/hardware/automotive/evs/1.1/types.h>
		#include <log/log.h>
		#include <system/camera_metadata.h>
		#include <tinyxml2.h>

		#include "ConfigManagerUtil.h"
		#include <string>
		#include <unordered_map>
		#include <unordered_set>
		#include <vector>

		using namespace std;
		using namespace tinyxml2;
		namespace android::hardware::automotive::evs::V1_1::implementation {

		using ::android::hardware::hidl_vec;
		using ::android::hardware::camera::device::V3_2::Stream;
		using ::android::hardware::automotive::evs::V1_1::CameraParam;
		using hardware::hidl_vec;
		using hardware::automotive::evs::V1_1::CameraParam;
		using hardware::camera::device::V3_2::Stream;

		/*
		* Plese note that this is different from what is defined in
		@@ -55,14 +53,10 @@ public:
		/* Camera device's capabilities and metadata */
		class CameraInfo {
		public:
		CameraInfo() :
		characteristics(nullptr) {
		/* Nothing to do */
		CameraInfo() : characteristics(nullptr) { /* Nothing to do */
		}

		virtual ~CameraInfo() {
		free_camera_metadata(characteristics);
		}
		virtual ~CameraInfo() { free_camera_metadata(characteristics); }

		/* Allocate memory for camera_metadata_t */
		bool allocate(size_t entry_cap, size_t data_cap) {
		@@ -79,21 +73,20 @@ public:
		* List of supported controls that the primary client can program.
		* Paraemters are stored with its valid range
		*/
		unordered_map<CameraParam,
		tuple<int32_t, int32_t, int32_t>> controls;
		std::unordered_map<CameraParam, std::tuple<int32_t, int32_t, int32_t>> controls;

		/*
		* List of supported output stream configurations; each array stores
		* format, width, height, and direction values in the order.
		*/
		unordered_map<int32_t, RawStreamConfiguration> streamConfigurations;
		std::unordered_map<int32_t, RawStreamConfiguration> streamConfigurations;

		/*
		* Internal storage for camera metadata. Each entry holds a pointer to
		* data and number of elements
		*/
		unordered_map<camera_metadata_tag_t,
		pair<unique_ptr<void *>, size_t>> cameraMetadata;
		std::unordered_map<camera_metadata_tag_t, std::pair<std::unique_ptr<void*>, size_t>>
		cameraMetadata;

		/* Camera module characteristics */
		camera_metadata_t* characteristics;
		@@ -104,7 +97,7 @@ public:
		CameraGroupInfo() {}

		/* ID of member camera devices */
		unordered_set<string> devices;
		std::unordered_set<std::string> devices;

		/* The capture operation of member camera devices are synchronized */
		bool synchronized = false;
		@@ -122,7 +115,7 @@ public:
		* List of supported input stream configurations; each array stores
		* format, width, height, and direction values in the order.
		*/
		unordered_map<int32_t, RawStreamConfiguration> streamConfigurations;
		std::unordered_map<int32_t, RawStreamConfiguration> streamConfigurations;
		};

		/*
		@@ -131,77 +124,71 @@ public:
		* @return SystemInfo
		* Constant reference of SystemInfo.
		*/
		const SystemInfo &getSystemInfo() {
		return mSystemInfo;
		}
		const SystemInfo& getSystemInfo() { return mSystemInfo; }

		/*
		* Return a list of cameras
		*
		* This function assumes that it is not being called frequently.
		*
		* @return vector<string>
		* @return std::vector<std::string>
		* A vector that contains unique camera device identifiers.
		*/
		vector<string> getCameraList() {
		vector<string> aList;
		std::vector<std::string> getCameraList() {
		std::vector<std::string> aList;
		for (auto& v : mCameraInfo) {
		aList.emplace_back(v.first);
		aList.push_back(v.first);
		}

		return aList;
		}


		/*
		* Return a list of cameras
		*
		* @return CameraGroupInfo
		* A pointer to a camera group identified by a given id.
		*/
		unique_ptr<CameraGroupInfo>& getCameraGroupInfo(const string& gid) {
		std::unique_ptr<CameraGroupInfo>& getCameraGroupInfo(const std::string& gid) {
		return mCameraGroupInfos[gid];
		}


		/*
		* Return a camera metadata
		*
		* @param cameraId
		* Unique camera node identifier in string
		* Unique camera node identifier in std::string
		*
		* @return unique_ptr<CameraInfo>
		* @return std::unique_ptr<CameraInfo>
		* A pointer to CameraInfo that is associated with a given camera
		* ID. This returns a null pointer if this does not recognize a
		* given camera identifier.
		*/
		unique_ptr<CameraInfo>& getCameraInfo(const string cameraId) noexcept {
		std::unique_ptr<CameraInfo>& getCameraInfo(const std::string cameraId) noexcept {
		return mCameraInfo[cameraId];
		}

		private:
		/* Constructors */
		ConfigManager(const char *xmlPath) :
		mConfigFilePath(xmlPath) {
		}
		ConfigManager(const char* xmlPath) : mConfigFilePath(xmlPath) {}

		/* System configuration */
		SystemInfo mSystemInfo;

		/* Internal data structure for camera device information */
		unordered_map<string, unique_ptr<CameraInfo>> mCameraInfo;
		std::unordered_map<std::string, std::unique_ptr<CameraInfo>> mCameraInfo;

		/* Internal data structure for camera device information */
		unordered_map<string, unique_ptr<DisplayInfo>> mDisplayInfo;
		std::unordered_map<std::string, std::unique_ptr<DisplayInfo>> mDisplayInfo;

		/* Camera groups are stored in <groud id, CameraGroupInfo> hash map */
		unordered_map<string, unique_ptr<CameraGroupInfo>> mCameraGroupInfos;
		std::unordered_map<std::string, std::unique_ptr<CameraGroupInfo>> mCameraGroupInfos;

		/*
		* Camera positions are stored in <position, camera id set> hash map.
		* The position must be one of front, rear, left, and right.
		*/
		unordered_map<string, unordered_set<string>> mCameraPosition;
		std::unordered_map<std::string, std::unordered_set<std::string>> mCameraPosition;

		/* A path to XML configuration file */
		const char* mConfigFilePath;
		@@ -221,7 +208,7 @@ private:
		* @param aSysElem
		* A pointer to "system" XML element.
		*/
		void readSystemInfo(const XMLElement * const aSysElem);
		void readSystemInfo(const tinyxml2::XMLElement* const aSysElem);

		/*
		* read the information of camera devices
		@@ -230,7 +217,7 @@ private:
		* A pointer to "camera" XML element that may contain multiple
		* "device" elements.
		*/
		void readCameraInfo(const XMLElement * const aCameraElem);
		void readCameraInfo(const tinyxml2::XMLElement* const aCameraElem);

		/*
		* read display device information
		@@ -239,7 +226,7 @@ private:
		* A pointer to "display" XML element that may contain multiple
		* "device" elements.
		*/
		void readDisplayInfo(const XMLElement * const aDisplayElem);
		void readDisplayInfo(const tinyxml2::XMLElement* const aDisplayElem);

		/*
		* read camera device information
		@@ -255,8 +242,7 @@ private:
		* Return false upon any failure in reading and processing camera
		* device information.
		*/
		bool readCameraDeviceInfo(CameraInfo *aCamera,
		const XMLElement *aDeviceElem);
		bool readCameraDeviceInfo(CameraInfo* aCamera, const tinyxml2::XMLElement* aDeviceElem);

		/*
		* read camera metadata
		@@ -273,8 +259,7 @@ private:
		* @return size_t
		* Number of camera metadata entries
		*/
		size_t readCameraCapabilities(const XMLElement * const aCapElem,
		CameraInfo *aCamera,
		size_t readCameraCapabilities(const tinyxml2::XMLElement* const aCapElem, CameraInfo* aCamera,
		size_t& dataSize);

		/*
		@@ -291,8 +276,7 @@ private:
		* @return size_t
		* Number of camera metadata entries
		*/
		size_t readCameraMetadata(const XMLElement * const aParamElem,
		CameraInfo *aCamera,
		size_t readCameraMetadata(const tinyxml2::XMLElement* const aParamElem, CameraInfo* aCamera,
		size_t& dataSize);

		/*
		@@ -310,9 +294,9 @@ private:
		* or its size is not large enough to add all found camera metadata
		* entries.
		*/
		bool constructCameraMetadata(CameraInfo *aCamera,
		const size_t totalEntries,
		bool constructCameraMetadata(CameraInfo* aCamera, const size_t totalEntries,
		const size_t totalDataSize);
		};
		#endif // CONFIG_MANAGER_H

		} // namespace android::hardware::automotive::evs::V1_1::implementation
		#endif // ANDROID_HARDWARE_AUTOMOTIVE_EVS_V1_1_CONFIGMANAGER_H

automotive/evs/1.1/default/ConfigManagerUtil.cpp

+37 −43

File changed.

Preview size limit exceeded, changes collapsed.

automotive/evs/1.1/default/ConfigManagerUtil.h

+15 −24

File changed.

Preview size limit exceeded, changes collapsed.