Snap for 5626642 from d87fe8d7f56798d0ac806e4be9a56696c6ce8b17 to qt-c2f2-release (576f6094) · Commits · e / os / android_frameworks_native-old

cmds/atrace/atrace.cpp

+1 −0

Original line number	Original line	Diff line number	Diff line
	@@ -890,6 +890,7 @@ static void cleanUpUserspaceTracing()
	setTagsProperty(0);		setTagsProperty(0);
	clearAppProperties();		clearAppProperties();
	pokeBinderServices();		pokeBinderServices();
			pokeHalServices();

	if (g_tracePdx) {		if (g_tracePdx) {
	ServiceUtility::PokeServices();		ServiceUtility::PokeServices();

services/sensorservice/SensorDevice.cpp

+35 −26

Original line number	Original line	Diff line number	Diff line
	@@ -45,7 +45,9 @@ namespace android {

	ANDROID_SINGLETON_STATIC_INSTANCE(SensorDevice)		ANDROID_SINGLETON_STATIC_INSTANCE(SensorDevice)

	static status_t StatusFromResult(Result result) {		namespace {

			status_t statusFromResult(Result result) {
	switch (result) {		switch (result) {
	case Result::OK:		case Result::OK:
	return OK;		return OK;
	@@ -71,6 +73,8 @@ enum EventQueueFlagBitsInternal : uint32_t {
	INTERNAL_WAKE = 1 << 16,		INTERNAL_WAKE = 1 << 16,
	};		};

			} // anonymous namespace

	void SensorsHalDeathReceivier::serviceDied(		void SensorsHalDeathReceivier::serviceDied(
	uint64_t /* cookie */,		uint64_t /* cookie */,
	const wp<::android::hidl::base::V1_0::IBase>& /* service */) {		const wp<::android::hidl::base::V1_0::IBase>& /* service */) {
	@@ -105,7 +109,7 @@ SensorDevice::SensorDevice()
	initializeSensorList();		initializeSensorList();

	mIsDirectReportSupported =		mIsDirectReportSupported =
	(checkReturn(mSensors->unregisterDirectChannel(-1)) != Result::INVALID_OPERATION);		(checkReturnAndGetStatus(mSensors->unregisterDirectChannel(-1)) != INVALID_OPERATION);
	}		}

	void SensorDevice::initializeSensorList() {		void SensorDevice::initializeSensorList() {
	@@ -122,7 +126,7 @@ void SensorDevice::initializeSensorList() {
	convertToSensor(list[i], &sensor);		convertToSensor(list[i], &sensor);
	// Sanity check and clamp power if it is 0 (or close)		// Sanity check and clamp power if it is 0 (or close)
	if (sensor.power < minPowerMa) {		if (sensor.power < minPowerMa) {
	ALOGE("Reported power %f not deemed sane, clamping to %f",		ALOGI("Reported power %f not deemed sane, clamping to %f",
	sensor.power, minPowerMa);		sensor.power, minPowerMa);
	sensor.power = minPowerMa;		sensor.power = minPowerMa;
	}		}
	@@ -217,10 +221,10 @@ SensorDevice::HalConnectionStatus SensorDevice::connectHidlServiceV2_0() {
	mWakeLockQueue != nullptr && mEventQueueFlag != nullptr &&		mWakeLockQueue != nullptr && mEventQueueFlag != nullptr &&
	mWakeLockQueueFlag != nullptr);		mWakeLockQueueFlag != nullptr);

	status_t status = StatusFromResult(checkReturn(mSensors->initialize(		status_t status = checkReturnAndGetStatus(mSensors->initialize(
	*mEventQueue->getDesc(),		*mEventQueue->getDesc(),
	*mWakeLockQueue->getDesc(),		*mWakeLockQueue->getDesc(),
	new SensorsCallback())));		new SensorsCallback()));

	if (status != NO_ERROR) {		if (status != NO_ERROR) {
	connectionStatus = HalConnectionStatus::FAILED_TO_CONNECT;		connectionStatus = HalConnectionStatus::FAILED_TO_CONNECT;
	@@ -270,6 +274,8 @@ bool SensorDevice::sensorHandlesChanged(const Vector<sensor_t>& oldSensorList,
	bool didChange = false;		bool didChange = false;

	if (oldSensorList.size() != newSensorList.size()) {		if (oldSensorList.size() != newSensorList.size()) {
			ALOGI("Sensor list size changed from %zu to %zu", oldSensorList.size(),
			newSensorList.size());
	didChange = true;		didChange = true;
	}		}

	@@ -281,6 +287,7 @@ bool SensorDevice::sensorHandlesChanged(const Vector<sensor_t>& oldSensorList,
	if (prevSensor.handle == newSensor.handle) {		if (prevSensor.handle == newSensor.handle) {
	found = true;		found = true;
	if (!sensorIsEquivalent(prevSensor, newSensor)) {		if (!sensorIsEquivalent(prevSensor, newSensor)) {
			ALOGI("Sensor %s not equivalent to previous version", newSensor.name);
	didChange = true;		didChange = true;
	}		}
	}		}
	@@ -289,6 +296,7 @@ bool SensorDevice::sensorHandlesChanged(const Vector<sensor_t>& oldSensorList,
	if (!found) {		if (!found) {
	// Could not find the new sensor in the old list of sensors, the lists must		// Could not find the new sensor in the old list of sensors, the lists must
	// have changed.		// have changed.
			ALOGI("Sensor %s (handle %d) did not exist before", newSensor.name, newSensor.handle);
	didChange = true;		didChange = true;
	}		}
	}		}
	@@ -423,7 +431,7 @@ ssize_t SensorDevice::pollHal(sensors_event_t* buffer, size_t count) {
	convertToSensorEvents(events, dynamicSensorsAdded, buffer);		convertToSensorEvents(events, dynamicSensorsAdded, buffer);
	err = (ssize_t)events.size();		err = (ssize_t)events.size();
	} else {		} else {
	err = StatusFromResult(result);		err = statusFromResult(result);
	}		}
	});		});

	@@ -621,7 +629,7 @@ status_t SensorDevice::activateLocked(void* ident, int handle, int enabled) {
	if (actuateHardware) {		if (actuateHardware) {
	ALOGD_IF(DEBUG_CONNECTIONS, "\t>>> actuating h/w activate handle=%d enabled=%d", handle,		ALOGD_IF(DEBUG_CONNECTIONS, "\t>>> actuating h/w activate handle=%d enabled=%d", handle,
	enabled);		enabled);
	err = StatusFromResult(checkReturn(mSensors->activate(handle, enabled)));		err = checkReturnAndGetStatus(mSensors->activate(handle, enabled));
	ALOGE_IF(err, "Error %s sensor %d (%s)", enabled ? "activating" : "disabling", handle,		ALOGE_IF(err, "Error %s sensor %d (%s)", enabled ? "activating" : "disabling", handle,
	strerror(-err));		strerror(-err));

	@@ -694,9 +702,8 @@ status_t SensorDevice::batchLocked(void* ident, int handle, int flags, int64_t s
	if (prevBestBatchParams != info.bestBatchParams) {		if (prevBestBatchParams != info.bestBatchParams) {
	ALOGD_IF(DEBUG_CONNECTIONS, "\t>>> actuating h/w BATCH 0x%08x %" PRId64 " %" PRId64, handle,		ALOGD_IF(DEBUG_CONNECTIONS, "\t>>> actuating h/w BATCH 0x%08x %" PRId64 " %" PRId64, handle,
	info.bestBatchParams.mTSample, info.bestBatchParams.mTBatch);		info.bestBatchParams.mTSample, info.bestBatchParams.mTBatch);
	err = StatusFromResult(		err = checkReturnAndGetStatus(mSensors->batch(
	checkReturn(mSensors->batch(		handle, info.bestBatchParams.mTSample, info.bestBatchParams.mTBatch));
	handle, info.bestBatchParams.mTSample, info.bestBatchParams.mTBatch)));
	if (err != NO_ERROR) {		if (err != NO_ERROR) {
	ALOGE("sensor batch failed %p 0x%08x %" PRId64 " %" PRId64 " err=%s",		ALOGE("sensor batch failed %p 0x%08x %" PRId64 " %" PRId64 " err=%s",
	mSensors.get(), handle, info.bestBatchParams.mTSample,		mSensors.get(), handle, info.bestBatchParams.mTSample,
	@@ -720,7 +727,7 @@ status_t SensorDevice::flush(void* ident, int handle) {
	if (mSensors == nullptr) return NO_INIT;		if (mSensors == nullptr) return NO_INIT;
	if (isClientDisabled(ident)) return INVALID_OPERATION;		if (isClientDisabled(ident)) return INVALID_OPERATION;
	ALOGD_IF(DEBUG_CONNECTIONS, "\t>>> actuating h/w flush %d", handle);		ALOGD_IF(DEBUG_CONNECTIONS, "\t>>> actuating h/w flush %d", handle);
	return StatusFromResult(checkReturn(mSensors->flush(handle)));		return checkReturnAndGetStatus(mSensors->flush(handle));
	}		}

	bool SensorDevice::isClientDisabled(void* ident) {		bool SensorDevice::isClientDisabled(void* ident) {
	@@ -753,16 +760,14 @@ void SensorDevice::enableAllSensors() {
	const int sensor_handle = mActivationCount.keyAt(i);		const int sensor_handle = mActivationCount.keyAt(i);
	ALOGD_IF(DEBUG_CONNECTIONS, "\t>> reenable actuating h/w sensor enable handle=%d ",		ALOGD_IF(DEBUG_CONNECTIONS, "\t>> reenable actuating h/w sensor enable handle=%d ",
	sensor_handle);		sensor_handle);
	status_t err = StatusFromResult(		status_t err = checkReturnAndGetStatus(mSensors->batch(
	checkReturn(mSensors->batch(
	sensor_handle,		sensor_handle,
	info.bestBatchParams.mTSample,		info.bestBatchParams.mTSample,
	info.bestBatchParams.mTBatch)));		info.bestBatchParams.mTBatch));
	ALOGE_IF(err, "Error calling batch on sensor %d (%s)", sensor_handle, strerror(-err));		ALOGE_IF(err, "Error calling batch on sensor %d (%s)", sensor_handle, strerror(-err));

	if (err == NO_ERROR) {		if (err == NO_ERROR) {
	err = StatusFromResult(		err = checkReturnAndGetStatus(mSensors->activate(sensor_handle, 1 /* enabled */));
	checkReturn(mSensors->activate(sensor_handle, 1 /* enabled */)));
	ALOGE_IF(err, "Error activating sensor %d (%s)", sensor_handle, strerror(-err));		ALOGE_IF(err, "Error activating sensor %d (%s)", sensor_handle, strerror(-err));
	}		}

	@@ -810,14 +815,13 @@ status_t SensorDevice::injectSensorData(
	Event ev;		Event ev;
	convertFromSensorEvent(*injected_sensor_event, &ev);		convertFromSensorEvent(*injected_sensor_event, &ev);

	return StatusFromResult(checkReturn(mSensors->injectSensorData(ev)));		return checkReturnAndGetStatus(mSensors->injectSensorData(ev));
	}		}

	status_t SensorDevice::setMode(uint32_t mode) {		status_t SensorDevice::setMode(uint32_t mode) {
	if (mSensors == nullptr) return NO_INIT;		if (mSensors == nullptr) return NO_INIT;
	return StatusFromResult(		return checkReturnAndGetStatus(mSensors->setOperationMode(
	checkReturn(mSensors->setOperationMode(		static_cast<hardware::sensors::V1_0::OperationMode>(mode)));
	static_cast<hardware::sensors::V1_0::OperationMode>(mode))));
	}		}

	int32_t SensorDevice::registerDirectChannel(const sensors_direct_mem_t* memory) {		int32_t SensorDevice::registerDirectChannel(const sensors_direct_mem_t* memory) {
	@@ -855,7 +859,7 @@ int32_t SensorDevice::registerDirectChannel(const sensors_direct_mem_t* memory)
	if (result == Result::OK) {		if (result == Result::OK) {
	ret = channelHandle;		ret = channelHandle;
	} else {		} else {
	ret = StatusFromResult(result);		ret = statusFromResult(result);
	}		}
	}));		}));
	return ret;		return ret;
	@@ -894,12 +898,12 @@ int32_t SensorDevice::configureDirectChannel(int32_t sensorHandle,
	checkReturn(mSensors->configDirectReport(sensorHandle, channelHandle, rate,		checkReturn(mSensors->configDirectReport(sensorHandle, channelHandle, rate,
	[&ret, rate] (auto result, auto token) {		[&ret, rate] (auto result, auto token) {
	if (rate == RateLevel::STOP) {		if (rate == RateLevel::STOP) {
	ret = StatusFromResult(result);		ret = statusFromResult(result);
	} else {		} else {
	if (result == Result::OK) {		if (result == Result::OK) {
	ret = token;		ret = token;
	} else {		} else {
	ret = StatusFromResult(result);		ret = statusFromResult(result);
	}		}
	}		}
	}));		}));
	@@ -1008,7 +1012,7 @@ void SensorDevice::convertToSensorEvents(
	}		}

	void SensorDevice::handleHidlDeath(const std::string & detail) {		void SensorDevice::handleHidlDeath(const std::string & detail) {
	if (!SensorDevice::getInstance().mSensors->supportsMessageQueues()) {		if (!mSensors->supportsMessageQueues()) {
	// restart is the only option at present.		// restart is the only option at present.
	LOG_ALWAYS_FATAL("Abort due to ISensors hidl service failure, detail: %s.", detail.c_str());		LOG_ALWAYS_FATAL("Abort due to ISensors hidl service failure, detail: %s.", detail.c_str());
	} else {		} else {
	@@ -1016,5 +1020,10 @@ void SensorDevice::handleHidlDeath(const std::string & detail) {
	}		}
	}		}

			status_t SensorDevice::checkReturnAndGetStatus(const Return<Result>& ret) {
			checkReturn(ret);
			return (!ret.isOk()) ? DEAD_OBJECT : statusFromResult(ret);
			}

	// ---------------------------------------------------------------------------		// ---------------------------------------------------------------------------
	}; // namespace android		}; // namespace android

services/sensorservice/SensorDevice.h

+3 −3

Original line number	Original line	Diff line number	Diff line
	@@ -211,14 +211,14 @@ private:
	status_t batchLocked(void* ident, int handle, int flags, int64_t samplingPeriodNs,		status_t batchLocked(void* ident, int handle, int flags, int64_t samplingPeriodNs,
	int64_t maxBatchReportLatencyNs);		int64_t maxBatchReportLatencyNs);

	static void handleHidlDeath(const std::string &detail);		void handleHidlDeath(const std::string &detail);
	template<typename T>		template<typename T>
	static Return<T> checkReturn(Return<T> &&ret) {		void checkReturn(const Return<T>& ret) {
	if (!ret.isOk()) {		if (!ret.isOk()) {
	handleHidlDeath(ret.description());		handleHidlDeath(ret.description());
	}		}
	return std::move(ret);
	}		}
			status_t checkReturnAndGetStatus(const Return<Result>& ret);
	//TODO(b/67425500): remove waiter after bug is resolved.		//TODO(b/67425500): remove waiter after bug is resolved.
	sp<SensorDeviceUtils::HidlServiceRegistrationWaiter> mRestartWaiter;		sp<SensorDeviceUtils::HidlServiceRegistrationWaiter> mRestartWaiter;

services/surfaceflinger/RegionSamplingThread.cpp

+52 −9

Original line number	Original line	Diff line number	Diff line
	@@ -26,6 +26,8 @@
	#include <utils/Trace.h>		#include <utils/Trace.h>
	#include <string>		#include <string>

			#include <compositionengine/Display.h>
			#include <compositionengine/impl/OutputCompositionState.h>
	#include "DisplayDevice.h"		#include "DisplayDevice.h"
	#include "Layer.h"		#include "Layer.h"
	#include "SurfaceFlinger.h"		#include "SurfaceFlinger.h"
	@@ -264,7 +266,22 @@ float getLuma(float r, float g, float b) {
	}		}
	} // anonymous namespace		} // anonymous namespace

	float sampleArea(const uint32_t* data, int32_t stride, const Rect& area) {		float sampleArea(const uint32_t* data, int32_t width, int32_t height, int32_t stride,
			uint32_t orientation, const Rect& sample_area) {
			if (!sample_area.isValid() \|\| (sample_area.getWidth() > width) \|\|
			(sample_area.getHeight() > height)) {
			ALOGE("invalid sampling region requested");
			return 0.0f;
			}

			// (b/133849373) ROT_90 screencap images produced upside down
			auto area = sample_area;
			if (orientation & ui::Transform::ROT_90) {
			area.top = height - area.top;
			area.bottom = height - area.bottom;
			std::swap(area.top, area.bottom);
			}

	std::array<int32_t, 256> brightnessBuckets = {};		std::array<int32_t, 256> brightnessBuckets = {};
	const int32_t majoritySampleNum = area.getWidth() * area.getHeight() / 2;		const int32_t majoritySampleNum = area.getWidth() * area.getHeight() / 2;

	@@ -293,18 +310,21 @@ float sampleArea(const uint32_t* data, int32_t stride, const Rect& area) {

	std::vector<float> RegionSamplingThread::sampleBuffer(		std::vector<float> RegionSamplingThread::sampleBuffer(
	const sp<GraphicBuffer>& buffer, const Point& leftTop,		const sp<GraphicBuffer>& buffer, const Point& leftTop,
	const std::vector<RegionSamplingThread::Descriptor>& descriptors) {		const std::vector<RegionSamplingThread::Descriptor>& descriptors, uint32_t orientation) {
	void* data_raw = nullptr;		void* data_raw = nullptr;
	buffer->lock(GRALLOC_USAGE_SW_READ_OFTEN, &data_raw);		buffer->lock(GRALLOC_USAGE_SW_READ_OFTEN, &data_raw);
	std::shared_ptr<uint32_t> data(reinterpret_cast<uint32_t*>(data_raw),		std::shared_ptr<uint32_t> data(reinterpret_cast<uint32_t*>(data_raw),
	[&buffer](auto) { buffer->unlock(); });		[&buffer](auto) { buffer->unlock(); });
	if (!data) return {};		if (!data) return {};

			const int32_t width = buffer->getWidth();
			const int32_t height = buffer->getHeight();
	const int32_t stride = buffer->getStride();		const int32_t stride = buffer->getStride();
	std::vector<float> lumas(descriptors.size());		std::vector<float> lumas(descriptors.size());
	std::transform(descriptors.begin(), descriptors.end(), lumas.begin(),		std::transform(descriptors.begin(), descriptors.end(), lumas.begin(),
	[&](auto const& descriptor) {		[&](auto const& descriptor) {
	return sampleArea(data.get(), stride, descriptor.area - leftTop);		return sampleArea(data.get(), width, height, stride, orientation,
			descriptor.area - leftTop);
	});		});
	return lumas;		return lumas;
	}		}
	@@ -317,6 +337,11 @@ void RegionSamplingThread::captureSample() {
	return;		return;
	}		}

			const auto device = mFlinger.getDefaultDisplayDevice();
			const auto display = device->getCompositionDisplay();
			const auto state = display->getState();
			const auto orientation = static_cast<ui::Transform::orientation_flags>(state.orientation);

	std::vector<RegionSamplingThread::Descriptor> descriptors;		std::vector<RegionSamplingThread::Descriptor> descriptors;
	Region sampleRegion;		Region sampleRegion;
	for (const auto& [listener, descriptor] : mDescriptors) {		for (const auto& [listener, descriptor] : mDescriptors) {
	@@ -326,10 +351,28 @@ void RegionSamplingThread::captureSample() {

	const Rect sampledArea = sampleRegion.bounds();		const Rect sampledArea = sampleRegion.bounds();

	sp<const DisplayDevice> device = mFlinger.getDefaultDisplayDevice();		auto dx = 0;
	DisplayRenderArea renderArea(device, sampledArea, sampledArea.getWidth(),		auto dy = 0;
	sampledArea.getHeight(), ui::Dataspace::V0_SRGB,		switch (orientation) {
	ui::Transform::ROT_0);		case ui::Transform::ROT_90:
			dx = device->getWidth();
			break;
			case ui::Transform::ROT_180:
			dx = device->getWidth();
			dy = device->getHeight();
			break;
			case ui::Transform::ROT_270:
			dy = device->getHeight();
			break;
			default:
			break;
			}

			ui::Transform t(orientation);
			auto screencapRegion = t.transform(sampleRegion);
			screencapRegion = screencapRegion.translate(dx, dy);
			DisplayRenderArea renderArea(device, screencapRegion.bounds(), sampledArea.getWidth(),
			sampledArea.getHeight(), ui::Dataspace::V0_SRGB, orientation);

	std::unordered_set<sp<IRegionSamplingListener>, SpHash<IRegionSamplingListener>> listeners;		std::unordered_set<sp<IRegionSamplingListener>, SpHash<IRegionSamplingListener>> listeners;

	@@ -395,8 +438,8 @@ void RegionSamplingThread::captureSample() {
	}		}

	ALOGV("Sampling %zu descriptors", activeDescriptors.size());		ALOGV("Sampling %zu descriptors", activeDescriptors.size());
	std::vector<float> lumas = sampleBuffer(buffer, sampledArea.leftTop(), activeDescriptors);		std::vector<float> lumas =
			sampleBuffer(buffer, sampledArea.leftTop(), activeDescriptors, orientation);
	if (lumas.size() != activeDescriptors.size()) {		if (lumas.size() != activeDescriptors.size()) {
	ALOGW("collected %zu median luma values for %zu descriptors", lumas.size(),		ALOGW("collected %zu median luma values for %zu descriptors", lumas.size(),
	activeDescriptors.size());		activeDescriptors.size());

services/surfaceflinger/RegionSamplingThread.h

+3 −2

Original line number	Original line	Diff line number	Diff line
	@@ -37,7 +37,8 @@ class Scheduler;
	class SurfaceFlinger;		class SurfaceFlinger;
	struct SamplingOffsetCallback;		struct SamplingOffsetCallback;

	float sampleArea(const uint32_t* data, int32_t stride, const Rect& area);		float sampleArea(const uint32_t* data, int32_t width, int32_t height, int32_t stride,
			uint32_t orientation, const Rect& area);

	class RegionSamplingThread : public IBinder::DeathRecipient {		class RegionSamplingThread : public IBinder::DeathRecipient {
	public:		public:
	@@ -94,7 +95,7 @@ private:
	};		};
	std::vector<float> sampleBuffer(		std::vector<float> sampleBuffer(
	const sp<GraphicBuffer>& buffer, const Point& leftTop,		const sp<GraphicBuffer>& buffer, const Point& leftTop,
	const std::vector<RegionSamplingThread::Descriptor>& descriptors);		const std::vector<RegionSamplingThread::Descriptor>& descriptors, uint32_t orientation);

	void doSample();		void doSample();
	void binderDied(const wp<IBinder>& who) override;		void binderDied(const wp<IBinder>& who) override;