Snap for 11926388 from 683fe045ffbfd5de81ceb3385b73ad0d687f83a3 to 24Q3-release (3405ac2b) · Commits · e / os / android_frameworks_native

libs/binder/PersistableBundle.cpp

+6 −7

Original line number	Diff line number	Diff line
		@@ -86,7 +86,6 @@ namespace os {
		{ \
		size_t num_erased = (map).erase(key); \
		if (num_erased) { \
		ALOGE("Failed at %s:%d (%s)", __FILE__, __LINE__, __func__); \
		return num_erased; \
		} \
		}

libs/binder/tests/Android.bp

+1 −0

Original line number	Diff line number	Diff line
		@@ -62,6 +62,7 @@ cc_test {
		"binderStatusUnitTest.cpp",
		"binderMemoryHeapBaseUnitTest.cpp",
		"binderRecordedTransactionTest.cpp",
		"binderPersistableBundleTest.cpp",
		],
		shared_libs: [
		"libbinder",

libs/binder/tests/binderLibTest.cpp

+32 −1

Original line number	Diff line number	Diff line
		@@ -38,6 +38,7 @@
		#include <binder/IServiceManager.h>
		#include <binder/RpcServer.h>
		#include <binder/RpcSession.h>
		#include <binder/Status.h>
		#include <binder/unique_fd.h>
		#include <utils/Flattenable.h>

		@@ -57,6 +58,7 @@ using namespace std::string_literals;
		using namespace std::chrono_literals;
		using android::base::testing::HasValue;
		using android::base::testing::Ok;
		using android::binder::Status;
		using android::binder::unique_fd;
		using testing::ExplainMatchResult;
		using testing::Matcher;
		@@ -461,6 +463,35 @@ TEST_F(BinderLibTest, AddManagerToManager) {
		EXPECT_EQ(NO_ERROR, sm->addService(String16("binderLibTest-manager"), binder));
		}

		TEST_F(BinderLibTest, RegisterForNotificationsFailure) {
		auto sm = defaultServiceManager();
		using LocalRegistrationCallback = IServiceManager::LocalRegistrationCallback;
		class LocalRegistrationCallbackImpl : public virtual LocalRegistrationCallback {
		void onServiceRegistration(const String16&, const sp<IBinder>&) override {}
		virtual ~LocalRegistrationCallbackImpl() {}
		};
		sp<LocalRegistrationCallback> cb = sp<LocalRegistrationCallbackImpl>::make();

		EXPECT_EQ(BAD_VALUE, sm->registerForNotifications(String16("ValidName"), nullptr));
		EXPECT_EQ(UNKNOWN_ERROR, sm->registerForNotifications(String16("InvalidName!$"), cb));
		}

		TEST_F(BinderLibTest, UnregisterForNotificationsFailure) {
		auto sm = defaultServiceManager();
		using LocalRegistrationCallback = IServiceManager::LocalRegistrationCallback;
		class LocalRegistrationCallbackImpl : public virtual LocalRegistrationCallback {
		void onServiceRegistration(const String16&, const sp<IBinder>&) override {}
		virtual ~LocalRegistrationCallbackImpl() {}
		};
		sp<LocalRegistrationCallback> cb = sp<LocalRegistrationCallbackImpl>::make();

		EXPECT_EQ(OK, sm->registerForNotifications(String16("ValidName"), cb));

		EXPECT_EQ(BAD_VALUE, sm->unregisterForNotifications(String16("ValidName"), nullptr));
		EXPECT_EQ(BAD_VALUE, sm->unregisterForNotifications(String16("AnotherValidName"), cb));
		EXPECT_EQ(BAD_VALUE, sm->unregisterForNotifications(String16("InvalidName!!!"), cb));
		}

		TEST_F(BinderLibTest, WasParceled) {
		auto binder = sp<BBinder>::make();
		EXPECT_FALSE(binder->wasParceled());

libs/binder/tests/binderPersistableBundleTest.cpp

0 → 100644

+134 −0

Original line number	Diff line number	Diff line
		/*
		* Copyright (C) 2024 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 <binder/Parcel.h>
		#include <binder/PersistableBundle.h>
		#include <gtest/gtest.h>
		#include <numeric>

		using android::OK;
		using android::Parcel;
		using android::status_t;
		using android::String16;
		using android::String8;
		using android::os::PersistableBundle;

		namespace android {

		inline std::string to_string(String16 const& str) {
		return String8{str}.c_str();
		}

		namespace os {

		template <typename T>
		inline std::ostream& operator<<(std::ostream& out, std::vector<T> const& vec) {
		using std::to_string;
		auto str =
		std::accumulate(vec.begin(), vec.end(), std::string{},
		[](std::string const& a, auto const& b) { return a + to_string(b); });
		return out << str;
		}

		inline std::ostream& operator<<(std::ostream& out, PersistableBundle const& pb) {
		#define PRINT(TYPENAME, TYPE) \
		for (auto const& key : pb.get##TYPENAME##Keys()) { \
		TYPE val{}; \
		pb.get##TYPENAME(key, &val); \
		out << #TYPE " " << key << ": " << val << std::endl; \
		}

		out << "size: " << pb.size() << std::endl;
		PRINT(Boolean, bool);
		PRINT(Int, int);
		PRINT(Long, int64_t);
		PRINT(Double, double);
		PRINT(String, String16);
		PRINT(BooleanVector, std::vector<bool>);
		PRINT(IntVector, std::vector<int32_t>);
		PRINT(LongVector, std::vector<int64_t>);
		PRINT(DoubleVector, std::vector<double>);
		PRINT(StringVector, std::vector<String16>);
		PRINT(PersistableBundle, PersistableBundle);

		#undef PRINT

		return out;
		}

		} // namespace os
		} // namespace android

		static const String16 kKey{"key"};

		static PersistableBundle createSimplePersistableBundle() {
		PersistableBundle pb{};
		pb.putInt(kKey, 64);
		return pb;
		}

		#define TEST_PUT_AND_GET(TYPENAME, TYPE, ...) \
		TEST(PersistableBundle, PutAndGet##TYPENAME) { \
		TYPE const expected{__VA_ARGS__}; \
		PersistableBundle pb{}; \
		\
		pb.put##TYPENAME(kKey, expected); \
		\
		std::set<String16> expectedKeys{kKey}; \
		EXPECT_EQ(pb.get##TYPENAME##Keys(), expectedKeys); \
		\
		TYPE val{}; \
		EXPECT_TRUE(pb.get##TYPENAME(kKey, &val)); \
		EXPECT_EQ(val, expected); \
		}

		TEST_PUT_AND_GET(Boolean, bool, true);
		TEST_PUT_AND_GET(Int, int, 64);
		TEST_PUT_AND_GET(Long, int64_t, 42);
		TEST_PUT_AND_GET(Double, double, 42.64);
		TEST_PUT_AND_GET(String, String16, String16{"foo"});
		TEST_PUT_AND_GET(BooleanVector, std::vector<bool>, true, true);
		TEST_PUT_AND_GET(IntVector, std::vector<int32_t>, 1, 2);
		TEST_PUT_AND_GET(LongVector, std::vector<int64_t>, 1, 2);
		TEST_PUT_AND_GET(DoubleVector, std::vector<double>, 4.2, 5.9);
		TEST_PUT_AND_GET(StringVector, std::vector<String16>, String16{"foo"}, String16{"bar"});
		TEST_PUT_AND_GET(PersistableBundle, PersistableBundle, createSimplePersistableBundle());

		TEST(PersistableBundle, ParcelAndUnparcel) {
		PersistableBundle expected = createSimplePersistableBundle();
		PersistableBundle out{};

		Parcel p{};
		EXPECT_EQ(expected.writeToParcel(&p), 0);
		p.setDataPosition(0);
		EXPECT_EQ(out.readFromParcel(&p), 0);

		EXPECT_EQ(expected, out);
		}

		TEST(PersistableBundle, OverwriteKey) {
		PersistableBundle pb{};

		pb.putInt(kKey, 64);
		pb.putDouble(kKey, 0.5);

		EXPECT_EQ(pb.getIntKeys().size(), 0);
		EXPECT_EQ(pb.getDoubleKeys().size(), 1);

		double out;
		EXPECT_TRUE(pb.getDouble(kKey, &out));
		EXPECT_EQ(out, 0.5);
		}

services/sensorservice/senserservice_flags.aconfig

+7 −0

Original line number	Diff line number	Diff line
		@@ -28,3 +28,10 @@ flag {
		description: "When this flag is enabled, sensor service will only erase dynamic sensor data at the end of the threadLoop to prevent race condition."
		bug: "329020894"
		}

		flag {
		name: "sensor_service_report_sensor_usage_in_tracing"
		namespace: "sensors"
		description: "When this flag is enabled, sensor service will report sensor usage when system trace is enabled."
		bug: "333132224"
		}
		No newline at end of file