internal/policy/BackdropFrameRenderer.java

/*
 * Copyright (C) 2015 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.internal.policy;

import com.android.internal.widget.NonClientDecorView;

import android.graphics.Rect;
import android.graphics.drawable.Drawable;
import android.os.Looper;
import android.view.Choreographer;
import android.view.DisplayListCanvas;
import android.view.RenderNode;
import android.view.ThreadedRenderer;
import android.view.View;

/**
 * The thread which draws a fill in background while the app is resizing in areas where the app
 * content draw is lagging behind the resize operation.
 * It starts with the creation and it ends once someone calls destroy().
 * Any size changes can be passed by a call to setTargetRect will passed to the thread and
 * executed via the Choreographer.
 * @hide
 */
public class BackdropFrameRenderer extends Thread implements Choreographer.FrameCallback {

    private NonClientDecorView mNonClientDecorView;

    // This is containing the last requested size by a resize command. Note that this size might
    // or might not have been applied to the output already.
    private final Rect mTargetRect = new Rect();

    // The render nodes for the multi threaded renderer.
    private ThreadedRenderer mRenderer;
    private RenderNode mFrameAndBackdropNode;

    private final Rect mOldTargetRect = new Rect();
    private final Rect mNewTargetRect = new Rect();
    private Choreographer mChoreographer;

    // Cached size values from the last render for the case that the view hierarchy is gone
    // during a configuration change.
    private int mLastContentWidth;
    private int mLastContentHeight;
    private int mLastCaptionHeight;
    private int mLastXOffset;
    private int mLastYOffset;

    // Whether to report when next frame is drawn or not.
    private boolean mReportNextDraw;

    public BackdropFrameRenderer(NonClientDecorView nonClientDecorView,
            ThreadedRenderer renderer,
            Rect initialBounds) {
        mNonClientDecorView = nonClientDecorView;
        setName("ResizeFrame");
        mRenderer = renderer;

        // Create a render node for the content and frame backdrop
        // which can be resized independently from the content.
        mFrameAndBackdropNode = RenderNode.create("FrameAndBackdropNode", null);

        mRenderer.addRenderNode(mFrameAndBackdropNode, true);

        // Set the initial bounds and draw once so that we do not get a broken frame.
        mTargetRect.set(initialBounds);
        synchronized (this) {
            changeWindowSizeLocked(initialBounds);
        }

        // Kick off our draw thread.
        start();
    }

    /**
     * Call this function asynchronously when the window size has been changed. The change will
     * be picked up once per frame and the frame will be re-rendered accordingly.
     * @param newTargetBounds The new target bounds.
     */
    public void setTargetRect(Rect newTargetBounds) {
        synchronized (this) {
            mTargetRect.set(newTargetBounds);
            // Notify of a bounds change.
            pingRenderLocked();
        }
    }

    /**
     * The window got replaced due to a configuration change.
     */
    public void onConfigurationChange() {
        synchronized (this) {
            if (mRenderer != null) {
                // Enforce a window redraw.
                mOldTargetRect.set(0, 0, 0, 0);
                pingRenderLocked();
            }
        }
    }

    /**
     * All resources of the renderer will be released. This function can be called from the
     * the UI thread as well as the renderer thread.
     */
    public void releaseRenderer() {
        synchronized (this) {
            if (mRenderer != null) {
                // Invalidate the current content bounds.
                mRenderer.setContentDrawBounds(0, 0, 0, 0);

                // Remove the render node again
                // (see comment above - better to do that only once).
                mRenderer.removeRenderNode(mFrameAndBackdropNode);

                mRenderer = null;

                // Exit the renderer loop.
                pingRenderLocked();
            }
        }
    }

    @Override
    public void run() {
        try {
            Looper.prepare();
            synchronized (this) {
                mChoreographer = Choreographer.getInstance();

                // Draw at least once.
                mChoreographer.postFrameCallback(this);
            }
            Looper.loop();
        } finally {
            releaseRenderer();
        }
        synchronized (this) {
            // Make sure no more messages are being sent.
            mChoreographer = null;
        }
    }

    /**
     * The implementation of the FrameCallback.
     * @param frameTimeNanos The time in nanoseconds when the frame started being rendered,
     * in the {@link System#nanoTime()} timebase.  Divide this value by {@code 1000000}
     */
    @Override
    public void doFrame(long frameTimeNanos) {
        synchronized (this) {
            if (mRenderer == null) {
                reportDrawIfNeeded();
                // Tell the looper to stop. We are done.
                Looper.myLooper().quit();
                return;
            }
            mNewTargetRect.set(mTargetRect);
            if (!mNewTargetRect.equals(mOldTargetRect) || mReportNextDraw) {
                mOldTargetRect.set(mNewTargetRect);
                changeWindowSizeLocked(mNewTargetRect);
            }
        }
    }

