Snap for 12296955 from dd60a5d17e9d3c447a90f5f9642063ce4df9e705 to 24Q4-release (097ad655) · Commits · e / os / android_frameworks_av

cmds/screenrecord/screenrecord.cpp

+20 −1

Original line number	Diff line number	Diff line
		@@ -362,13 +362,26 @@ static status_t prepareVirtualDisplay(
		const ui::DisplayState& displayState,
		const sp<IGraphicBufferProducer>& bufferProducer,
		sp<IBinder>* pDisplayHandle, sp<SurfaceControl>* mirrorRoot) {
		static const std::string kDisplayName("ScreenRecorder");
		std::string displayName = gPhysicalDisplayId
		? "ScreenRecorder " + to_string(*gPhysicalDisplayId)
		: "ScreenRecorder";
		static const std::string kDisplayName(displayName);

		sp<IBinder> dpy = SurfaceComposerClient::createVirtualDisplay(kDisplayName, gSecureDisplay);
		SurfaceComposerClient::Transaction t;
		t.setDisplaySurface(dpy, bufferProducer);
		setDisplayProjection(t, dpy, displayState);

		// ensures that random layer stack assigned to virtual display changes
		// between calls - if a list of displays with their layer stacks becomes
		// available, we should use it to ensure a new layer stack is used here
		std::srand(
		std::chrono::duration_cast<std::chrono::milliseconds>(
		std::chrono::system_clock::now().time_since_epoch()
		).count());
		ui::LayerStack layerStack = ui::LayerStack::fromValue(std::rand());
		t.setDisplayLayerStack(dpy, layerStack);

		PhysicalDisplayId displayId;
		status_t err = getPhysicalDisplayId(displayId);
		if (err != NO_ERROR) {
		@@ -1224,6 +1237,8 @@ static void usage() {
		" see \"dumpsys SurfaceFlinger --display-id\" for valid display IDs.\n"
		"--verbose\n"
		" Display interesting information on stdout.\n"
		"--version\n"
		" Show Android screenrecord version.\n"
		"--help\n"
		" Show this message.\n"
		"\n"
		@@ -1255,6 +1270,7 @@ int main(int argc, char* const argv[]) {
		{ "bframes", required_argument, NULL, 'B' },
		{ "display-id", required_argument, NULL, 'd' },
		{ "capture-secure", no_argument, NULL, 'S' },
		{ "version", no_argument, NULL, 'x' },
		{ NULL, 0, NULL, 0 }
		};

		@@ -1377,6 +1393,9 @@ int main(int argc, char* const argv[]) {
		case 'S':
		gSecureDisplay = true;
		break;
		case 'x':
		fprintf(stderr, "%d.%d\n", kVersionMajor, kVersionMinor);
		return 0;
		default:
		if (ic != '?') {
		fprintf(stderr, "getopt_long returned unexpected value 0x%x\n", ic);

cmds/screenrecord/screenrecord.h

+1 −1

Original line number	Diff line number	Diff line
		@@ -18,6 +18,6 @@
		#define SCREENRECORD_SCREENRECORD_H

		#define kVersionMajor 1
		#define kVersionMinor 3
		#define kVersionMinor 4

		#endif /SCREENRECORD_SCREENRECORD_H/

services/audiopolicy/managerdefault/AudioPolicyManager.cpp

+9 −22

Original line number	Diff line number	Diff line
		@@ -123,16 +123,17 @@ status_t AudioPolicyManager::setDeviceConnectionState(audio_devices_t device,
		}
		}

		status_t AudioPolicyManager::broadcastDeviceConnectionState(const sp<DeviceDescriptor> &device,
		void AudioPolicyManager::broadcastDeviceConnectionState(const sp<DeviceDescriptor> &device,
		media::DeviceConnectedState state)
		{
		audio_port_v7 devicePort;
		device->toAudioPort(&devicePort);
		status_t status = mpClientInterface->setDeviceConnectedState(&devicePort, state);
		ALOGE_IF(status != OK, "Error %d while setting connected state %d for device %s", status,
		static_cast<int>(state), device->getDeviceTypeAddr().toString(false).c_str());

		return status;
		if (status_t status = mpClientInterface->setDeviceConnectedState(&devicePort, state);
		status != OK) {
		ALOGE("Error %d while setting connected state %d for device %s",
		status, static_cast<int>(state),
		device->getDeviceTypeAddr().toString(false).c_str());
		}
		}

		status_t AudioPolicyManager::setDeviceConnectionStateInt(
		@@ -213,14 +214,7 @@ status_t AudioPolicyManager::setDeviceConnectionStateInt(const sp<DeviceDescript

		// Before checking outputs, broadcast connect event to allow HAL to retrieve dynamic
		// parameters on newly connected devices (instead of opening the outputs...)
		if (broadcastDeviceConnectionState(
		device, media::DeviceConnectedState::CONNECTED) != NO_ERROR) {
		mAvailableOutputDevices.remove(device);
		mHwModules.cleanUpForDevice(device);
		ALOGE("%s() device %s format %x connection failed", __func__,
		device->toString().c_str(), device->getEncodedFormat());
		return INVALID_OPERATION;
		}
		broadcastDeviceConnectionState(device, media::DeviceConnectedState::CONNECTED);

		if (checkOutputsForDevice(device, state, outputs) != NO_ERROR) {
		mAvailableOutputDevices.remove(device);
		@@ -405,14 +399,7 @@ status_t AudioPolicyManager::setDeviceConnectionStateInt(const sp<DeviceDescript

		// Before checking intputs, broadcast connect event to allow HAL to retrieve dynamic
		// parameters on newly connected devices (instead of opening the inputs...)
		if (broadcastDeviceConnectionState(
		device, media::DeviceConnectedState::CONNECTED) != NO_ERROR) {
		mAvailableInputDevices.remove(device);
		mHwModules.cleanUpForDevice(device);
		ALOGE("%s() device %s format %x connection failed", __func__,
		device->toString().c_str(), device->getEncodedFormat());
		return INVALID_OPERATION;
		}
		broadcastDeviceConnectionState(device, media::DeviceConnectedState::CONNECTED);
		// Propagate device availability to Engine
		setEngineDeviceConnectionState(device, state);

services/audiopolicy/managerdefault/AudioPolicyManager.h

+2 −2

Original line number	Diff line number	Diff line
		@@ -1109,7 +1109,7 @@ private:
		// It can give a chance to HAL implementer to retrieve dynamic capabilities associated
		// to this device for example.
		// TODO avoid opening stream to retrieve capabilities of a profile.
		status_t broadcastDeviceConnectionState(const sp<DeviceDescriptor> &device,
		void broadcastDeviceConnectionState(const sp<DeviceDescriptor> &device,
		media::DeviceConnectedState state);

		// updates device caching and output for streams that can influence the

services/audiopolicy/tests/audiopolicymanager_tests.cpp

+0 −48

Original line number	Diff line number	Diff line
		@@ -2532,29 +2532,8 @@ class AudioPolicyManagerTestClientOpenFails : public AudioPolicyManagerTestClien

		void setSimulateFailure(bool simulateFailure) { mSimulateFailure = simulateFailure; }

		void setSimulateBroadcastDeviceStatus(audio_devices_t device, status_t status) {
		if (status != NO_ERROR) {
		// simulate device connect status
		mSimulateBroadcastDeviceStatus[device] = status;
		} else {
		// remove device connection fixed status
		mSimulateBroadcastDeviceStatus.erase(device);
		}
		}

		status_t setDeviceConnectedState(const struct audio_port_v7* port,
		media::DeviceConnectedState state) override {
		if (mSimulateBroadcastDeviceStatus.find(port->ext.device.type) !=
		mSimulateBroadcastDeviceStatus.end()) {
		// If a simulated status exists, return a status value
		return mSimulateBroadcastDeviceStatus[port->ext.device.type];
		}
		return AudioPolicyManagerTestClient::setDeviceConnectedState(port, state);
		}

		private:
		bool mSimulateFailure = false;
		std::map<audio_devices_t, status_t> mSimulateBroadcastDeviceStatus;
		};

		} // namespace
		@@ -2575,9 +2554,6 @@ class AudioPolicyManagerTestDeviceConnectionFailed :
		void setSimulateOpenFailure(bool simulateFailure) {
		mFullClient->setSimulateFailure(simulateFailure); }

		void setSimulateBroadcastDeviceStatus(audio_devices_t device, status_t status) {
		mFullClient->setSimulateBroadcastDeviceStatus(device, status); }

		static const std::string sBluetoothConfig;

		private:
		@@ -2621,30 +2597,6 @@ TEST_P(AudioPolicyManagerTestDeviceConnectionFailed, SetDeviceConnectedStateHasA
		}
		}

		TEST_P(AudioPolicyManagerTestDeviceConnectionFailed, BroadcastDeviceFailure) {
		const audio_devices_t type = std::get<0>(GetParam());
		const std::string name = std::get<1>(GetParam());
		const std::string address = std::get<2>(GetParam());
		const audio_format_t format = std::get<3>(GetParam());

		// simulate broadcastDeviceConnectionState return failure
		setSimulateBroadcastDeviceStatus(type, INVALID_OPERATION);
		ASSERT_EQ(INVALID_OPERATION, mManager->setDeviceConnectionState(
		type, AUDIO_POLICY_DEVICE_STATE_AVAILABLE,
		address.c_str(), name.c_str(), format));

		// if broadcast is fail, device should not be added to available devices list
		if (audio_is_output_device(type)) {
		auto availableDevices = mManager->getAvailableOutputDevices();
		EXPECT_FALSE(availableDevices.containsDeviceWithType(type));
		} else if (audio_is_input_device(type)) {
		auto availableDevices = mManager->getAvailableInputDevices();
		EXPECT_FALSE(availableDevices.containsDeviceWithType(type));
		}

		setSimulateBroadcastDeviceStatus(type, NO_ERROR);
		}

		INSTANTIATE_TEST_CASE_P(
		DeviceConnectionFailure,
		AudioPolicyManagerTestDeviceConnectionFailed,