Remove unnecessary transition logic from ImageWallpaper (4a297798) · Commits · e / os / android_frameworks_base

packages/SystemUI/res/raw/image_wallpaper_fragment_shader.glsl

+1 −66

Original line number	Original line	Diff line number	Diff line
	@@ -3,74 +3,9 @@ precision mediump float;
	// The actual wallpaper texture.		// The actual wallpaper texture.
	uniform sampler2D uTexture;		uniform sampler2D uTexture;

	// The 85th percenile for the luminance histogram of the image (a value between 0 and 1).
	// This value represents the point in histogram that includes 85% of the pixels of the image.
	uniform float uPer85;

	// Reveal is the animation value that goes from 1 (the image is hidden) to 0 (the image is visible).
	uniform float uReveal;

	// The opacity of locked screen (constant value).
	uniform float uAod2Opacity;
	varying vec2 vTextureCoordinates;		varying vec2 vTextureCoordinates;

	/*
	* Calculates the relative luminance of the pixel.
	*/
	vec3 luminosity(vec3 color) {
	float lum = 0.2126 * color.r + 0.7152 * color.g + 0.0722 * color.b;
	return vec3(lum);
	}

	vec4 transform(vec3 diffuse) {
	// Getting the luminance for this pixel
	vec3 lum = luminosity(diffuse);

	/*
	* while the reveal > per85, it shows the luminance image (B&W image)
	* then when moving passed that value, the image gets colored.
	*/
	float trans = smoothstep(0., uPer85, uReveal);
	diffuse = mix(diffuse, lum, trans);

	// 'lower' value represents the capped 'reveal' value to the range [0, per85]
	float selector = step(uPer85, uReveal);
	float lower = mix(uReveal, uPer85, selector);

	/*
	* Remaps image:
	* - from reveal=1 to reveal=per85 => lower=per85, diffuse=luminance
	* That means that remaps black and white image pixel
	* from a possible values of [0,1] to [per85, 1] (if the pixel is darker than per85,
	* it's gonna be black, if it's between per85 and 1, it's gonna be gray
	* and if it's 1 it's gonna be white).
	* - from reveal=per85 to reveal=0 => lower=reveal, 'diffuse' changes from luminance to color
	* That means that remaps each image pixel color (rgb)
	* from a possible values of [0,1] to [lower, 1] (if the pixel color is darker than 'lower',
	* it's gonna be 0, if it's between 'lower' and 1, it's gonna be remap to a value
	* between 0 and 1 and if it's 1 it's gonna be 1).
	* - if reveal=0 => lower=0, diffuse=color image
	* The image is shown as it is, colored.
	*/
	vec3 remaps = smoothstep(lower, 1., diffuse);

	// Interpolate between diffuse and remaps using reveal to avoid over saturation.
	diffuse = mix(diffuse, remaps, uReveal);

	/*
	* Fades in the pixel value:
	* - if reveal=1 => fadeInOpacity=0
	* - from reveal=1 to reveal=per85 => 0<=fadeInOpacity<=1
	* - if reveal>per85 => fadeInOpacity=1
	*/
	float fadeInOpacity = 1. - smoothstep(uPer85, 1., uReveal);
	diffuse = uAod2Opacity fadeInOpacity;

	return vec4(diffuse.r, diffuse.g, diffuse.b, 1.);
	}

	void main() {		void main() {
	// gets the pixel value of the wallpaper for this uv coordinates on screen.		// gets the pixel value of the wallpaper for this uv coordinates on screen.
	vec4 fragColor = texture2D(uTexture, vTextureCoordinates);		gl_FragColor = texture2D(uTexture, vTextureCoordinates);
	gl_FragColor = transform(fragColor.rgb);
	}		}
			No newline at end of file

packages/SystemUI/src/com/android/systemui/ImageWallpaper.java

+11 −176