    /**
     * The content is about to be drawn and we got the location of where it will be shown.
     * If a "changeWindowSizeLocked" call has already been processed, we will re-issue the call
     * if the previous call was ignored since the size was unknown.
     * @param xOffset The x offset where the content is drawn to.
     * @param yOffset The y offset where the content is drawn to.
     * @param xSize The width size of the content. This should not be 0.
     * @param ySize The height of the content.
     * @return true if a frame should be requested after the content is drawn; false otherwise.
     */
    public boolean onContentDrawn(int xOffset, int yOffset, int xSize, int ySize) {
        synchronized (this) {
            final boolean firstCall = mLastContentWidth == 0;
            // The current content buffer is drawn here.
            mLastContentWidth = xSize;
            mLastContentHeight = ySize - mLastCaptionHeight;
            mLastXOffset = xOffset;
            mLastYOffset = yOffset;

            mRenderer.setContentDrawBounds(
                    mLastXOffset,
                    mLastYOffset,
                    mLastXOffset + mLastContentWidth,
                    mLastYOffset + mLastCaptionHeight + mLastContentHeight);
            // If this was the first call and changeWindowSizeLocked got already called prior
            // to us, we should re-issue a changeWindowSizeLocked now.
            return firstCall && (mLastCaptionHeight != 0 || !mNonClientDecorView.mShowDecor);
        }
    }

    public void onRequestDraw(boolean reportNextDraw) {
        synchronized (this) {
            mReportNextDraw = reportNextDraw;
            mOldTargetRect.set(0, 0, 0, 0);
            pingRenderLocked();
        }
    }

    /**
     * Resizing the frame to fit the new window size.
     * @param newBounds The window bounds which needs to be drawn.
     */
    private void changeWindowSizeLocked(Rect newBounds) {
        // While a configuration change is taking place the view hierarchy might become
        // inaccessible. For that case we remember the previous metrics to avoid flashes.
        // Note that even when there is no visible caption, the caption child will exist.
        View caption = mNonClientDecorView.getChildAt(0);
        if (caption != null) {
            final int captionHeight = caption.getHeight();
            // The caption height will probably never dynamically change while we are resizing.
            // Once set to something other then 0 it should be kept that way.
            if (captionHeight != 0) {
                // Remember the height of the caption.
                mLastCaptionHeight = captionHeight;
            }
        }
        // Make sure that the other thread has already prepared the render draw calls for the
        // content. If any size is 0, we have to wait for it to be drawn first.
        if ((mLastCaptionHeight == 0 && mNonClientDecorView.mShowDecor) ||
                mLastContentWidth == 0 || mLastContentHeight == 0) {
            return;
        }
        // Since the surface is spanning the entire screen, we have to add the start offset of
        // the bounds to get to the surface location.
        final int left = mLastXOffset + newBounds.left;
        final int top = mLastYOffset + newBounds.top;
        final int width = newBounds.width();
        final int height = newBounds.height();

        mFrameAndBackdropNode.setLeftTopRightBottom(left, top, left + width, top + height);

        // Draw the caption and content backdrops in to our render node.
        DisplayListCanvas canvas = mFrameAndBackdropNode.start(width, height);
        mNonClientDecorView.mCaptionBackgroundDrawable.setBounds(
                0, 0, left + width, top + mLastCaptionHeight);
        mNonClientDecorView.mCaptionBackgroundDrawable.draw(canvas);

        // The backdrop: clear everything with the background. Clipping is done elsewhere.
        mNonClientDecorView.mResizingBackgroundDrawable.setBounds(
                0, mLastCaptionHeight, left + width, top + height);
        mNonClientDecorView.mResizingBackgroundDrawable.draw(canvas);
        mFrameAndBackdropNode.end(canvas);

        // We need to render the node explicitly
        mRenderer.drawRenderNode(mFrameAndBackdropNode);

        reportDrawIfNeeded();
    }

    /**
     * Notify view root that a frame has been drawn by us, if it has requested so.
     */
    private void reportDrawIfNeeded() {
        if (mReportNextDraw) {
            if (mNonClientDecorView.isAttachedToWindow()) {
                mNonClientDecorView.getViewRootImpl().reportDrawFinish();
            }
            mReportNextDraw = false;
        }
    }

    /**
     * Sends a message to the renderer to wake up and perform the next action which can be
     * either the next rendering or the self destruction if mRenderer is null.
     * Note: This call must be synchronized.
     */
    private void pingRenderLocked() {
        if (mChoreographer != null) {
            mChoreographer.postFrameCallback(this);
        }
    }
}