Merge "Migrate display related methods to AIDL part 2" into tm-dev am: f0e58ecc7e (0ddc37f6) · Commits · e / os / platform_frameworks_native

libs/gui/ISurfaceComposer.cpp

+0 −366

Original line number	Diff line number	Diff line
		@@ -226,14 +226,6 @@ public:
		return result;
		}

		void setPowerMode(const sp<IBinder>& display, int mode) override {
		Parcel data, reply;
		data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
		data.writeStrongBinder(display);
		data.writeInt32(mode);
		remote()->transact(BnSurfaceComposer::SET_POWER_MODE, data, &reply);
		}

		status_t getDisplayState(const sp<IBinder>& display, ui::DisplayState* state) override {
		Parcel data, reply;
		data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
		@@ -333,29 +325,6 @@ public:
		return static_cast<status_t>(reply.readInt32());
		}

		// TODO(b/213909104) : Add unit tests to verify surface flinger boot time APIs
		status_t getBootDisplayModeSupport(bool* outSupport) const override {
		Parcel data, reply;
		status_t error = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
		if (error != NO_ERROR) {
		ALOGE("getBootDisplayModeSupport: failed to write interface token: %d", error);
		return error;
		}
		error = remote()->transact(BnSurfaceComposer::GET_BOOT_DISPLAY_MODE_SUPPORT, data, &reply);
		if (error != NO_ERROR) {
		ALOGE("getBootDisplayModeSupport: failed to transact: %d", error);
		return error;
		}
		bool support;
		error = reply.readBool(&support);
		if (error != NO_ERROR) {
		ALOGE("getBootDisplayModeSupport: failed to read support: %d", error);
		return error;
		}
		*outSupport = support;
		return NO_ERROR;
		}

		status_t setBootDisplayMode(const sp<IBinder>& display,
		ui::DisplayModeId displayModeId) override {
		Parcel data, reply;
		@@ -381,73 +350,6 @@ public:
		return result;
		}

		status_t clearBootDisplayMode(const sp<IBinder>& display) override {
		Parcel data, reply;
		status_t result = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
		if (result != NO_ERROR) {
		ALOGE("clearBootDisplayMode failed to writeInterfaceToken: %d", result);
		return result;
		}
		result = data.writeStrongBinder(display);
		if (result != NO_ERROR) {
		ALOGE("clearBootDisplayMode failed to writeStrongBinder: %d", result);
		return result;
		}
		result = remote()->transact(BnSurfaceComposer::CLEAR_BOOT_DISPLAY_MODE, data, &reply);
		if (result != NO_ERROR) {
		ALOGE("clearBootDisplayMode failed to transact: %d", result);
		}
		return result;
		}

		void setAutoLowLatencyMode(const sp<IBinder>& display, bool on) override {
		Parcel data, reply;
		status_t result = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
		if (result != NO_ERROR) {
		ALOGE("setAutoLowLatencyMode failed to writeInterfaceToken: %d", result);
		return;
		}

		result = data.writeStrongBinder(display);
		if (result != NO_ERROR) {
		ALOGE("setAutoLowLatencyMode failed to writeStrongBinder: %d", result);
		return;
		}
		result = data.writeBool(on);
		if (result != NO_ERROR) {
		ALOGE("setAutoLowLatencyMode failed to writeBool: %d", result);
		return;
		}
		result = remote()->transact(BnSurfaceComposer::SET_AUTO_LOW_LATENCY_MODE, data, &reply);
		if (result != NO_ERROR) {
		ALOGE("setAutoLowLatencyMode failed to transact: %d", result);
		return;
		}
		}

		void setGameContentType(const sp<IBinder>& display, bool on) override {
		Parcel data, reply;
		status_t result = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
		if (result != NO_ERROR) {
		ALOGE("setGameContentType failed to writeInterfaceToken: %d", result);
		return;
		}
		result = data.writeStrongBinder(display);
		if (result != NO_ERROR) {
		ALOGE("setGameContentType failed to writeStrongBinder: %d", result);
		return;
		}
		result = data.writeBool(on);
		if (result != NO_ERROR) {
		ALOGE("setGameContentType failed to writeBool: %d", result);
		return;
		}
		result = remote()->transact(BnSurfaceComposer::SET_GAME_CONTENT_TYPE, data, &reply);
		if (result != NO_ERROR) {
		ALOGE("setGameContentType failed to transact: %d", result);
		}
		}

		status_t clearAnimationFrameStats() override {
		Parcel data, reply;
		status_t result = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
		@@ -722,26 +624,6 @@ public:
		return error;
		}

		status_t isWideColorDisplay(const sp<IBinder>& token,
		bool* outIsWideColorDisplay) const override {
		Parcel data, reply;
		status_t error = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
		if (error != NO_ERROR) {
		return error;
		}
		error = data.writeStrongBinder(token);
		if (error != NO_ERROR) {
		return error;
		}

		error = remote()->transact(BnSurfaceComposer::IS_WIDE_COLOR_DISPLAY, data, &reply);
		if (error != NO_ERROR) {
		return error;
		}
		error = reply.readBool(outIsWideColorDisplay);
		return error;
		}

		status_t addRegionSamplingListener(const Rect& samplingArea, const sp<IBinder>& stopLayerHandle,
		const sp<IRegionSamplingListener>& listener) override {
		Parcel data, reply;
		@@ -974,109 +856,6 @@ public:
		return reply.readInt32();
		}

		status_t getDisplayBrightnessSupport(const sp<IBinder>& displayToken,
		bool* outSupport) const override {
		Parcel data, reply;
		status_t error = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
		if (error != NO_ERROR) {
		ALOGE("getDisplayBrightnessSupport: failed to write interface token: %d", error);
		return error;
		}
		error = data.writeStrongBinder(displayToken);
		if (error != NO_ERROR) {
		ALOGE("getDisplayBrightnessSupport: failed to write display token: %d", error);
		return error;
		}
		error = remote()->transact(BnSurfaceComposer::GET_DISPLAY_BRIGHTNESS_SUPPORT, data, &reply);
		if (error != NO_ERROR) {
		ALOGE("getDisplayBrightnessSupport: failed to transact: %d", error);
		return error;
		}
		bool support;
		error = reply.readBool(&support);
		if (error != NO_ERROR) {
		ALOGE("getDisplayBrightnessSupport: failed to read support: %d", error);
		return error;
		}
		*outSupport = support;
		return NO_ERROR;
		}

		status_t setDisplayBrightness(const sp<IBinder>& displayToken,
		const gui::DisplayBrightness& brightness) override {
		Parcel data, reply;
		status_t error = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
		if (error != NO_ERROR) {
		ALOGE("setDisplayBrightness: failed to write interface token: %d", error);
		return error;
		}
		error = data.writeStrongBinder(displayToken);
		if (error != NO_ERROR) {
		ALOGE("setDisplayBrightness: failed to write display token: %d", error);
		return error;
		}
		error = data.writeParcelable(brightness);
		if (error != NO_ERROR) {
		ALOGE("setDisplayBrightness: failed to write brightness: %d", error);
		return error;
		}
		error = remote()->transact(BnSurfaceComposer::SET_DISPLAY_BRIGHTNESS, data, &reply);
		if (error != NO_ERROR) {
		ALOGE("setDisplayBrightness: failed to transact: %d", error);
		return error;
		}
		return NO_ERROR;
		}

		status_t addHdrLayerInfoListener(const sp<IBinder>& displayToken,
		const sp<gui::IHdrLayerInfoListener>& listener) override {
		Parcel data, reply;
		SAFE_PARCEL(data.writeInterfaceToken, ISurfaceComposer::getInterfaceDescriptor());
		SAFE_PARCEL(data.writeStrongBinder, displayToken);
		SAFE_PARCEL(data.writeStrongBinder, IInterface::asBinder(listener));
		const status_t error =
		remote()->transact(BnSurfaceComposer::ADD_HDR_LAYER_INFO_LISTENER, data, &reply);
		if (error != OK) {
		ALOGE("addHdrLayerInfoListener: Failed to transact; error = %d", error);
		}
		return error;
		}

		status_t removeHdrLayerInfoListener(const sp<IBinder>& displayToken,
		const sp<gui::IHdrLayerInfoListener>& listener) override {
		Parcel data, reply;
		SAFE_PARCEL(data.writeInterfaceToken, ISurfaceComposer::getInterfaceDescriptor());
		SAFE_PARCEL(data.writeStrongBinder, displayToken);
		SAFE_PARCEL(data.writeStrongBinder, IInterface::asBinder(listener));
		const status_t error =
		remote()->transact(BnSurfaceComposer::REMOVE_HDR_LAYER_INFO_LISTENER, data, &reply);
		if (error != OK) {
		ALOGE("removeHdrLayerInfoListener: Failed to transact; error = %d", error);
		}
		return error;
		}

		status_t notifyPowerBoost(int32_t boostId) override {
		Parcel data, reply;
		status_t error = data.writeInterfaceToken(ISurfaceComposer::getInterfaceDescriptor());
		if (error != NO_ERROR) {
		ALOGE("notifyPowerBoost: failed to write interface token: %d", error);
		return error;
		}
		error = data.writeInt32(boostId);
		if (error != NO_ERROR) {
		ALOGE("notifyPowerBoost: failed to write boostId: %d", error);
		return error;
		}
		error = remote()->transact(BnSurfaceComposer::NOTIFY_POWER_BOOST, data, &reply,
		IBinder::FLAG_ONEWAY);
		if (error != NO_ERROR) {
		ALOGE("notifyPowerBoost: failed to transact: %d", error);
		return error;
		}
		return NO_ERROR;
		}

		status_t setGlobalShadowSettings(const half4& ambientColor, const half4& spotColor,
		float lightPosY, float lightPosZ, float lightRadius) override {
		Parcel data, reply;
		@@ -1475,15 +1254,6 @@ status_t BnSurfaceComposer::onTransact(
		result = reply->writeInt32(result);
		return result;
		}
		case GET_BOOT_DISPLAY_MODE_SUPPORT: {
		CHECK_INTERFACE(ISurfaceComposer, data, reply);
		bool support = false;
		status_t result = getBootDisplayModeSupport(&support);
		if (result == NO_ERROR) {
		reply->writeBool(support);
		}
		return result;
		}
		case SET_BOOT_DISPLAY_MODE: {
		CHECK_INTERFACE(ISurfaceComposer, data, reply);
		sp<IBinder> display = nullptr;
		@@ -1500,50 +1270,6 @@ status_t BnSurfaceComposer::onTransact(
		}
		return setBootDisplayMode(display, displayModeId);
		}
		case CLEAR_BOOT_DISPLAY_MODE: {
		CHECK_INTERFACE(ISurfaceComposer, data, reply);
		sp<IBinder> display = nullptr;
		status_t result = data.readStrongBinder(&display);
		if (result != NO_ERROR) {
		ALOGE("clearBootDisplayMode failed to readStrongBinder: %d", result);
		return result;
		}
		return clearBootDisplayMode(display);
		}
		case SET_AUTO_LOW_LATENCY_MODE: {
		CHECK_INTERFACE(ISurfaceComposer, data, reply);
		sp<IBinder> display = nullptr;
		status_t result = data.readStrongBinder(&display);
		if (result != NO_ERROR) {
		ALOGE("setAutoLowLatencyMode failed to readStrongBinder: %d", result);
		return result;
		}
		bool setAllm = false;
		result = data.readBool(&setAllm);
		if (result != NO_ERROR) {
		ALOGE("setAutoLowLatencyMode failed to readBool: %d", result);
		return result;
		}
		setAutoLowLatencyMode(display, setAllm);
		return result;
		}
		case SET_GAME_CONTENT_TYPE: {
		CHECK_INTERFACE(ISurfaceComposer, data, reply);
		sp<IBinder> display = nullptr;
		status_t result = data.readStrongBinder(&display);
		if (result != NO_ERROR) {
		ALOGE("setGameContentType failed to readStrongBinder: %d", result);
		return result;
		}
		bool setGameContentTypeOn = false;
		result = data.readBool(&setGameContentTypeOn);
		if (result != NO_ERROR) {
		ALOGE("setGameContentType failed to readBool: %d", result);
		return result;
		}
		setGameContentType(display, setGameContentTypeOn);
		return result;
		}
		case CLEAR_ANIMATION_FRAME_STATS: {
		CHECK_INTERFACE(ISurfaceComposer, data, reply);
		status_t result = clearAnimationFrameStats();
		@@ -1558,13 +1284,6 @@ status_t BnSurfaceComposer::onTransact(
		reply->writeInt32(result);
		return NO_ERROR;
		}
		case SET_POWER_MODE: {
		CHECK_INTERFACE(ISurfaceComposer, data, reply);
		sp<IBinder> display = data.readStrongBinder();
		int32_t mode = data.readInt32();
		setPowerMode(display, mode);
		return NO_ERROR;
		}
		case ENABLE_VSYNC_INJECTIONS: {
		CHECK_INTERFACE(ISurfaceComposer, data, reply);
		bool enable = false;
		@@ -1714,20 +1433,6 @@ status_t BnSurfaceComposer::onTransact(
		}
		return error;
		}
		case IS_WIDE_COLOR_DISPLAY: {
		CHECK_INTERFACE(ISurfaceComposer, data, reply);
		sp<IBinder> display = nullptr;
		status_t error = data.readStrongBinder(&display);
		if (error != NO_ERROR) {
		return error;
		}
		bool result;
		error = isWideColorDisplay(display, &result);
		if (error == NO_ERROR) {
		reply->writeBool(result);
		}
		return error;
		}
		case ADD_REGION_SAMPLING_LISTENER: {
		CHECK_INTERFACE(ISurfaceComposer, data, reply);
		Rect samplingArea;
		@@ -1925,77 +1630,6 @@ status_t BnSurfaceComposer::onTransact(
		reply->writeInt32(result);
		return result;
		}
		case GET_DISPLAY_BRIGHTNESS_SUPPORT: {
		CHECK_INTERFACE(ISurfaceComposer, data, reply);
		sp<IBinder> displayToken;
		status_t error = data.readNullableStrongBinder(&displayToken);
		if (error != NO_ERROR) {
		ALOGE("getDisplayBrightnessSupport: failed to read display token: %d", error);
		return error;
		}
		bool support = false;
		error = getDisplayBrightnessSupport(displayToken, &support);
		reply->writeBool(support);
		return error;
		}
		case SET_DISPLAY_BRIGHTNESS: {
		CHECK_INTERFACE(ISurfaceComposer, data, reply);
		sp<IBinder> displayToken;
		status_t error = data.readNullableStrongBinder(&displayToken);
		if (error != NO_ERROR) {
		ALOGE("setDisplayBrightness: failed to read display token: %d", error);
		return error;
		}
		gui::DisplayBrightness brightness;
		error = data.readParcelable(&brightness);
		if (error != NO_ERROR) {
		ALOGE("setDisplayBrightness: failed to read brightness: %d", error);
		return error;
		}
		return setDisplayBrightness(displayToken, brightness);
		}
		case ADD_HDR_LAYER_INFO_LISTENER: {
		CHECK_INTERFACE(ISurfaceComposer, data, reply);
		sp<IBinder> displayToken;
		status_t error = data.readNullableStrongBinder(&displayToken);
		if (error != NO_ERROR) {
		ALOGE("addHdrLayerInfoListener: Failed to read display token");
		return error;
		}
		sp<gui::IHdrLayerInfoListener> listener;
		error = data.readNullableStrongBinder(&listener);
		if (error != NO_ERROR) {
		ALOGE("addHdrLayerInfoListener: Failed to read listener");
		return error;
		}
		return addHdrLayerInfoListener(displayToken, listener);
		}
		case REMOVE_HDR_LAYER_INFO_LISTENER: {
		CHECK_INTERFACE(ISurfaceComposer, data, reply);
		sp<IBinder> displayToken;
		status_t error = data.readNullableStrongBinder(&displayToken);
		if (error != NO_ERROR) {
		ALOGE("removeHdrLayerInfoListener: Failed to read display token");
		return error;
		}
		sp<gui::IHdrLayerInfoListener> listener;
		error = data.readNullableStrongBinder(&listener);
		if (error != NO_ERROR) {
		ALOGE("removeHdrLayerInfoListener: Failed to read listener");
		return error;
		}
		return removeHdrLayerInfoListener(displayToken, listener);
		}
		case NOTIFY_POWER_BOOST: {
		CHECK_INTERFACE(ISurfaceComposer, data, reply);
		int32_t boostId;
		status_t error = data.readInt32(&boostId);
		if (error != NO_ERROR) {
		ALOGE("notifyPowerBoost: failed to read boostId: %d", error);
		return error;
		}
		return notifyPowerBoost(boostId);
		}
		case SET_GLOBAL_SHADOW_SETTINGS: {
		CHECK_INTERFACE(ISurfaceComposer, data, reply);

libs/gui/Surface.cpp

+6 −2

Original line number	Diff line number	Diff line
		@@ -126,6 +126,10 @@ sp<ISurfaceComposer> Surface::composerService() const {
		return ComposerService::getComposerService();
		}

		sp<gui::ISurfaceComposer> Surface::composerServiceAIDL() const {
		return ComposerServiceAIDL::getComposerService();
		}

		nsecs_t Surface::now() const {
		return systemTime();
		}
		@@ -350,8 +354,8 @@ status_t Surface::getWideColorSupport(bool* supported) {
		}

		*supported = false;
		status_t error = composerService()->isWideColorDisplay(display, supported);
		return error;
		binder::Status status = composerServiceAIDL()->isWideColorDisplay(display, supported);
		return status.transactionError();
		}

		status_t Surface::getHdrSupport(bool* supported) {

libs/gui/SurfaceComposerClient.cpp

+31 −14

Original line number	Diff line number	Diff line
		@@ -2191,7 +2191,9 @@ status_t SurfaceComposerClient::setActiveColorMode(const sp<IBinder>& display,
		}

		status_t SurfaceComposerClient::getBootDisplayModeSupport(bool* support) {
		return ComposerService::getComposerService()->getBootDisplayModeSupport(support);
		binder::Status status =
		ComposerServiceAIDL::getComposerService()->getBootDisplayModeSupport(support);
		return status.transactionError();
		}

		status_t SurfaceComposerClient::setBootDisplayMode(const sp<IBinder>& display,
		@@ -2200,7 +2202,9 @@ status_t SurfaceComposerClient::setBootDisplayMode(const sp<IBinder>& display,
		}

		status_t SurfaceComposerClient::clearBootDisplayMode(const sp<IBinder>& display) {
		return ComposerService::getComposerService()->clearBootDisplayMode(display);
		binder::Status status =
		ComposerServiceAIDL::getComposerService()->clearBootDisplayMode(display);
		return status.transactionError();
		}

		status_t SurfaceComposerClient::setOverrideFrameRate(uid_t uid, float frameRate) {
		@@ -2208,16 +2212,16 @@ status_t SurfaceComposerClient::setOverrideFrameRate(uid_t uid, float frameRate)
		}

		void SurfaceComposerClient::setAutoLowLatencyMode(const sp<IBinder>& display, bool on) {
		ComposerService::getComposerService()->setAutoLowLatencyMode(display, on);
		ComposerServiceAIDL::getComposerService()->setAutoLowLatencyMode(display, on);
		}

		void SurfaceComposerClient::setGameContentType(const sp<IBinder>& display, bool on) {
		ComposerService::getComposerService()->setGameContentType(display, on);
		ComposerServiceAIDL::getComposerService()->setGameContentType(display, on);
		}

		void SurfaceComposerClient::setDisplayPowerMode(const sp<IBinder>& token,
		int mode) {
		ComposerService::getComposerService()->setPowerMode(token, mode);
		ComposerServiceAIDL::getComposerService()->setPowerMode(token, mode);
		}

		status_t SurfaceComposerClient::getCompositionPreference(
		@@ -2278,8 +2282,10 @@ status_t SurfaceComposerClient::getDisplayedContentSample(const sp<IBinder>& dis

		status_t SurfaceComposerClient::isWideColorDisplay(const sp<IBinder>& display,
		bool* outIsWideColorDisplay) {
		return ComposerService::getComposerService()->isWideColorDisplay(display,
		binder::Status status =
		ComposerServiceAIDL::getComposerService()->isWideColorDisplay(display,
		outIsWideColorDisplay);
		return status.transactionError();
		}

		status_t SurfaceComposerClient::addRegionSamplingListener(
		@@ -2316,28 +2322,39 @@ status_t SurfaceComposerClient::removeTunnelModeEnabledListener(

		bool SurfaceComposerClient::getDisplayBrightnessSupport(const sp<IBinder>& displayToken) {
		bool support = false;
		ComposerService::getComposerService()->getDisplayBrightnessSupport(displayToken, &support);
		return support;
		binder::Status status =
		ComposerServiceAIDL::getComposerService()->getDisplayBrightnessSupport(displayToken,
		&support);
		return status.isOk() ? support : false;
		}

		status_t SurfaceComposerClient::setDisplayBrightness(const sp<IBinder>& displayToken,
		const gui::DisplayBrightness& brightness) {
		return ComposerService::getComposerService()->setDisplayBrightness(displayToken, brightness);
		binder::Status status =
		ComposerServiceAIDL::getComposerService()->setDisplayBrightness(displayToken,
		brightness);
		return status.transactionError();
		}

		status_t SurfaceComposerClient::addHdrLayerInfoListener(
		const sp<IBinder>& displayToken, const sp<gui::IHdrLayerInfoListener>& listener) {
		return ComposerService::getComposerService()->addHdrLayerInfoListener(displayToken, listener);
		binder::Status status =
		ComposerServiceAIDL::getComposerService()->addHdrLayerInfoListener(displayToken,
		listener);
		return status.transactionError();
		}

		status_t SurfaceComposerClient::removeHdrLayerInfoListener(
		const sp<IBinder>& displayToken, const sp<gui::IHdrLayerInfoListener>& listener) {
		return ComposerService::getComposerService()->removeHdrLayerInfoListener(displayToken,
		binder::Status status =
		ComposerServiceAIDL::getComposerService()->removeHdrLayerInfoListener(displayToken,
		listener);
		return status.transactionError();
		}

		status_t SurfaceComposerClient::notifyPowerBoost(int32_t boostId) {
		return ComposerService::getComposerService()->notifyPowerBoost(boostId);
		binder::Status status = ComposerServiceAIDL::getComposerService()->notifyPowerBoost(boostId);
		return status.transactionError();
		}

		status_t SurfaceComposerClient::setGlobalShadowSettings(const half4& ambientColor,

libs/gui/aidl/android/gui/ISurfaceComposer.aidl

+106 −0

File changed.

Preview size limit exceeded, changes collapsed.

libs/gui/include/gui/ISurfaceComposer.h

+13 −120

File changed.

Preview size limit exceeded, changes collapsed.