| /* |
| * Copyright (C) 2014 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. |
| */ |
| |
| package com.android.server.wm; |
| |
| import android.graphics.PixelFormat; |
| import android.graphics.Rect; |
| import android.os.SystemClock; |
| import android.util.Slog; |
| import android.view.DisplayInfo; |
| import android.view.SurfaceControl; |
| |
| import java.io.PrintWriter; |
| |
| public class DimLayer { |
| private static final String TAG = "DimLayer"; |
| private static final boolean DEBUG = false; |
| |
| /** Reference to the owner of this object. */ |
| final DisplayContent mDisplayContent; |
| |
| /** Actual surface that dims */ |
| SurfaceControl mDimSurface; |
| |
| /** Last value passed to mDimSurface.setAlpha() */ |
| float mAlpha = 0; |
| |
| /** Last value passed to mDimSurface.setLayer() */ |
| int mLayer = -1; |
| |
| /** Next values to pass to mDimSurface.setPosition() and mDimSurface.setSize() */ |
| Rect mBounds = new Rect(); |
| |
| /** Last values passed to mDimSurface.setPosition() and mDimSurface.setSize() */ |
| Rect mLastBounds = new Rect(); |
| |
| /** True after mDimSurface.show() has been called, false after mDimSurface.hide(). */ |
| private boolean mShowing = false; |
| |
| /** Value of mAlpha when beginning transition to mTargetAlpha */ |
| float mStartAlpha = 0; |
| |
| /** Final value of mAlpha following transition */ |
| float mTargetAlpha = 0; |
| |
| /** Time in units of SystemClock.uptimeMillis() at which the current transition started */ |
| long mStartTime; |
| |
| /** Time in milliseconds to take to transition from mStartAlpha to mTargetAlpha */ |
| long mDuration; |
| |
| /** Owning stack */ |
| final TaskStack mStack; |
| |
| DimLayer(WindowManagerService service, TaskStack stack, DisplayContent displayContent) { |
| mStack = stack; |
| mDisplayContent = displayContent; |
| final int displayId = mDisplayContent.getDisplayId(); |
| if (DEBUG) Slog.v(TAG, "Ctor: displayId=" + displayId); |
| SurfaceControl.openTransaction(); |
| try { |
| if (WindowManagerService.DEBUG_SURFACE_TRACE) { |
| mDimSurface = new WindowStateAnimator.SurfaceTrace(service.mFxSession, |
| "DimSurface", |
| 16, 16, PixelFormat.OPAQUE, |
| SurfaceControl.FX_SURFACE_DIM | SurfaceControl.HIDDEN); |
| } else { |
| mDimSurface = new SurfaceControl(service.mFxSession, TAG, |
| 16, 16, PixelFormat.OPAQUE, |
| SurfaceControl.FX_SURFACE_DIM | SurfaceControl.HIDDEN); |
| } |
| if (WindowManagerService.SHOW_TRANSACTIONS || |
| WindowManagerService.SHOW_SURFACE_ALLOC) Slog.i(TAG, |
| " DIM " + mDimSurface + ": CREATE"); |
| mDimSurface.setLayerStack(displayId); |
| } catch (Exception e) { |
| Slog.e(WindowManagerService.TAG, "Exception creating Dim surface", e); |
| } finally { |
| SurfaceControl.closeTransaction(); |
| } |
| } |
| |
| /** Return true if dim layer is showing */ |
| boolean isDimming() { |
| return mTargetAlpha != 0; |
| } |
| |
| /** Return true if in a transition period */ |
| boolean isAnimating() { |
| return mTargetAlpha != mAlpha; |
| } |
| |
| float getTargetAlpha() { |
| return mTargetAlpha; |
| } |
| |
| void setLayer(int layer) { |
| if (mLayer != layer) { |
| mLayer = layer; |
| mDimSurface.setLayer(layer); |
| } |
| } |
| |
| int getLayer() { |
| return mLayer; |
| } |
| |
| private void setAlpha(float alpha) { |
| if (mAlpha != alpha) { |
| if (DEBUG) Slog.v(TAG, "setAlpha alpha=" + alpha); |
| try { |
| mDimSurface.setAlpha(alpha); |
| if (alpha == 0 && mShowing) { |
| if (DEBUG) Slog.v(TAG, "setAlpha hiding"); |
| mDimSurface.hide(); |
| mShowing = false; |
| } else if (alpha > 0 && !mShowing) { |
| if (DEBUG) Slog.v(TAG, "setAlpha showing"); |
| mDimSurface.show(); |
| mShowing = true; |
| } |
| } catch (RuntimeException e) { |
| Slog.w(TAG, "Failure setting alpha immediately", e); |
| } |
| mAlpha = alpha; |
| } |
| } |
| |
| /** |
| * @param layer The new layer value. |
| * @param inTransaction Whether the call is made within a surface transaction. |
| */ |
| void adjustSurface(int layer, boolean inTransaction) { |
| final int dw, dh; |
| final float xPos, yPos; |
| if (!mStack.isFullscreen()) { |
| dw = mBounds.width(); |
| dh = mBounds.height(); |
| xPos = mBounds.left; |
| yPos = mBounds.top; |
| } else { |
| // Set surface size to screen size. |
| final DisplayInfo info = mDisplayContent.getDisplayInfo(); |
| // Multiply by 1.5 so that rotating a frozen surface that includes this does not expose |
| // a corner. |
| dw = (int) (info.logicalWidth * 1.5); |
| dh = (int) (info.logicalHeight * 1.5); |
| // back off position so 1/4 of Surface is before and 1/4 is after. |
| xPos = -1 * dw / 6; |
| yPos = -1 * dh / 6; |
| } |
| |
| try { |
| if (!inTransaction) { |
| SurfaceControl.openTransaction(); |
| } |
| mDimSurface.setPosition(xPos, yPos); |
| mDimSurface.setSize(dw, dh); |
| mDimSurface.setLayer(layer); |
| } catch (RuntimeException e) { |
| Slog.w(TAG, "Failure setting size or layer", e); |
| } finally { |
| if (!inTransaction) { |
| SurfaceControl.closeTransaction(); |
| } |
| } |
| mLastBounds.set(mBounds); |
| mLayer = layer; |
| } |
| |
| // Assumes that surface transactions are currently closed. |
| void setBounds(Rect bounds) { |
| mBounds.set(bounds); |
| if (isDimming() && !mLastBounds.equals(bounds)) { |
| adjustSurface(mLayer, false); |
| } |
| } |
| |
| /** |
| * @param duration The time to test. |
| * @return True if the duration would lead to an earlier end to the current animation. |
| */ |
| private boolean durationEndsEarlier(long duration) { |
| return SystemClock.uptimeMillis() + duration < mStartTime + mDuration; |
| } |
| |
| /** Jump to the end of the animation. |
| * NOTE: Must be called with Surface transaction open. */ |
| void show() { |
| if (isAnimating()) { |
| if (DEBUG) Slog.v(TAG, "show: immediate"); |
| show(mLayer, mTargetAlpha, 0); |
| } |
| } |
| |
| /** |
| * Begin an animation to a new dim value. |
| * NOTE: Must be called with Surface transaction open. |
| * |
| * @param layer The layer to set the surface to. |
| * @param alpha The dim value to end at. |
| * @param duration How long to take to get there in milliseconds. |
| */ |
| void show(int layer, float alpha, long duration) { |
| if (DEBUG) Slog.v(TAG, "show: layer=" + layer + " alpha=" + alpha |
| + " duration=" + duration); |
| if (mDimSurface == null) { |
| Slog.e(TAG, "show: no Surface"); |
| // Make sure isAnimating() returns false. |
| mTargetAlpha = mAlpha = 0; |
| return; |
| } |
| |
| if (!mLastBounds.equals(mBounds) || mLayer != layer) { |
| adjustSurface(layer, true); |
| } |
| |
| long curTime = SystemClock.uptimeMillis(); |
| final boolean animating = isAnimating(); |
| if ((animating && (mTargetAlpha != alpha || durationEndsEarlier(duration))) |
| || (!animating && mAlpha != alpha)) { |
| if (duration <= 0) { |
| // No animation required, just set values. |
| setAlpha(alpha); |
| } else { |
| // Start or continue animation with new parameters. |
| mStartAlpha = mAlpha; |
| mStartTime = curTime; |
| mDuration = duration; |
| } |
| } |
| if (DEBUG) Slog.v(TAG, "show: mStartAlpha=" + mStartAlpha + " mStartTime=" + mStartTime); |
| mTargetAlpha = alpha; |
| } |
| |
| /** Immediate hide. |
| * NOTE: Must be called with Surface transaction open. */ |
| void hide() { |
| if (mShowing) { |
| if (DEBUG) Slog.v(TAG, "hide: immediate"); |
| hide(0); |
| } |
| } |
| |
| /** |
| * Gradually fade to transparent. |
| * NOTE: Must be called with Surface transaction open. |
| * |
| * @param duration Time to fade in milliseconds. |
| */ |
| void hide(long duration) { |
| if (mShowing && (mTargetAlpha != 0 || durationEndsEarlier(duration))) { |
| if (DEBUG) Slog.v(TAG, "hide: duration=" + duration); |
| show(mLayer, 0, duration); |
| } |
| } |
| |
| /** |
| * Advance the dimming per the last #show(int, float, long) call. |
| * NOTE: Must be called with Surface transaction open. |
| * |
| * @return True if animation is still required after this step. |
| */ |
| boolean stepAnimation() { |
| if (mDimSurface == null) { |
| Slog.e(TAG, "stepAnimation: null Surface"); |
| // Ensure that isAnimating() returns false; |
| mTargetAlpha = mAlpha = 0; |
| return false; |
| } |
| |
| if (isAnimating()) { |
| final long curTime = SystemClock.uptimeMillis(); |
| final float alphaDelta = mTargetAlpha - mStartAlpha; |
| float alpha = mStartAlpha + alphaDelta * (curTime - mStartTime) / mDuration; |
| if (alphaDelta > 0 && alpha > mTargetAlpha || |
| alphaDelta < 0 && alpha < mTargetAlpha) { |
| // Don't exceed limits. |
| alpha = mTargetAlpha; |
| } |
| if (DEBUG) Slog.v(TAG, "stepAnimation: curTime=" + curTime + " alpha=" + alpha); |
| setAlpha(alpha); |
| } |
| |
| return isAnimating(); |
| } |
| |
| /** Cleanup */ |
| void destroySurface() { |
| if (DEBUG) Slog.v(TAG, "destroySurface."); |
| if (mDimSurface != null) { |
| mDimSurface.destroy(); |
| mDimSurface = null; |
| } |
| } |
| |
| public void printTo(String prefix, PrintWriter pw) { |
| pw.print(prefix); pw.print("mDimSurface="); pw.print(mDimSurface); |
| pw.print(" mLayer="); pw.print(mLayer); |
| pw.print(" mAlpha="); pw.println(mAlpha); |
| pw.print(prefix); pw.print("mLastBounds="); pw.print(mLastBounds.toShortString()); |
| pw.print(" mBounds="); pw.println(mBounds.toShortString()); |
| pw.print(prefix); pw.print("Last animation: "); |
| pw.print(" mDuration="); pw.print(mDuration); |
| pw.print(" mStartTime="); pw.print(mStartTime); |
| pw.print(" curTime="); pw.println(SystemClock.uptimeMillis()); |
| pw.print(prefix); pw.print(" mStartAlpha="); pw.print(mStartAlpha); |
| pw.print(" mTargetAlpha="); pw.println(mTargetAlpha); |
| } |
| } |