services/surfaceflinger/SurfaceInterceptor.cpp - android_frameworks_native - Gitiles

 /*
  * Copyright 2016 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.
  */

 #undef LOG_TAG
 #define LOG_TAG "SurfaceInterceptor"
 #define ATRACE_TAG ATRACE_TAG_GRAPHICS

 #include "Layer.h"
 #include "SurfaceFlinger.h"
 #include "SurfaceInterceptor.h"

 #include <cutils/log.h>

 #include <utils/Trace.h>

 #include <fstream>

 namespace android {

 // ----------------------------------------------------------------------------

 void SurfaceInterceptor::enable(const SortedVector<sp<Layer>>& layers) {
     ATRACE_CALL();
     if (mEnabled) {
         return;
     }
     mEnabled = true;
     saveExistingLayers(layers);
 }

 void SurfaceInterceptor::disable() {
     ATRACE_CALL();
     if (!mEnabled) {
         return;
     }
     std::lock_guard<std::mutex> protoGuard(mTraceMutex);
     mEnabled = false;
     status_t err(writeProtoFileLocked());
     ALOGE_IF(err == PERMISSION_DENIED, "Could not save the proto file! Permission denied");
     ALOGE_IF(err == NOT_ENOUGH_DATA, "Could not save the proto file! There are missing fields");
     mTrace.Clear();
 }

 void SurfaceInterceptor::saveExistingLayers(const SortedVector<sp<Layer>>& layers) {
     ATRACE_CALL();
     std::lock_guard<std::mutex> protoGuard(mTraceMutex);
     for (const auto& layer : layers) {
         saveLayerCreateLocked(layer);
         saveInitialLayerStateLocked(layer);
     }
 }

 void SurfaceInterceptor::saveInitialLayerStateLocked(const sp<const Layer>& layer) {
     ATRACE_CALL();
     if (layer == nullptr) {
         return;
     }
     Increment* increment(addTraceIncrementLocked());
     Transaction* transaction(increment->mutable_transaction());
     transaction->set_synchronous(layer->mTransactionFlags & BnSurfaceComposer::eSynchronous);
     transaction->set_animation(layer->mTransactionFlags & BnSurfaceComposer::eAnimation);

     const int32_t layerId(getLayerId(layer));
     addPositionLocked(transaction, layerId, layer->mCurrentState.active.transform.tx(),
             layer->mCurrentState.active.transform.ty());
     addDepthLocked(transaction, layerId, layer->mCurrentState.z);
     addSizeLocked(transaction, layerId, layer->mCurrentState.active.w,
             layer->mCurrentState.active.h);
     addAlphaLocked(transaction, layerId, layer->mCurrentState.alpha);
     addTransparentRegionLocked(transaction, layerId, layer->mCurrentState.activeTransparentRegion);
     addLayerStackLocked(transaction, layerId, layer->mCurrentState.layerStack);
     addCropLocked(transaction, layerId, layer->mCurrentState.crop);
     if (layer->mCurrentState.handle != NULL) {
         addDeferTransactionLocked(transaction, layerId, layer->mCurrentState.handle,
                 layer->mCurrentState.frameNumber);
     }
     addFinalCropLocked(transaction, layerId, layer->mCurrentState.finalCrop);
     addOverrideScalingModeLocked(transaction, layerId, layer->getEffectiveScalingMode());
     addFlagsLocked(transaction, layerId, layer->mCurrentState.flags);
 }

 status_t SurfaceInterceptor::writeProtoFileLocked() {
     ATRACE_CALL();
     std::ofstream output(mOutputFileName, std::ios::out | std::ios::trunc | std::ios::binary);
     // SerializeToOstream returns false when it's missing required data or when it could not write
     if (!mTrace.IsInitialized()) {
         return NOT_ENOUGH_DATA;
     }
     if (!mTrace.SerializeToOstream(&output)) {
         return PERMISSION_DENIED;
     }
     return NO_ERROR;
 }

 void SurfaceInterceptor::setOutputFileName(const std::string& outputFileName) {
     mOutputFileName = outputFileName;
 }

 const sp<const Layer> SurfaceInterceptor::getLayer(const sp<const IBinder>& handle) {
     const auto layerHandle(static_cast<const Layer::Handle*>(handle.get()));
     const sp<const Layer> layer(layerHandle->owner.promote());
     // layer could be a nullptr at this point
     return layer;
 }

 const std::string SurfaceInterceptor::getLayerName(const sp<const Layer>& layer) {
     return layer->getName().string();
 }

 int32_t SurfaceInterceptor::getLayerId(const sp<const Layer>& layer) {
     return layer->sequence;
 }

 Increment* SurfaceInterceptor::addTraceIncrementLocked() {
     Increment* increment(mTrace.add_increment());
     increment->set_time_stamp(systemTime());
     return increment;
 }

 Change* SurfaceInterceptor::addChangeLocked(Transaction* transaction, int32_t layerId) {
     Change* change(transaction->add_change());
     change->set_id(layerId);
     return change;
 }

 void SurfaceInterceptor::setProtoRectLocked(Rectangle* protoRect, const Rect& rect) {
     protoRect->set_left(rect.left);
     protoRect->set_top(rect.top);
     protoRect->set_right(rect.right);
     protoRect->set_bottom(rect.bottom);
 }

 void SurfaceInterceptor::addPositionLocked(Transaction* transaction, int32_t layerId, float x,
         float y)
 {
     Change* change(addChangeLocked(transaction, layerId));
     PositionChange* posChange(change->mutable_position());
     posChange->set_x(x);
     posChange->set_y(y);
 }

 void SurfaceInterceptor::addDepthLocked(Transaction* transaction, int32_t layerId, uint32_t z) {
     Change* change(addChangeLocked(transaction, layerId));
     LayerChange* depthChange(change->mutable_layer());
     depthChange->set_layer(z);
 }

 void SurfaceInterceptor::addSizeLocked(Transaction* transaction, int32_t layerId, uint32_t w,
         uint32_t h)
 {
     Change* change(addChangeLocked(transaction, layerId));
     SizeChange* sizeChange(change->mutable_size());
     sizeChange->set_w(w);
     sizeChange->set_h(h);
 }

 void SurfaceInterceptor::addAlphaLocked(Transaction* transaction, int32_t layerId, float alpha) {
     Change* change(addChangeLocked(transaction, layerId));
     AlphaChange* alphaChange(change->mutable_alpha());
     alphaChange->set_alpha(alpha);
 }

 void SurfaceInterceptor::addMatrixLocked(Transaction* transaction, int32_t layerId,
         const layer_state_t::matrix22_t& matrix)
 {
     Change* change(addChangeLocked(transaction, layerId));
     MatrixChange* matrixChange(change->mutable_matrix());
     matrixChange->set_dsdx(matrix.dsdx);
     matrixChange->set_dtdx(matrix.dtdx);
     matrixChange->set_dsdy(matrix.dsdy);
     matrixChange->set_dtdy(matrix.dtdy);
 }

 void SurfaceInterceptor::addTransparentRegionLocked(Transaction* transaction, int32_t layerId,
         const Region& transRegion)
 {
     Change* change(addChangeLocked(transaction, layerId));
     TransparentRegionHintChange* transparentChange(change->mutable_transparent_region_hint());

     for (const auto& rect : transRegion) {
         Rectangle* protoRect(transparentChange->add_region());
         setProtoRectLocked(protoRect, rect);
     }
 }

 void SurfaceInterceptor::addFlagsLocked(Transaction* transaction, int32_t layerId, uint8_t flags) {
     // There can be multiple flags changed
     if (flags & layer_state_t::eLayerHidden) {
         Change* change(addChangeLocked(transaction, layerId));
         HiddenFlagChange* flagChange(change->mutable_hidden_flag());
         flagChange->set_hidden_flag(true);
     }
     if (flags & layer_state_t::eLayerOpaque) {
         Change* change(addChangeLocked(transaction, layerId));
         OpaqueFlagChange* flagChange(change->mutable_opaque_flag());
         flagChange->set_opaque_flag(true);
     }
     if (flags & layer_state_t::eLayerSecure) {
         Change* change(addChangeLocked(transaction, layerId));
         SecureFlagChange* flagChange(change->mutable_secure_flag());
         flagChange->set_secure_flag(true);
     }
 }

 void SurfaceInterceptor::addLayerStackLocked(Transaction* transaction, int32_t layerId,
         uint32_t layerStack)
 {
     Change* change(addChangeLocked(transaction, layerId));
     LayerStackChange* layerStackChange(change->mutable_layer_stack());
     layerStackChange->set_layer_stack(layerStack);
 }

 void SurfaceInterceptor::addCropLocked(Transaction* transaction, int32_t layerId,
         const Rect& rect)
 {
     Change* change(addChangeLocked(transaction, layerId));
     CropChange* cropChange(change->mutable_crop());
     Rectangle* protoRect(cropChange->mutable_rectangle());
     setProtoRectLocked(protoRect, rect);
 }

 void SurfaceInterceptor::addFinalCropLocked(Transaction* transaction, int32_t layerId,
         const Rect& rect)
 {
     Change* change(addChangeLocked(transaction, layerId));
     FinalCropChange* finalCropChange(change->mutable_final_crop());
     Rectangle* protoRect(finalCropChange->mutable_rectangle());
     setProtoRectLocked(protoRect, rect);
 }

 void SurfaceInterceptor::addDeferTransactionLocked(Transaction* transaction, int32_t layerId,
         const sp<const IBinder>& handle, uint64_t frameNumber)
 {
     Change* change(addChangeLocked(transaction, layerId));
     const sp<const Layer> layer(getLayer(handle));
     if (layer == nullptr) {
         ALOGE("An existing layer could not be retrieved with the handle"
                 " for the deferred transaction");
         return;
     }
     DeferredTransactionChange* deferTransaction(change->mutable_deferred_transaction());
     deferTransaction->set_layer_id(getLayerId(layer));
     deferTransaction->set_frame_number(frameNumber);
 }

 void SurfaceInterceptor::addOverrideScalingModeLocked(Transaction* transaction, int32_t layerId,
         int32_t overrideScalingMode)
 {
     Change* change(addChangeLocked(transaction, layerId));
     OverrideScalingModeChange* overrideChange(change->mutable_override_scaling_mode());
     overrideChange->set_override_scaling_mode(overrideScalingMode);
 }

 void SurfaceInterceptor::addChangedPropertiesLocked(Transaction* transaction,
         const layer_state_t& state)
 {
     const sp<const Layer> layer(getLayer(state.surface));
     if (layer == nullptr) {
         ALOGE("An existing layer could not be retrieved with the surface "
                 "from the layer_state_t surface in the update transaction");
         return;
     }

     const int32_t layerId(getLayerId(layer));

     if (state.what & layer_state_t::ePositionChanged) {
         addPositionLocked(transaction, layerId, state.x, state.y);
     }
     if (state.what & layer_state_t::eLayerChanged) {
         addDepthLocked(transaction, layerId, state.z);
     }
     if (state.what & layer_state_t::eSizeChanged) {
         addSizeLocked(transaction, layerId, state.w, state.h);
     }
     if (state.what & layer_state_t::eAlphaChanged) {
         addAlphaLocked(transaction, layerId, state.alpha);
     }
     if (state.what & layer_state_t::eMatrixChanged) {
         addMatrixLocked(transaction, layerId, state.matrix);
     }
     if (state.what & layer_state_t::eTransparentRegionChanged) {
         addTransparentRegionLocked(transaction, layerId, state.transparentRegion);
     }
     if (state.what & layer_state_t::eFlagsChanged) {
         addFlagsLocked(transaction, layerId, state.flags);
     }
     if (state.what & layer_state_t::eLayerStackChanged) {
         addLayerStackLocked(transaction, layerId, state.layerStack);
     }
     if (state.what & layer_state_t::eCropChanged) {
         addCropLocked(transaction, layerId, state.crop);
     }
     if (state.what & layer_state_t::eDeferTransaction) {
         addDeferTransactionLocked(transaction, layerId, state.handle, state.frameNumber);
     }
     if (state.what & layer_state_t::eFinalCropChanged) {
         addFinalCropLocked(transaction, layerId, state.finalCrop);
     }
     if (state.what & layer_state_t::eOverrideScalingModeChanged) {
         addOverrideScalingModeLocked(transaction, layerId, state.overrideScalingMode);
     }
 }

 void SurfaceInterceptor::addUpdatedLayersLocked(Increment* increment, uint32_t flags,
         const Vector<ComposerState>& stateUpdates)
 {
     Transaction* transaction(increment->mutable_transaction());
     transaction->set_synchronous(flags & BnSurfaceComposer::eSynchronous);
     transaction->set_animation(flags & BnSurfaceComposer::eAnimation);
     for (const auto& compState: stateUpdates) {
         addChangedPropertiesLocked(transaction, compState.state);
     }
 }

 void SurfaceInterceptor::addCreatedLayerLocked(Increment* increment, const sp<const Layer>& layer) {
     Create* create(increment->mutable_create());
     create->set_id(getLayerId(layer));
     create->set_name(getLayerName(layer));
     create->set_w(layer->mCurrentState.active.w);
     create->set_h(layer->mCurrentState.active.h);
 }

 void SurfaceInterceptor::addDeletedLayerLocked(Increment* increment, const sp<const Layer>& layer) {
     Delete* deleteLayer(increment->mutable_delete_());
     deleteLayer->set_id(getLayerId(layer));
 }

 void SurfaceInterceptor::addUpdatedBufferLocked(Increment* increment, const sp<const Layer>& layer,
         uint32_t width, uint32_t height, uint64_t frameNumber)
 {
     BufferUpdate* update(increment->mutable_buffer_update());
     update->set_id(getLayerId(layer));
     update->set_w(width);
     update->set_h(height);
     update->set_frame_number(frameNumber);
 }

 void SurfaceInterceptor::addUpdatedVsyncLocked(Increment* increment, nsecs_t timestamp) {
     VSyncEvent* event(increment->mutable_vsync_event());
     event->set_when(timestamp);
 }

 void SurfaceInterceptor::saveLayerUpdates(const Vector<ComposerState>& stateUpdates,
         uint32_t flags)
 {
     ATRACE_CALL();
     if (!mEnabled || stateUpdates.size() <= 0) {
         return;
     }
     std::lock_guard<std::mutex> protoGuard(mTraceMutex);
     addUpdatedLayersLocked(addTraceIncrementLocked(), flags, stateUpdates);
 }

 void SurfaceInterceptor::saveLayerCreate(const sp<const Layer>& layer) {
     ATRACE_CALL();
     if (!mEnabled || layer == nullptr) {
         return;
     }
     std::lock_guard<std::mutex> protoGuard(mTraceMutex);
     addCreatedLayerLocked(addTraceIncrementLocked(), layer);
 }

 void SurfaceInterceptor::saveLayerCreateLocked(const sp<const Layer>& layer) {
     if (!mEnabled || layer == nullptr) {
         return;
     }
     addCreatedLayerLocked(addTraceIncrementLocked(), layer);
 }

 void SurfaceInterceptor::saveLayerDelete(const sp<const Layer>& layer) {
     ATRACE_CALL();
     if (!mEnabled || layer == nullptr) {
         return;
     }
     std::lock_guard<std::mutex> protoGuard(mTraceMutex);
     addDeletedLayerLocked(addTraceIncrementLocked(), layer);
 }

 void SurfaceInterceptor::saveBufferUpdate(const sp<const Layer>& layer, uint32_t width,
         uint32_t height, uint64_t frameNumber)
 {
     ATRACE_CALL();
     if (!mEnabled || layer == nullptr) {
         return;
     }
     std::lock_guard<std::mutex> protoGuard(mTraceMutex);
     addUpdatedBufferLocked(addTraceIncrementLocked(), layer, width, height, frameNumber);
 }

 void SurfaceInterceptor::saveVSyncEvent(nsecs_t timestamp) {
     if (!mEnabled) {
         return;
     }
     std::lock_guard<std::mutex> protoGuard(mTraceMutex);
     addUpdatedVsyncLocked(addTraceIncrementLocked(), timestamp);
 }

 } // namespace android
	/*
	* Copyright 2016 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.
	*/

	#undef LOG_TAG
	#define LOG_TAG "SurfaceInterceptor"
	#define ATRACE_TAG ATRACE_TAG_GRAPHICS

	#include "Layer.h"
	#include "SurfaceFlinger.h"
	#include "SurfaceInterceptor.h"

	#include <cutils/log.h>

	#include <utils/Trace.h>

	#include <fstream>

	namespace android {

	// ----------------------------------------------------------------------------

	void SurfaceInterceptor::enable(const SortedVector<sp<Layer>>& layers) {
	ATRACE_CALL();
	if (mEnabled) {
	return;
	}
	mEnabled = true;
	saveExistingLayers(layers);
	}

	void SurfaceInterceptor::disable() {
	ATRACE_CALL();
	if (!mEnabled) {
	return;
	}
	std::lock_guard<std::mutex> protoGuard(mTraceMutex);
	mEnabled = false;
	status_t err(writeProtoFileLocked());
	ALOGE_IF(err == PERMISSION_DENIED, "Could not save the proto file! Permission denied");
	ALOGE_IF(err == NOT_ENOUGH_DATA, "Could not save the proto file! There are missing fields");
	mTrace.Clear();
	}

	void SurfaceInterceptor::saveExistingLayers(const SortedVector<sp<Layer>>& layers) {
	ATRACE_CALL();
	std::lock_guard<std::mutex> protoGuard(mTraceMutex);
	for (const auto& layer : layers) {
	saveLayerCreateLocked(layer);
	saveInitialLayerStateLocked(layer);
	}
	}

	void SurfaceInterceptor::saveInitialLayerStateLocked(const sp<const Layer>& layer) {
	ATRACE_CALL();
	if (layer == nullptr) {
	return;
	}
	Increment* increment(addTraceIncrementLocked());
	Transaction* transaction(increment->mutable_transaction());
	transaction->set_synchronous(layer->mTransactionFlags & BnSurfaceComposer::eSynchronous);
	transaction->set_animation(layer->mTransactionFlags & BnSurfaceComposer::eAnimation);

	const int32_t layerId(getLayerId(layer));
	addPositionLocked(transaction, layerId, layer->mCurrentState.active.transform.tx(),
	layer->mCurrentState.active.transform.ty());
	addDepthLocked(transaction, layerId, layer->mCurrentState.z);
	addSizeLocked(transaction, layerId, layer->mCurrentState.active.w,
	layer->mCurrentState.active.h);
	addAlphaLocked(transaction, layerId, layer->mCurrentState.alpha);
	addTransparentRegionLocked(transaction, layerId, layer->mCurrentState.activeTransparentRegion);
	addLayerStackLocked(transaction, layerId, layer->mCurrentState.layerStack);
	addCropLocked(transaction, layerId, layer->mCurrentState.crop);
	if (layer->mCurrentState.handle != NULL) {
	addDeferTransactionLocked(transaction, layerId, layer->mCurrentState.handle,
	layer->mCurrentState.frameNumber);
	}
	addFinalCropLocked(transaction, layerId, layer->mCurrentState.finalCrop);
	addOverrideScalingModeLocked(transaction, layerId, layer->getEffectiveScalingMode());
	addFlagsLocked(transaction, layerId, layer->mCurrentState.flags);
	}

	status_t SurfaceInterceptor::writeProtoFileLocked() {
	ATRACE_CALL();
	std::ofstream output(mOutputFileName, std::ios::out \| std::ios::trunc \| std::ios::binary);
	// SerializeToOstream returns false when it's missing required data or when it could not write
	if (!mTrace.IsInitialized()) {
	return NOT_ENOUGH_DATA;
	}
	if (!mTrace.SerializeToOstream(&output)) {
	return PERMISSION_DENIED;
	}
	return NO_ERROR;
	}

	void SurfaceInterceptor::setOutputFileName(const std::string& outputFileName) {
	mOutputFileName = outputFileName;
	}

	const sp<const Layer> SurfaceInterceptor::getLayer(const sp<const IBinder>& handle) {
	const auto layerHandle(static_cast<const Layer::Handle*>(handle.get()));
	const sp<const Layer> layer(layerHandle->owner.promote());
	// layer could be a nullptr at this point
	return layer;
	}

	const std::string SurfaceInterceptor::getLayerName(const sp<const Layer>& layer) {
	return layer->getName().string();
	}

	int32_t SurfaceInterceptor::getLayerId(const sp<const Layer>& layer) {
	return layer->sequence;
	}

	Increment* SurfaceInterceptor::addTraceIncrementLocked() {
	Increment* increment(mTrace.add_increment());
	increment->set_time_stamp(systemTime());
	return increment;
	}

	Change* SurfaceInterceptor::addChangeLocked(Transaction* transaction, int32_t layerId) {
	Change* change(transaction->add_change());
	change->set_id(layerId);
	return change;
	}

	void SurfaceInterceptor::setProtoRectLocked(Rectangle* protoRect, const Rect& rect) {
	protoRect->set_left(rect.left);
	protoRect->set_top(rect.top);
	protoRect->set_right(rect.right);
	protoRect->set_bottom(rect.bottom);
	}

	void SurfaceInterceptor::addPositionLocked(Transaction* transaction, int32_t layerId, float x,
	float y)
	{
	Change* change(addChangeLocked(transaction, layerId));
	PositionChange* posChange(change->mutable_position());
	posChange->set_x(x);
	posChange->set_y(y);
	}

	void SurfaceInterceptor::addDepthLocked(Transaction* transaction, int32_t layerId, uint32_t z) {
	Change* change(addChangeLocked(transaction, layerId));
	LayerChange* depthChange(change->mutable_layer());
	depthChange->set_layer(z);
	}

	void SurfaceInterceptor::addSizeLocked(Transaction* transaction, int32_t layerId, uint32_t w,
	uint32_t h)
	{
	Change* change(addChangeLocked(transaction, layerId));
	SizeChange* sizeChange(change->mutable_size());
	sizeChange->set_w(w);
	sizeChange->set_h(h);
	}

	void SurfaceInterceptor::addAlphaLocked(Transaction* transaction, int32_t layerId, float alpha) {
	Change* change(addChangeLocked(transaction, layerId));
	AlphaChange* alphaChange(change->mutable_alpha());
	alphaChange->set_alpha(alpha);
	}

	void SurfaceInterceptor::addMatrixLocked(Transaction* transaction, int32_t layerId,
	const layer_state_t::matrix22_t& matrix)
	{
	Change* change(addChangeLocked(transaction, layerId));
	MatrixChange* matrixChange(change->mutable_matrix());
	matrixChange->set_dsdx(matrix.dsdx);
	matrixChange->set_dtdx(matrix.dtdx);
	matrixChange->set_dsdy(matrix.dsdy);
	matrixChange->set_dtdy(matrix.dtdy);
	}

	void SurfaceInterceptor::addTransparentRegionLocked(Transaction* transaction, int32_t layerId,
	const Region& transRegion)
	{
	Change* change(addChangeLocked(transaction, layerId));
	TransparentRegionHintChange* transparentChange(change->mutable_transparent_region_hint());

	for (const auto& rect : transRegion) {
	Rectangle* protoRect(transparentChange->add_region());
	setProtoRectLocked(protoRect, rect);
	}
	}

	void SurfaceInterceptor::addFlagsLocked(Transaction* transaction, int32_t layerId, uint8_t flags) {
	// There can be multiple flags changed
	if (flags & layer_state_t::eLayerHidden) {
	Change* change(addChangeLocked(transaction, layerId));
	HiddenFlagChange* flagChange(change->mutable_hidden_flag());
	flagChange->set_hidden_flag(true);
	}
	if (flags & layer_state_t::eLayerOpaque) {
	Change* change(addChangeLocked(transaction, layerId));
	OpaqueFlagChange* flagChange(change->mutable_opaque_flag());
	flagChange->set_opaque_flag(true);
	}
	if (flags & layer_state_t::eLayerSecure) {
	Change* change(addChangeLocked(transaction, layerId));
	SecureFlagChange* flagChange(change->mutable_secure_flag());
	flagChange->set_secure_flag(true);
	}
	}

	void SurfaceInterceptor::addLayerStackLocked(Transaction* transaction, int32_t layerId,
	uint32_t layerStack)
	{
	Change* change(addChangeLocked(transaction, layerId));
	LayerStackChange* layerStackChange(change->mutable_layer_stack());
	layerStackChange->set_layer_stack(layerStack);
	}

	void SurfaceInterceptor::addCropLocked(Transaction* transaction, int32_t layerId,
	const Rect& rect)
	{
	Change* change(addChangeLocked(transaction, layerId));
	CropChange* cropChange(change->mutable_crop());
	Rectangle* protoRect(cropChange->mutable_rectangle());
	setProtoRectLocked(protoRect, rect);
	}

	void SurfaceInterceptor::addFinalCropLocked(Transaction* transaction, int32_t layerId,
	const Rect& rect)
	{
	Change* change(addChangeLocked(transaction, layerId));
	FinalCropChange* finalCropChange(change->mutable_final_crop());
	Rectangle* protoRect(finalCropChange->mutable_rectangle());
	setProtoRectLocked(protoRect, rect);
	}

	void SurfaceInterceptor::addDeferTransactionLocked(Transaction* transaction, int32_t layerId,
	const sp<const IBinder>& handle, uint64_t frameNumber)
	{
	Change* change(addChangeLocked(transaction, layerId));
	const sp<const Layer> layer(getLayer(handle));
	if (layer == nullptr) {
	ALOGE("An existing layer could not be retrieved with the handle"
	" for the deferred transaction");
	return;
	}
	DeferredTransactionChange* deferTransaction(change->mutable_deferred_transaction());
	deferTransaction->set_layer_id(getLayerId(layer));
	deferTransaction->set_frame_number(frameNumber);
	}

	void SurfaceInterceptor::addOverrideScalingModeLocked(Transaction* transaction, int32_t layerId,
	int32_t overrideScalingMode)
	{
	Change* change(addChangeLocked(transaction, layerId));
	OverrideScalingModeChange* overrideChange(change->mutable_override_scaling_mode());
	overrideChange->set_override_scaling_mode(overrideScalingMode);
	}

	void SurfaceInterceptor::addChangedPropertiesLocked(Transaction* transaction,
	const layer_state_t& state)
	{
	const sp<const Layer> layer(getLayer(state.surface));
	if (layer == nullptr) {
	ALOGE("An existing layer could not be retrieved with the surface "
	"from the layer_state_t surface in the update transaction");
	return;
	}

	const int32_t layerId(getLayerId(layer));

	if (state.what & layer_state_t::ePositionChanged) {
	addPositionLocked(transaction, layerId, state.x, state.y);
	}
	if (state.what & layer_state_t::eLayerChanged) {
	addDepthLocked(transaction, layerId, state.z);
	}
	if (state.what & layer_state_t::eSizeChanged) {
	addSizeLocked(transaction, layerId, state.w, state.h);
	}
	if (state.what & layer_state_t::eAlphaChanged) {
	addAlphaLocked(transaction, layerId, state.alpha);
	}
	if (state.what & layer_state_t::eMatrixChanged) {
	addMatrixLocked(transaction, layerId, state.matrix);
	}
	if (state.what & layer_state_t::eTransparentRegionChanged) {
	addTransparentRegionLocked(transaction, layerId, state.transparentRegion);
	}
	if (state.what & layer_state_t::eFlagsChanged) {
	addFlagsLocked(transaction, layerId, state.flags);
	}
	if (state.what & layer_state_t::eLayerStackChanged) {
	addLayerStackLocked(transaction, layerId, state.layerStack);
	}
	if (state.what & layer_state_t::eCropChanged) {
	addCropLocked(transaction, layerId, state.crop);
	}
	if (state.what & layer_state_t::eDeferTransaction) {
	addDeferTransactionLocked(transaction, layerId, state.handle, state.frameNumber);
	}
	if (state.what & layer_state_t::eFinalCropChanged) {
	addFinalCropLocked(transaction, layerId, state.finalCrop);
	}
	if (state.what & layer_state_t::eOverrideScalingModeChanged) {
	addOverrideScalingModeLocked(transaction, layerId, state.overrideScalingMode);
	}
	}

	void SurfaceInterceptor::addUpdatedLayersLocked(Increment* increment, uint32_t flags,
	const Vector<ComposerState>& stateUpdates)
	{
	Transaction* transaction(increment->mutable_transaction());
	transaction->set_synchronous(flags & BnSurfaceComposer::eSynchronous);
	transaction->set_animation(flags & BnSurfaceComposer::eAnimation);
	for (const auto& compState: stateUpdates) {
	addChangedPropertiesLocked(transaction, compState.state);
	}
	}

	void SurfaceInterceptor::addCreatedLayerLocked(Increment* increment, const sp<const Layer>& layer) {
	Create* create(increment->mutable_create());
	create->set_id(getLayerId(layer));
	create->set_name(getLayerName(layer));
	create->set_w(layer->mCurrentState.active.w);
	create->set_h(layer->mCurrentState.active.h);
	}

	void SurfaceInterceptor::addDeletedLayerLocked(Increment* increment, const sp<const Layer>& layer) {
	Delete* deleteLayer(increment->mutable_delete_());
	deleteLayer->set_id(getLayerId(layer));
	}

	void SurfaceInterceptor::addUpdatedBufferLocked(Increment* increment, const sp<const Layer>& layer,
	uint32_t width, uint32_t height, uint64_t frameNumber)
	{
	BufferUpdate* update(increment->mutable_buffer_update());
	update->set_id(getLayerId(layer));
	update->set_w(width);
	update->set_h(height);
	update->set_frame_number(frameNumber);
	}

	void SurfaceInterceptor::addUpdatedVsyncLocked(Increment* increment, nsecs_t timestamp) {
	VSyncEvent* event(increment->mutable_vsync_event());
	event->set_when(timestamp);
	}

	void SurfaceInterceptor::saveLayerUpdates(const Vector<ComposerState>& stateUpdates,
	uint32_t flags)
	{
	ATRACE_CALL();
	if (!mEnabled \|\| stateUpdates.size() <= 0) {
	return;
	}
	std::lock_guard<std::mutex> protoGuard(mTraceMutex);
	addUpdatedLayersLocked(addTraceIncrementLocked(), flags, stateUpdates);
	}

	void SurfaceInterceptor::saveLayerCreate(const sp<const Layer>& layer) {
	ATRACE_CALL();
	if (!mEnabled \|\| layer == nullptr) {
	return;
	}
	std::lock_guard<std::mutex> protoGuard(mTraceMutex);
	addCreatedLayerLocked(addTraceIncrementLocked(), layer);
	}

	void SurfaceInterceptor::saveLayerCreateLocked(const sp<const Layer>& layer) {
	if (!mEnabled \|\| layer == nullptr) {
	return;
	}
	addCreatedLayerLocked(addTraceIncrementLocked(), layer);
	}

	void SurfaceInterceptor::saveLayerDelete(const sp<const Layer>& layer) {
	ATRACE_CALL();
	if (!mEnabled \|\| layer == nullptr) {
	return;
	}
	std::lock_guard<std::mutex> protoGuard(mTraceMutex);
	addDeletedLayerLocked(addTraceIncrementLocked(), layer);
	}

	void SurfaceInterceptor::saveBufferUpdate(const sp<const Layer>& layer, uint32_t width,
	uint32_t height, uint64_t frameNumber)
	{
	ATRACE_CALL();
	if (!mEnabled \|\| layer == nullptr) {
	return;
	}
	std::lock_guard<std::mutex> protoGuard(mTraceMutex);
	addUpdatedBufferLocked(addTraceIncrementLocked(), layer, width, height, frameNumber);
	}

	void SurfaceInterceptor::saveVSyncEvent(nsecs_t timestamp) {
	if (!mEnabled) {
	return;
	}
	std::lock_guard<std::mutex> protoGuard(mTraceMutex);
	addUpdatedVsyncLocked(addTraceIncrementLocked(), timestamp);
	}

	} // namespace android