Add a android-base shim for floss (0a17f920) · Commits · e / os / android_packages_modules_Bluetooth

floss/android-base/BUILD.gn

0 → 100644

+25 −0

Original line number	Diff line number	Diff line
		#
		# Copyright 2023 Google, Inc.
		#
		# 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.
		#

		config("android-base_config") {
		include_dirs = [ "include" ]
		}

		static_library("android-base") {
		sources = [ "properties.cc" ]
		include_dirs = [ "//bt/system" ]
		public_configs = [ ":android-base_config" ]
		}

floss/android-base/include/android-base/parseint.h

0 → 100644

+145 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2015 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.
		*/

		#pragma once

		#include <errno.h>
		#include <stdlib.h>
		#include <string.h>

		#include <limits>
		#include <string>
		#include <type_traits>

		namespace android {
		namespace base {

		// Parses the unsigned decimal or hexadecimal integer in the string 's' and sets
		// 'out' to that value if it is specified. Optionally allows the caller to
		// define a 'max' beyond which otherwise valid values will be rejected. Returns
		// boolean success; 'out' is untouched if parsing fails.
		template <typename T>
		bool ParseUint(const char* s, T* out, T max = std::numeric_limits<T>::max(),
		bool allow_suffixes = false) {
		static_assert(std::is_unsigned<T>::value,
		"ParseUint can only be used with unsigned types");
		while (isspace(*s)) {
		s++;
		}

		if (s[0] == '-') {
		errno = EINVAL;
		return false;
		}

		// This is never out of bounds. If string is zero-sized, s[0] == '\0'
		// so the second condition is not checked. If string is "0",
		// s[1] will compare against the '\0'.
		int base = (s[0] == '0' && (s[1] == 'x' \|\| s[1] == 'X')) ? 16 : 10;
		errno = 0;
		char* end;
		unsigned long long int result = strtoull(s, &end, base);
		if (errno != 0) return false;
		if (end == s) {
		errno = EINVAL;
		return false;
		}
		if (*end != '\0') {
		const char* suffixes = "bkmgtpe";
		const char* suffix;
		if ((!allow_suffixes \|\|
		(suffix = strchr(suffixes, tolower(*end))) == nullptr) \|\|
		__builtin_mul_overflow(result, 1ULL << (10 * (suffix - suffixes)),
		&result)) {
		errno = EINVAL;
		return false;
		}
		}
		if (max < result) {
		errno = ERANGE;
		return false;
		}
		if (out != nullptr) {
		*out = static_cast<T>(result);
		}
		return true;
		}

		// TODO: string_view
		template <typename T>
		bool ParseUint(const std::string& s, T* out,
		T max = std::numeric_limits<T>::max(),
		bool allow_suffixes = false) {
		return ParseUint(s.c_str(), out, max, allow_suffixes);
		}

		template <typename T>
		bool ParseByteCount(const char* s, T* out,
		T max = std::numeric_limits<T>::max()) {
		return ParseUint(s, out, max, true);
		}

		// TODO: string_view
		template <typename T>
		bool ParseByteCount(const std::string& s, T* out,
		T max = std::numeric_limits<T>::max()) {
		return ParseByteCount(s.c_str(), out, max);
		}

		// Parses the signed decimal or hexadecimal integer in the string 's' and sets
		// 'out' to that value if it is specified. Optionally allows the caller to
		// define a 'min' and 'max' beyond which otherwise valid values will be
		// rejected. Returns boolean success; 'out' is untouched if parsing fails.
		template <typename T>
		bool ParseInt(const char* s, T* out, T min = std::numeric_limits<T>::min(),
		T max = std::numeric_limits<T>::max()) {
		static_assert(std::is_signed<T>::value,
		"ParseInt can only be used with signed types");
		while (isspace(*s)) {
		s++;
		}

		int base = (s[0] == '0' && (s[1] == 'x' \|\| s[1] == 'X')) ? 16 : 10;
		errno = 0;
		char* end;
		long long int result = strtoll(s, &end, base);
		if (errno != 0) {
		return false;
		}
		if (s == end \|\| *end != '\0') {
		errno = EINVAL;
		return false;
		}
		if (result < min \|\| max < result) {
		errno = ERANGE;
		return false;
		}
		if (out != nullptr) {
		*out = static_cast<T>(result);
		}
		return true;
		}

		// TODO: string_view
		template <typename T>
		bool ParseInt(const std::string& s, T* out,
		T min = std::numeric_limits<T>::min(),
		T max = std::numeric_limits<T>::max()) {
		return ParseInt(s.c_str(), out, min, max);
		}

		} // namespace base
		} // namespace android

floss/android-base/include/android-base/properties.h

0 → 100644

+33 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2023 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.
		*/

		#pragma once

		#include <string>

		namespace android {
		namespace base {

		// Returns the current value of the system property `key`,
		// or `default_value` if the property is empty or doesn't exist.
		std::string GetProperty(const std::string& key,
		const std::string& default_value);

		// Sets the system property `key` to `value`.
		bool SetProperty(const std::string& key, const std::string& value);

		} // namespace base
		} // namespace android

floss/android-base/include/log/log.h

0 → 100644

+1 −0

Original line number	Diff line number	Diff line
		#define ALOGV(...)

floss/android-base/properties.cc

0 → 100644

+35 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2023 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.
		*/

		#include "android-base/properties.h"

		#include "gd/os/system_properties.h"

		namespace android {
		namespace base {

		std::string GetProperty(const std::string& key,
		const std::string& default_value) {
		return bluetooth::os::GetSystemProperty(key).value_or(default_value);
		}

		// Sets the system property `key` to `value`.
		bool SetProperty(const std::string& key, const std::string& value) {
		return bluetooth::os::SetSystemProperty(key, value);
		}

		} // namespace base
		} // namespace android