Original line number	Original line	Diff line number	Diff line
	@@ -16,9 +16,6 @@

	package com.android.systemui;		package com.android.systemui;

	import android.app.ActivityManager;
	import android.content.Context;
	import android.content.res.Configuration;
	import android.graphics.Rect;		import android.graphics.Rect;
	import android.os.Handler;		import android.os.Handler;
	import android.os.HandlerThread;		import android.os.HandlerThread;
	@@ -27,17 +24,12 @@ import android.os.Trace;
	import android.service.wallpaper.WallpaperService;		import android.service.wallpaper.WallpaperService;
	import android.util.Log;		import android.util.Log;
	import android.util.Size;		import android.util.Size;
	import android.view.DisplayInfo;
	import android.view.SurfaceHolder;		import android.view.SurfaceHolder;

	import com.android.internal.annotations.VisibleForTesting;		import com.android.internal.annotations.VisibleForTesting;
	import com.android.systemui.glwallpaper.EglHelper;		import com.android.systemui.glwallpaper.EglHelper;
	import com.android.systemui.glwallpaper.GLWallpaperRenderer;		import com.android.systemui.glwallpaper.GLWallpaperRenderer;
	import com.android.systemui.glwallpaper.ImageWallpaperRenderer;		import com.android.systemui.glwallpaper.ImageWallpaperRenderer;
	import com.android.systemui.plugins.statusbar.StatusBarStateController;
	import com.android.systemui.plugins.statusbar.StatusBarStateController.StateListener;
	import com.android.systemui.statusbar.StatusBarState;
	import com.android.systemui.statusbar.phone.DozeParameters;

	import java.io.FileDescriptor;		import java.io.FileDescriptor;
	import java.io.PrintWriter;		import java.io.PrintWriter;
	@@ -53,16 +45,12 @@ public class ImageWallpaper extends WallpaperService {
	// We delayed destroy render context that subsequent render requests have chance to cancel it.		// We delayed destroy render context that subsequent render requests have chance to cancel it.
	// This is to avoid destroying then recreating render context in a very short time.		// This is to avoid destroying then recreating render context in a very short time.
	private static final int DELAY_FINISH_RENDERING = 1000;		private static final int DELAY_FINISH_RENDERING = 1000;
	private static final int INTERVAL_WAIT_FOR_RENDERING = 100;		private static final boolean DEBUG = false;
	private static final int PATIENCE_WAIT_FOR_RENDERING = 10;
	private static final boolean DEBUG = true;
	private final DozeParameters mDozeParameters;
	private HandlerThread mWorker;		private HandlerThread mWorker;

	@Inject		@Inject
	public ImageWallpaper(DozeParameters dozeParameters) {		public ImageWallpaper() {
	super();		super();
	mDozeParameters = dozeParameters;
	}		}

	@Override		@Override
	@@ -74,7 +62,7 @@ public class ImageWallpaper extends WallpaperService {

	@Override		@Override
	public Engine onCreateEngine() {		public Engine onCreateEngine() {
	return new GLEngine(this, mDozeParameters);		return new GLEngine();
	}		}

	@Override		@Override
	@@ -84,7 +72,7 @@ public class ImageWallpaper extends WallpaperService {
	mWorker = null;		mWorker = null;
	}		}

	class GLEngine extends Engine implements GLWallpaperRenderer.SurfaceProxy, StateListener {		class GLEngine extends Engine {
	// Surface is rejected if size below a threshold on some devices (ie. 8px on elfin)		// Surface is rejected if size below a threshold on some devices (ie. 8px on elfin)
	// set min to 64 px (CTS covers this), please refer to ag/4867989 for detail.		// set min to 64 px (CTS covers this), please refer to ag/4867989 for detail.
	@VisibleForTesting		@VisibleForTesting
	@@ -94,40 +82,15 @@ public class ImageWallpaper extends WallpaperService {

	private GLWallpaperRenderer mRenderer;		private GLWallpaperRenderer mRenderer;
	private EglHelper mEglHelper;		private EglHelper mEglHelper;
	private StatusBarStateController mController;
	private final Runnable mFinishRenderingTask = this::finishRendering;		private final Runnable mFinishRenderingTask = this::finishRendering;
	private boolean mShouldStopTransition;
	private final DisplayInfo mDisplayInfo = new DisplayInfo();
	private final Object mMonitor = new Object();
	@VisibleForTesting
	boolean mIsHighEndGfx;
	private boolean mDisplayNeedsBlanking;
	private boolean mNeedTransition;
	private boolean mNeedRedraw;		private boolean mNeedRedraw;
	// This variable can only be accessed in synchronized block.
	private boolean mWaitingForRendering;

	GLEngine(Context context, DozeParameters dozeParameters) {		GLEngine() {
	init(dozeParameters);
	}		}

	@VisibleForTesting		@VisibleForTesting
	GLEngine(DozeParameters dozeParameters, Handler handler) {		GLEngine(Handler handler) {
	super(SystemClock::elapsedRealtime, handler);		super(SystemClock::elapsedRealtime, handler);
	init(dozeParameters);
	}

	private void init(DozeParameters dozeParameters) {
	mIsHighEndGfx = ActivityManager.isHighEndGfx();
	mDisplayNeedsBlanking = dozeParameters.getDisplayNeedsBlanking();
	mNeedTransition = false;

	// We will preserve EGL context when we are in lock screen or aod
	// to avoid janking in following transition, we need to release when back to home.
	mController = Dependency.get(StatusBarStateController.class);
	if (mController != null) {
	mController.addCallback(this /* StateListener */);
	}
	}		}

	@Override		@Override
	@@ -135,9 +98,8 @@ public class ImageWallpaper extends WallpaperService {
	mEglHelper = getEglHelperInstance();		mEglHelper = getEglHelperInstance();
	// Deferred init renderer because we need to get wallpaper by display context.		// Deferred init renderer because we need to get wallpaper by display context.
	mRenderer = getRendererInstance();		mRenderer = getRendererInstance();
	getDisplayContext().getDisplay().getDisplayInfo(mDisplayInfo);
	setFixedSizeAllowed(true);		setFixedSizeAllowed(true);
	setOffsetNotificationsEnabled(mNeedTransition);		setOffsetNotificationsEnabled(false);
	updateSurfaceSize();		updateSurfaceSize();
	}		}

	@@ -146,7 +108,7 @@ public class ImageWallpaper extends WallpaperService {
	}		}

	ImageWallpaperRenderer getRendererInstance() {		ImageWallpaperRenderer getRendererInstance() {
	return new ImageWallpaperRenderer(getDisplayContext(), this /* SurfaceProxy */);		return new ImageWallpaperRenderer(getDisplayContext());
	}		}

	private void updateSurfaceSize() {		private void updateSurfaceSize() {
	@@ -157,79 +119,13 @@ public class ImageWallpaper extends WallpaperService {
	holder.setFixedSize(width, height);		holder.setFixedSize(width, height);
	}		}

	/**
	* Check if necessary to stop transition with current wallpaper on this device. <br/>
	* This should only be invoked after {@link #onSurfaceCreated(SurfaceHolder)}}
	* is invoked since it needs display context and surface frame size.
	* @return true if need to stop transition.
	*/
	@VisibleForTesting
	boolean checkIfShouldStopTransition() {
	int orientation = getDisplayContext().getResources().getConfiguration().orientation;
	Rect frame = getSurfaceHolder().getSurfaceFrame();
	Rect display = new Rect();
	if (orientation == Configuration.ORIENTATION_PORTRAIT) {
	display.set(0, 0, mDisplayInfo.logicalWidth, mDisplayInfo.logicalHeight);
	} else {
	display.set(0, 0, mDisplayInfo.logicalHeight, mDisplayInfo.logicalWidth);
	}
	return mNeedTransition
	&& (frame.width() < display.width() \|\| frame.height() < display.height());
	}

	@Override
	public void onOffsetsChanged(float xOffset, float yOffset, float xOffsetStep,
	float yOffsetStep, int xPixelOffset, int yPixelOffset) {
	if (mWorker == null) return;
	mWorker.getThreadHandler().post(() -> mRenderer.updateOffsets(xOffset, yOffset));
	}

	@Override
	public void onAmbientModeChanged(boolean inAmbientMode, long animationDuration) {
	if (mWorker == null \|\| !mNeedTransition) return;
	final long duration = mShouldStopTransition ? 0 : animationDuration;
	if (DEBUG) {
	Log.d(TAG, "onAmbientModeChanged: inAmbient=" + inAmbientMode
	+ ", duration=" + duration
	+ ", mShouldStopTransition=" + mShouldStopTransition);
	}
	mWorker.getThreadHandler().post(
	() -> mRenderer.updateAmbientMode(inAmbientMode, duration));
	if (inAmbientMode && animationDuration == 0) {
	// This means that we are transiting from home to aod, to avoid
	// race condition between window visibility and transition,
	// we don't return until the transition is finished. See b/136643341.
	waitForBackgroundRendering();
	}
	}

	@Override		@Override
	public boolean shouldZoomOutWallpaper() {		public boolean shouldZoomOutWallpaper() {
	return true;		return true;
	}		}

	private void waitForBackgroundRendering() {
	synchronized (mMonitor) {
	try {
	mWaitingForRendering = true;
	for (int patience = 1; mWaitingForRendering; patience++) {
	mMonitor.wait(INTERVAL_WAIT_FOR_RENDERING);
	mWaitingForRendering &= patience < PATIENCE_WAIT_FOR_RENDERING;
	}
	} catch (InterruptedException ex) {
	} finally {
	mWaitingForRendering = false;
	}
	}
	}

	@Override		@Override
	public void onDestroy() {		public void onDestroy() {
	if (mController != null) {
	mController.removeCallback(this /* StateListener */);
	}
	mController = null;

	mWorker.getThreadHandler().post(() -> {		mWorker.getThreadHandler().post(() -> {
	mRenderer.finish();		mRenderer.finish();
	mRenderer = null;		mRenderer = null;
	@@ -240,7 +136,6 @@ public class ImageWallpaper extends WallpaperService {

	@Override		@Override
	public void onSurfaceCreated(SurfaceHolder holder) {		public void onSurfaceCreated(SurfaceHolder holder) {
	mShouldStopTransition = checkIfShouldStopTransition();
	if (mWorker == null) return;		if (mWorker == null) return;
	mWorker.getThreadHandler().post(() -> {		mWorker.getThreadHandler().post(() -> {
	mEglHelper.init(holder, needSupportWideColorGamut());		mEglHelper.init(holder, needSupportWideColorGamut());
	@@ -251,32 +146,13 @@ public class ImageWallpaper extends WallpaperService {
	@Override		@Override
	public void onSurfaceChanged(SurfaceHolder holder, int format, int width, int height) {		public void onSurfaceChanged(SurfaceHolder holder, int format, int width, int height) {
	if (mWorker == null) return;		if (mWorker == null) return;
	mWorker.getThreadHandler().post(() -> {		mWorker.getThreadHandler().post(() -> mRenderer.onSurfaceChanged(width, height));
	mRenderer.onSurfaceChanged(width, height);
	mNeedRedraw = true;
	});
	}		}

	@Override		@Override
	public void onSurfaceRedrawNeeded(SurfaceHolder holder) {		public void onSurfaceRedrawNeeded(SurfaceHolder holder) {
	if (mWorker == null) return;		if (mWorker == null) return;
	if (DEBUG) {		mWorker.getThreadHandler().post(this::drawFrame);
	Log.d(TAG, "onSurfaceRedrawNeeded: mNeedRedraw=" + mNeedRedraw);
	}

	mWorker.getThreadHandler().post(() -> {
	if (mNeedRedraw) {
	drawFrame();
	mNeedRedraw = false;
	}
	});
	}

	@Override
	public void onVisibilityChanged(boolean visible) {
	if (DEBUG) {
	Log.d(TAG, "wallpaper visibility changes: " + visible);
	}
	}		}

	private void drawFrame() {		private void drawFrame() {
	@@ -285,15 +161,6 @@ public class ImageWallpaper extends WallpaperService {
	postRender();		postRender();
	}		}

	@Override
	public void onStatePostChange() {
	// When back to home, we try to release EGL, which is preserved in lock screen or aod.
	if (mWorker != null && mController.getState() == StatusBarState.SHADE) {
	mWorker.getThreadHandler().post(this::scheduleFinishRendering);
	}
	}

	@Override
	public void preRender() {		public void preRender() {
	// This method should only be invoked from worker thread.		// This method should only be invoked from worker thread.
	Trace.beginSection("ImageWallpaper#preRender");		Trace.beginSection("ImageWallpaper#preRender");
	@@ -330,7 +197,6 @@ public class ImageWallpaper extends WallpaperService {
	}		}
	}		}

	@Override
	public void requestRender() {		public void requestRender() {
	// This method should only be invoked from worker thread.		// This method should only be invoked from worker thread.
	Trace.beginSection("ImageWallpaper#requestRender");		Trace.beginSection("ImageWallpaper#requestRender");
	@@ -355,27 +221,13 @@ public class ImageWallpaper extends WallpaperService {
	}		}
	}		}

	@Override
	public void postRender() {		public void postRender() {
	// This method should only be invoked from worker thread.		// This method should only be invoked from worker thread.
	Trace.beginSection("ImageWallpaper#postRender");		Trace.beginSection("ImageWallpaper#postRender");
	notifyWaitingThread();
	scheduleFinishRendering();		scheduleFinishRendering();
	Trace.endSection();		Trace.endSection();
	}		}

	private void notifyWaitingThread() {
	synchronized (mMonitor) {
	if (mWaitingForRendering) {
	try {
	mWaitingForRendering = false;
	mMonitor.notify();
	} catch (IllegalMonitorStateException ex) {
	}
	}
	}
	}

	private void cancelFinishRenderingTask() {		private void cancelFinishRenderingTask() {
	if (mWorker == null) return;		if (mWorker == null) return;
	mWorker.getThreadHandler().removeCallbacks(mFinishRenderingTask);		mWorker.getThreadHandler().removeCallbacks(mFinishRenderingTask);
	@@ -391,18 +243,11 @@ public class ImageWallpaper extends WallpaperService {
	Trace.beginSection("ImageWallpaper#finishRendering");		Trace.beginSection("ImageWallpaper#finishRendering");
	if (mEglHelper != null) {		if (mEglHelper != null) {
	mEglHelper.destroyEglSurface();		mEglHelper.destroyEglSurface();
	if (!needPreserveEglContext()) {
	mEglHelper.destroyEglContext();		mEglHelper.destroyEglContext();
	}		}
	}
	Trace.endSection();		Trace.endSection();
	}		}

	private boolean needPreserveEglContext() {
	return mNeedTransition && mController != null
	&& mController.getState() == StatusBarState.KEYGUARD;
	}

	private boolean needSupportWideColorGamut() {		private boolean needSupportWideColorGamut() {
	return mRenderer.isWcgContent();		return mRenderer.isWcgContent();
	}		}
	@@ -411,16 +256,6 @@ public class ImageWallpaper extends WallpaperService {
	protected void dump(String prefix, FileDescriptor fd, PrintWriter out, String[] args) {		protected void dump(String prefix, FileDescriptor fd, PrintWriter out, String[] args) {
	super.dump(prefix, fd, out, args);		super.dump(prefix, fd, out, args);
	out.print(prefix); out.print("Engine="); out.println(this);		out.print(prefix); out.print("Engine="); out.println(this);
	out.print(prefix); out.print("isHighEndGfx="); out.println(mIsHighEndGfx);
	out.print(prefix); out.print("displayNeedsBlanking=");
	out.println(mDisplayNeedsBlanking);
	out.print(prefix); out.print("displayInfo="); out.print(mDisplayInfo);
	out.print(prefix); out.print("mNeedTransition="); out.println(mNeedTransition);
	out.print(prefix); out.print("mShouldStopTransition=");
	out.println(mShouldStopTransition);
	out.print(prefix); out.print("StatusBarState=");
	out.println(mController != null ? mController.getState() : "null");

	out.print(prefix); out.print("valid surface=");		out.print(prefix); out.print("valid surface=");
	out.println(getSurfaceHolder() != null && getSurfaceHolder().getSurface() != null		out.println(getSurfaceHolder() != null && getSurfaceHolder().getSurface() != null
	? getSurfaceHolder().getSurface().isValid()		? getSurfaceHolder().getSurface().isValid()

packages/SystemUI/src/com/android/systemui/glwallpaper/GLWallpaperRenderer.java

+0 −34

Original line number	Original line	Diff line number	Diff line
	@@ -48,20 +48,6 @@ public interface GLWallpaperRenderer {
	*/		*/
	void onDrawFrame();		void onDrawFrame();

	/**
	* Notify ambient mode is changed.
	* @param inAmbientMode true if in ambient mode.
	* @param duration duration of transition.
	*/
	void updateAmbientMode(boolean inAmbientMode, long duration);

	/**
	* Notify the wallpaper offsets changed.
	* @param xOffset offset along x axis.
	* @param yOffset offset along y axis.
	*/
	void updateOffsets(float xOffset, float yOffset);

	/**		/**
	* Ask renderer to report the surface size it needs.		* Ask renderer to report the surface size it needs.
	*/		*/
	@@ -81,24 +67,4 @@ public interface GLWallpaperRenderer {
	*/		*/
	void dump(String prefix, FileDescriptor fd, PrintWriter out, String[] args);		void dump(String prefix, FileDescriptor fd, PrintWriter out, String[] args);

	/**
	* A proxy which owns surface holder.
	*/
	interface SurfaceProxy {

	/**
	* Ask proxy to start rendering frame to surface.
	*/
	void requestRender();

	/**
	* Ask proxy to prepare render context.
	*/
	void preRender();

	/**
	* Ask proxy to destroy render context.
	*/
	void postRender();
	}
	}		}

packages/SystemUI/src/com/android/systemui/glwallpaper/ImageGLWallpaper.java

+3 −129

Original line number	Original line	Diff line number	Diff line
	@@ -33,7 +33,6 @@ import static android.opengl.GLES20.glUniform1i;
	import static android.opengl.GLES20.glVertexAttribPointer;		import static android.opengl.GLES20.glVertexAttribPointer;

	import android.graphics.Bitmap;		import android.graphics.Bitmap;
	import android.graphics.Rect;
	import android.opengl.GLUtils;		import android.opengl.GLUtils;
	import android.util.Log;		import android.util.Log;

	@@ -50,14 +49,9 @@ import java.nio.FloatBuffer;
	class ImageGLWallpaper {		class ImageGLWallpaper {
	private static final String TAG = ImageGLWallpaper.class.getSimpleName();		private static final String TAG = ImageGLWallpaper.class.getSimpleName();

	static final String A_POSITION = "aPosition";		private static final String A_POSITION = "aPosition";
	static final String A_TEXTURE_COORDINATES = "aTextureCoordinates";		private static final String A_TEXTURE_COORDINATES = "aTextureCoordinates";
	static final String U_PER85 = "uPer85";		private static final String U_TEXTURE = "uTexture";
	static final String U_REVEAL = "uReveal";
	static final String U_AOD2OPACITY = "uAod2Opacity";
	static final String U_TEXTURE = "uTexture";

	private static final int HANDLE_UNDEFINED = -1;
	private static final int POSITION_COMPONENT_COUNT = 2;		private static final int POSITION_COMPONENT_COUNT = 2;
	private static final int TEXTURE_COMPONENT_COUNT = 2;		private static final int TEXTURE_COMPONENT_COUNT = 2;
	private static final int BYTES_PER_FLOAT = 4;		private static final int BYTES_PER_FLOAT = 4;
	@@ -88,14 +82,9 @@ class ImageGLWallpaper {

	private int mAttrPosition;		private int mAttrPosition;
	private int mAttrTextureCoordinates;		private int mAttrTextureCoordinates;
	private int mUniAod2Opacity;
	private int mUniPer85;
	private int mUniReveal;
	private int mUniTexture;		private int mUniTexture;
	private int mTextureId;		private int mTextureId;

	private float[] mCurrentTexCoordinate;

	ImageGLWallpaper(ImageGLProgram program) {		ImageGLWallpaper(ImageGLProgram program) {
	mProgram = program;		mProgram = program;

	@@ -135,31 +124,9 @@ class ImageGLWallpaper {
	}		}

	private void setupUniforms() {		private void setupUniforms() {
	mUniAod2Opacity = mProgram.getUniformHandle(U_AOD2OPACITY);
	mUniPer85 = mProgram.getUniformHandle(U_PER85);
	mUniReveal = mProgram.getUniformHandle(U_REVEAL);
	mUniTexture = mProgram.getUniformHandle(U_TEXTURE);		mUniTexture = mProgram.getUniformHandle(U_TEXTURE);
	}		}

	int getHandle(String name) {
	switch (name) {
	case A_POSITION:
	return mAttrPosition;
	case A_TEXTURE_COORDINATES:
	return mAttrTextureCoordinates;
	case U_AOD2OPACITY:
	return mUniAod2Opacity;
	case U_PER85:
	return mUniPer85;
	case U_REVEAL:
	return mUniReveal;
	case U_TEXTURE:
	return mUniTexture;
	default:
	return HANDLE_UNDEFINED;
	}
	}

	void draw() {		void draw() {
	glDrawArrays(GL_TRIANGLES, 0, VERTICES.length / 2);		glDrawArrays(GL_TRIANGLES, 0, VERTICES.length / 2);
	}		}
	@@ -200,87 +167,6 @@ class ImageGLWallpaper {
	glUniform1i(mUniTexture, 0);		glUniform1i(mUniTexture, 0);
	}		}

	/**
	* This method adjust s(x-axis), t(y-axis) texture coordinates to get current display area
	* of texture and will be used during transition.
	* The adjustment happens if either the width or height of the surface is larger than
	* corresponding size of the display area.
	* If both width and height are larger than corresponding size of the display area,
	* the adjustment will happen at both s, t side.
	*
	* @param surface The size of the surface.
	* @param scissor The display area.
	* @param xOffset The offset amount along s axis.
	* @param yOffset The offset amount along t axis.
	*/
	void adjustTextureCoordinates(Rect surface, Rect scissor, float xOffset, float yOffset) {
	mCurrentTexCoordinate = TEXTURES.clone();

	if (surface == null \|\| scissor == null) {
	mTextureBuffer.put(mCurrentTexCoordinate);
	mTextureBuffer.position(0);
	return;
	}

	int surfaceWidth = surface.width();
	int surfaceHeight = surface.height();
	int scissorWidth = scissor.width();
	int scissorHeight = scissor.height();

	if (surfaceWidth > scissorWidth) {
	// Calculate the new s pos in pixels.
	float pixelS = (float) Math.round((surfaceWidth - scissorWidth) * xOffset);
	// Calculate the s pos in texture coordinate.
	float coordinateS = pixelS / surfaceWidth;
	// Calculate the percentage occupied by the scissor width in surface width.
	float surfacePercentageW = (float) scissorWidth / surfaceWidth;
	// Need also consider the case if surface height is smaller than scissor height.
	if (surfaceHeight < scissorHeight) {
	// We will narrow the surface percentage to keep aspect ratio.
	surfacePercentageW *= (float) surfaceHeight / scissorHeight;
	}
	// Determine the final s pos, also limit the legal s pos to prevent from out of range.
	float s = coordinateS + surfacePercentageW > 1f ? 1f - surfacePercentageW : coordinateS;
	// Traverse the s pos in texture coordinates array and adjust the s pos accordingly.
	for (int i = 0; i < mCurrentTexCoordinate.length; i += 2) {
	// indices 2, 4 and 6 are the end of s coordinates.
	if (i == 2 \|\| i == 4 \|\| i == 6) {
	mCurrentTexCoordinate[i] = Math.min(1f, s + surfacePercentageW);
	} else {
	mCurrentTexCoordinate[i] = s;
	}
	}
	}

	if (surfaceHeight > scissorHeight) {
	// Calculate the new t pos in pixels.
	float pixelT = (float) Math.round((surfaceHeight - scissorHeight) * yOffset);
	// Calculate the t pos in texture coordinate.
	float coordinateT = pixelT / surfaceHeight;
	// Calculate the percentage occupied by the scissor height in surface height.
	float surfacePercentageH = (float) scissorHeight / surfaceHeight;
	// Need also consider the case if surface width is smaller than scissor width.
	if (surfaceWidth < scissorWidth) {
	// We will narrow the surface percentage to keep aspect ratio.
	surfacePercentageH *= (float) surfaceWidth / scissorWidth;
	}
	// Determine the final t pos, also limit the legal t pos to prevent from out of range.
	float t = coordinateT + surfacePercentageH > 1f ? 1f - surfacePercentageH : coordinateT;
	// Traverse the t pos in texture coordinates array and adjust the t pos accordingly.
	for (int i = 1; i < mCurrentTexCoordinate.length; i += 2) {
	// indices 1, 3 and 11 are the end of t coordinates.
	if (i == 1 \|\| i == 3 \|\| i == 11) {
	mCurrentTexCoordinate[i] = Math.min(1f, t + surfacePercentageH);
	} else {
	mCurrentTexCoordinate[i] = t;
	}
	}
	}

	mTextureBuffer.put(mCurrentTexCoordinate);
	mTextureBuffer.position(0);
	}

	/**		/**
	* Called to dump current state.		* Called to dump current state.
	* @param prefix prefix.		* @param prefix prefix.
	@@ -289,17 +175,5 @@ class ImageGLWallpaper {
	* @param args args.		* @param args args.
	*/		*/
	public void dump(String prefix, FileDescriptor fd, PrintWriter out, String[] args) {		public void dump(String prefix, FileDescriptor fd, PrintWriter out, String[] args) {
	StringBuilder sb = new StringBuilder();
	sb.append('{');
	if (mCurrentTexCoordinate != null) {
	for (int i = 0; i < mCurrentTexCoordinate.length; i++) {
	sb.append(mCurrentTexCoordinate[i]).append(',');
	if (i == mCurrentTexCoordinate.length - 1) {
	sb.deleteCharAt(sb.length() - 1);
	}
	}
	}
	sb.append('}');
	out.print(prefix); out.print("mTexCoordinates="); out.println(sb.toString());
	}		}
	}		}

packages/SystemUI/src/com/android/systemui/glwallpaper/ImageProcessHelper.java

deleted100644 → 0

+0 −246

File deleted.

Preview size limit exceeded, changes collapsed.