Snap for 12502765 from ee9b3db98daef658ac789e1713348c930729224e to 25Q1-release (5d4f2279) · Commits · e / os / android_frameworks_av

camera/cameraserver/Android.bp

+6 −1

Original line number	Diff line number	Diff line
		@@ -22,6 +22,11 @@ package {
		default_applicable_licenses: ["frameworks_av_camera_license"],
		}

		vintf_fragment {
		name: "manifest_android.frameworks.cameraservice.service.xml",
		src: "manifest_android.frameworks.cameraservice.service.xml",
		}

		cc_binary {
		name: "cameraserver",

		@@ -61,7 +66,7 @@ cc_binary {

		init_rc: ["cameraserver.rc"],

		vintf_fragments: [
		vintf_fragment_modules: [
		"manifest_android.frameworks.cameraservice.service.xml",
		],
		}

media/audioaidlconversion/AidlConversionCppNdk.cpp

+32 −4

Original line number	Diff line number	Diff line
		@@ -1057,6 +1057,14 @@ AudioDeviceAddress::Tag suggestDeviceAddressTag(const AudioDeviceDescription& de
		return OK;
		}

		namespace {
		// Use '01' for LSB bits 0 and 1 as Bluetooth MAC addresses are never multicast
		// and universaly administered
		constexpr std::array<uint8_t, 4> BTANON_PREFIX {0xFD, 0xFF, 0xFF, 0xFF};
		// Keep sync with ServiceUtilities.cpp mustAnonymizeBluetoothAddress
		constexpr const char * BTANON_PREFIX_STR = "XX:XX:XX:XX:";
		}

		::android::status_t aidl2legacy_AudioDevice_audio_device(
		const AudioDevice& aidl,
		audio_devices_t* legacyType, std::string* legacyAddress) {
		@@ -1071,8 +1079,16 @@ AudioDeviceAddress::Tag suggestDeviceAddressTag(const AudioDeviceDescription& de
		case Tag::mac: {
		const std::vector<uint8_t>& mac = aidl.address.get<AudioDeviceAddress::mac>();
		if (mac.size() != 6) return BAD_VALUE;
		snprintf(addressBuffer, AUDIO_DEVICE_MAX_ADDRESS_LEN, "%02X:%02X:%02X:%02X:%02X:%02X",
		if (std::equal(BTANON_PREFIX.begin(), BTANON_PREFIX.end(), mac.begin())) {
		// special case for anonymized mac address:
		// change anonymized bytes back from FD:FF:FF:FF: to XX:XX:XX:XX:
		snprintf(addressBuffer, AUDIO_DEVICE_MAX_ADDRESS_LEN,
		"%s%02X:%02X", BTANON_PREFIX_STR, mac[4], mac[5]);
		} else {
		snprintf(addressBuffer, AUDIO_DEVICE_MAX_ADDRESS_LEN,
		"%02X:%02X:%02X:%02X:%02X:%02X",
		mac[0], mac[1], mac[2], mac[3], mac[4], mac[5]);
		}
		} break;
		case Tag::ipv4: {
		const std::vector<uint8_t>& ipv4 = aidl.address.get<AudioDeviceAddress::ipv4>();
		@@ -1134,8 +1150,20 @@ legacy2aidl_audio_device_AudioDevice(
		switch (suggestDeviceAddressTag(aidl.type)) {
		case Tag::mac: {
		std::vector<uint8_t> mac(6);
		int status = sscanf(legacyAddress.c_str(), "%hhX:%hhX:%hhX:%hhX:%hhX:%hhX",
		int status;
		// special case for anonymized mac address:
		// change anonymized bytes so that they can be scanned as HEX bytes
		if (legacyAddress.starts_with(BTANON_PREFIX_STR)) {
		std::copy(BTANON_PREFIX.begin(), BTANON_PREFIX.end(), mac.begin());
		LOG_ALWAYS_FATAL_IF(legacyAddress.length() <= strlen(BTANON_PREFIX_STR));
		status = sscanf(legacyAddress.c_str() + strlen(BTANON_PREFIX_STR),
		"%hhX:%hhX",
		&mac[4], &mac[5]);
		status += 4;
		} else {
		status = sscanf(legacyAddress.c_str(), "%hhX:%hhX:%hhX:%hhX:%hhX:%hhX",
		&mac[0], &mac[1], &mac[2], &mac[3], &mac[4], &mac[5]);
		}
		if (status != mac.size()) {
		ALOGE("%s: malformed MAC address: \"%s\"", __func__, legacyAddress.c_str());
		return unexpected(BAD_VALUE);

media/audioserver/main_audioserver.cpp

+1 −0

Original line number	Diff line number	Diff line
		@@ -205,6 +205,7 @@ int main(int argc __unused, char **argv)
		__func__, status, policyInfos.size());
		}
		const auto endTime = std::chrono::steady_clock::now();
		af->startupFinished();
		using FloatMillis = std::chrono::duration<float, std::milli>;
		const float timeTaken = std::chrono::duration_cast<FloatMillis>(
		endTime - startTime).count();

media/libaudioclient/AudioSystem.cpp

+12 −7

Original line number	Diff line number	Diff line
		@@ -308,11 +308,11 @@ status_t AudioSystem::getMasterMute(bool* mute) {
		}

		status_t AudioSystem::setStreamVolume(audio_stream_type_t stream, float value,
		audio_io_handle_t output) {
		bool muted, audio_io_handle_t output) {
		if (uint32_t(stream) >= AUDIO_STREAM_CNT) return BAD_VALUE;
		const sp<IAudioFlinger> af = get_audio_flinger();
		if (af == 0) return PERMISSION_DENIED;
		af->setStreamVolume(stream, value, output);
		af->setStreamVolume(stream, value, muted, output);
		return NO_ERROR;
		}

		@@ -325,14 +325,15 @@ status_t AudioSystem::setStreamMute(audio_stream_type_t stream, bool mute) {
		}

		status_t AudioSystem::setPortsVolume(
		const std::vector<audio_port_handle_t>& portIds, float volume, audio_io_handle_t output) {
		const std::vector<audio_port_handle_t>& portIds, float volume, bool muted,
		audio_io_handle_t output) {
		const sp<IAudioFlinger> af = get_audio_flinger();
		if (af == 0) return PERMISSION_DENIED;
		std::vector<int32_t> portIdsAidl = VALUE_OR_RETURN_STATUS(
		convertContainer<std::vector<int32_t>>(
		portIds, legacy2aidl_audio_port_handle_t_int32_t));
		int32_t outputAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_io_handle_t_int32_t(output));
		af->setPortsVolume(portIdsAidl, volume, outputAidl);
		af->setPortsVolume(portIdsAidl, volume, muted, outputAidl);
		return NO_ERROR;
		}

		@@ -1096,7 +1097,8 @@ status_t AudioSystem::getOutputForAttr(audio_attributes_t* attr,
		std::vector<audio_io_handle_t>* secondaryOutputs,
		bool *isSpatialized,
		bool *isBitPerfect,
		float *volume) {
		float *volume,
		bool *muted) {
		if (attr == nullptr) {
		ALOGE("%s NULL audio attributes", __func__);
		return BAD_VALUE;
		@@ -1163,6 +1165,7 @@ status_t AudioSystem::getOutputForAttr(audio_attributes_t* attr,
		*attr = VALUE_OR_RETURN_STATUS(
		aidl2legacy_AudioAttributes_audio_attributes_t(responseAidl.attr));
		*volume = responseAidl.volume;
		*muted = responseAidl.muted;

		return OK;
		}
		@@ -1326,6 +1329,7 @@ status_t AudioSystem::initStreamVolume(audio_stream_type_t stream,

		status_t AudioSystem::setStreamVolumeIndex(audio_stream_type_t stream,
		int index,
		bool muted,
		audio_devices_t device) {
		const sp<IAudioPolicyService> aps = get_audio_policy_service();
		if (aps == 0) return PERMISSION_DENIED;
		@@ -1336,7 +1340,7 @@ status_t AudioSystem::setStreamVolumeIndex(audio_stream_type_t stream,
		AudioDeviceDescription deviceAidl = VALUE_OR_RETURN_STATUS(
		legacy2aidl_audio_devices_t_AudioDeviceDescription(device));
		return statusTFromBinderStatus(
		aps->setStreamVolumeIndex(streamAidl, deviceAidl, indexAidl));
		aps->setStreamVolumeIndex(streamAidl, deviceAidl, indexAidl, muted));
		}

		status_t AudioSystem::getStreamVolumeIndex(audio_stream_type_t stream,
		@@ -1360,6 +1364,7 @@ status_t AudioSystem::getStreamVolumeIndex(audio_stream_type_t stream,

		status_t AudioSystem::setVolumeIndexForAttributes(const audio_attributes_t& attr,
		int index,
		bool muted,
		audio_devices_t device) {
		const sp<IAudioPolicyService> aps = get_audio_policy_service();
		if (aps == 0) return PERMISSION_DENIED;
		@@ -1370,7 +1375,7 @@ status_t AudioSystem::setVolumeIndexForAttributes(const audio_attributes_t& attr
		AudioDeviceDescription deviceAidl = VALUE_OR_RETURN_STATUS(
		legacy2aidl_audio_devices_t_AudioDeviceDescription(device));
		return statusTFromBinderStatus(
		aps->setVolumeIndexForAttributes(attrAidl, deviceAidl, indexAidl));
		aps->setVolumeIndexForAttributes(attrAidl, deviceAidl, indexAidl, muted));
		}

		status_t AudioSystem::getVolumeIndexForAttributes(const audio_attributes_t& attr,

media/libaudioclient/IAudioFlinger.cpp

+13 −8

Original line number	Diff line number	Diff line
		@@ -337,11 +337,12 @@ status_t AudioFlingerClientAdapter::getMasterBalance(float* balance) const{
		}

		status_t AudioFlingerClientAdapter::setStreamVolume(audio_stream_type_t stream, float value,
		audio_io_handle_t output) {
		bool muted, audio_io_handle_t output) {
		AudioStreamType streamAidl = VALUE_OR_RETURN_STATUS(
		legacy2aidl_audio_stream_type_t_AudioStreamType(stream));
		int32_t outputAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_io_handle_t_int32_t(output));
		return statusTFromBinderStatus(mDelegate->setStreamVolume(streamAidl, value, outputAidl));
		return statusTFromBinderStatus(
		mDelegate->setStreamVolume(streamAidl, value, muted, outputAidl));
		}

		status_t AudioFlingerClientAdapter::setStreamMute(audio_stream_type_t stream, bool muted) {
		@@ -351,12 +352,14 @@ status_t AudioFlingerClientAdapter::setStreamMute(audio_stream_type_t stream, bo
		}

		status_t AudioFlingerClientAdapter::setPortsVolume(
		const std::vector<audio_port_handle_t>& portIds, float volume, audio_io_handle_t output) {
		const std::vector<audio_port_handle_t> &portIds, float volume, bool muted,
		audio_io_handle_t output) {
		std::vector<int32_t> portIdsAidl = VALUE_OR_RETURN_STATUS(
		convertContainer<std::vector<int32_t>>(
		portIds, legacy2aidl_audio_port_handle_t_int32_t));
		int32_t outputAidl = VALUE_OR_RETURN_STATUS(legacy2aidl_audio_io_handle_t_int32_t(output));
		return statusTFromBinderStatus(mDelegate->setPortsVolume(portIdsAidl, volume, outputAidl));
		return statusTFromBinderStatus(
		mDelegate->setPortsVolume(portIdsAidl, volume, muted, outputAidl));
		}

		status_t AudioFlingerClientAdapter::setMode(audio_mode_t mode) {
		@@ -1007,12 +1010,13 @@ Status AudioFlingerServerAdapter::getMasterBalance(float* _aidl_return) {
		}

		Status AudioFlingerServerAdapter::setStreamVolume(AudioStreamType stream, float value,
		int32_t output) {
		bool muted, int32_t output) {
		audio_stream_type_t streamLegacy = VALUE_OR_RETURN_BINDER(
		aidl2legacy_AudioStreamType_audio_stream_type_t(stream));
		audio_io_handle_t outputLegacy = VALUE_OR_RETURN_BINDER(
		aidl2legacy_int32_t_audio_io_handle_t(output));
		return Status::fromStatusT(mDelegate->setStreamVolume(streamLegacy, value, outputLegacy));
		return Status::fromStatusT(
		mDelegate->setStreamVolume(streamLegacy, value, muted, outputLegacy));
		}

		Status AudioFlingerServerAdapter::setStreamMute(AudioStreamType stream, bool muted) {
		@@ -1022,13 +1026,14 @@ Status AudioFlingerServerAdapter::setStreamMute(AudioStreamType stream, bool mut
		}

		Status AudioFlingerServerAdapter::setPortsVolume(
		const std::vector<int32_t>& portIds, float volume, int32_t output) {
		const std::vector<int32_t>& portIds, float volume, bool muted, int32_t output) {
		std::vector<audio_port_handle_t> portIdsLegacy = VALUE_OR_RETURN_BINDER(
		convertContainer<std::vector<audio_port_handle_t>>(
		portIds, aidl2legacy_int32_t_audio_port_handle_t));
		audio_io_handle_t outputLegacy = VALUE_OR_RETURN_BINDER(
		aidl2legacy_int32_t_audio_io_handle_t(output));
		return Status::fromStatusT(mDelegate->setPortsVolume(portIdsLegacy, volume, outputLegacy));
		return Status::fromStatusT(
		mDelegate->setPortsVolume(portIdsLegacy, volume, muted, outputLegacy));
		}

		Status AudioFlingerServerAdapter::setMode(AudioMode mode) {