FileDocCategorySizeDatePackage
DimLayer.javaAPI DocAndroid 5.1 API11301Thu Mar 12 22:22:42 GMT 2015com.android.server.wm

DimLayer

public class DimLayer extends Object

Fields Summary
private static final String
TAG
private static final boolean
DEBUG
final DisplayContent
mDisplayContent
Reference to the owner of this object.
android.view.SurfaceControl
mDimSurface
Actual surface that dims
float
mAlpha
Last value passed to mDimSurface.setAlpha()
int
mLayer
Last value passed to mDimSurface.setLayer()
android.graphics.Rect
mBounds
Next values to pass to mDimSurface.setPosition() and mDimSurface.setSize()
android.graphics.Rect
mLastBounds
Last values passed to mDimSurface.setPosition() and mDimSurface.setSize()
private boolean
mShowing
True after mDimSurface.show() has been called, false after mDimSurface.hide().
float
mStartAlpha
Value of mAlpha when beginning transition to mTargetAlpha
float
mTargetAlpha
Final value of mAlpha following transition
long
mStartTime
Time in units of SystemClock.uptimeMillis() at which the current transition started
long
mDuration
Time in milliseconds to take to transition from mStartAlpha to mTargetAlpha
final TaskStack
mStack
Owning stack
Constructors Summary
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();
        }
Methods Summary
voidadjustSurface(int layer, boolean inTransaction)

param
layer The new layer value.
param
inTransaction Whether the call is made within a surface transaction.

        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;
voiddestroySurface()
Cleanup

        if (DEBUG) Slog.v(TAG, "destroySurface.");
        if (mDimSurface != null) {
            mDimSurface.destroy();
            mDimSurface = null;
        }
private booleandurationEndsEarlier(long duration)

param
duration The time to test.
return
True if the duration would lead to an earlier end to the current animation.

        return SystemClock.uptimeMillis() + duration < mStartTime + mDuration;
intgetLayer()

        return mLayer;
floatgetTargetAlpha()

        return mTargetAlpha;
voidhide()
Immediate hide. NOTE: Must be called with Surface transaction open.

        if (mShowing) {
            if (DEBUG) Slog.v(TAG, "hide: immediate");
            hide(0);
        }
voidhide(long duration)
Gradually fade to transparent. NOTE: Must be called with Surface transaction open.

param
duration Time to fade in milliseconds.

        if (mShowing && (mTargetAlpha != 0 || durationEndsEarlier(duration))) {
            if (DEBUG) Slog.v(TAG, "hide: duration=" + duration);
            show(mLayer, 0, duration);
        }
booleanisAnimating()
Return true if in a transition period

        return mTargetAlpha != mAlpha;
booleanisDimming()
Return true if dim layer is showing

        return mTargetAlpha != 0;
public voidprintTo(java.lang.String prefix, java.io.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);
private voidsetAlpha(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;
        }
voidsetBounds(android.graphics.Rect bounds)

        mBounds.set(bounds);
        if (isDimming() && !mLastBounds.equals(bounds)) {
            adjustSurface(mLayer, false);
        }
voidsetLayer(int layer)

        if (mLayer != layer) {
            mLayer = layer;
            mDimSurface.setLayer(layer);
        }
voidshow()
Jump to the end of the animation. NOTE: Must be called with Surface transaction open.

        if (isAnimating()) {
            if (DEBUG) Slog.v(TAG, "show: immediate");
            show(mLayer, mTargetAlpha, 0);
        }
voidshow(int layer, float alpha, long duration)
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.

        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;
booleanstepAnimation()
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.

        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();