Examples with DisplayListCanvas android.view.DisplayListCanvas used on opensource projects

Example 16 with DisplayListCanvas

use of android.view.DisplayListCanvas in project android_frameworks_base by crdroidandroid.

the class LockPatternView method onDraw.

@Override
protected void onDraw(Canvas canvas) {
    final ArrayList<Cell> pattern = mPattern;
    final int count = pattern.size();
    final boolean[][] drawLookup = mPatternDrawLookup;
    if (mPatternDisplayMode == DisplayMode.Animate) {
        // figure out which circles to draw
        // + 1 so we pause on complete pattern
        final int oneCycle = (count + 1) * MILLIS_PER_CIRCLE_ANIMATING;
        final int spotInCycle = (int) (SystemClock.elapsedRealtime() - mAnimatingPeriodStart) % oneCycle;
        final int numCircles = spotInCycle / MILLIS_PER_CIRCLE_ANIMATING;
        clearPatternDrawLookup();
        for (int i = 0; i < numCircles; i++) {
            final Cell cell = pattern.get(i);
            drawLookup[cell.getRow()][cell.getColumn()] = true;
        }
        // figure out in progress portion of ghosting line
        final boolean needToUpdateInProgressPoint = numCircles > 0 && numCircles < count;
        if (needToUpdateInProgressPoint) {
            final float percentageOfNextCircle = ((float) (spotInCycle % MILLIS_PER_CIRCLE_ANIMATING)) / MILLIS_PER_CIRCLE_ANIMATING;
            final Cell currentCell = pattern.get(numCircles - 1);
            final float centerX = getCenterXForColumn(currentCell.column);
            final float centerY = getCenterYForRow(currentCell.row);
            final Cell nextCell = pattern.get(numCircles);
            final float dx = percentageOfNextCircle * (getCenterXForColumn(nextCell.column) - centerX);
            final float dy = percentageOfNextCircle * (getCenterYForRow(nextCell.row) - centerY);
            mInProgressX = centerX + dx;
            mInProgressY = centerY + dy;
        }
        // TODO: Infinite loop here...
        invalidate();
    }
    final Path currentPath = mCurrentPath;
    currentPath.rewind();
    // draw the circles
    if (mVisibleDots) {
        for (int i = 0; i < mPatternSize; i++) {
            float centerY = getCenterYForRow(i);
            for (int j = 0; j < mPatternSize; j++) {
                CellState cellState = mCellStates[i][j];
                float centerX = getCenterXForColumn(j);
                float translationY = cellState.translationY;
                if (mUseLockPatternDrawable) {
                    drawCellDrawable(canvas, i, j, cellState.radius, drawLookup[i][j]);
                } else {
                    if (isHardwareAccelerated() && cellState.hwAnimating) {
                        DisplayListCanvas displayListCanvas = (DisplayListCanvas) canvas;
                        displayListCanvas.drawCircle(cellState.hwCenterX, cellState.hwCenterY, cellState.hwRadius, cellState.hwPaint);
                    } else {
                        drawCircle(canvas, (int) centerX, (int) centerY + translationY, cellState.radius, drawLookup[i][j], cellState.alpha);
                    }
                }
            }
        }
    }
    // TODO: the path should be created and cached every time we hit-detect a cell
    // only the last segment of the path should be computed here
    // draw the path of the pattern (unless we are in stealth mode)
    final boolean drawPath = ((!mInStealthMode && mPatternDisplayMode != DisplayMode.Wrong) || (mPatternDisplayMode == DisplayMode.Wrong && mShowErrorPath));
    if (drawPath) {
        mPathPaint.setColor(getCurrentColor(true));
        boolean anyCircles = false;
        float lastX = 0f;
        float lastY = 0f;
        for (int i = 0; i < count; i++) {
            Cell cell = pattern.get(i);
            // of animation).
            if (!drawLookup[cell.row][cell.column]) {
                break;
            }
            anyCircles = true;
            float centerX = getCenterXForColumn(cell.column);
            float centerY = getCenterYForRow(cell.row);
            if (i != 0) {
                CellState state = mCellStates[cell.row][cell.column];
                currentPath.rewind();
                currentPath.moveTo(lastX, lastY);
                if (state.lineEndX != Float.MIN_VALUE && state.lineEndY != Float.MIN_VALUE) {
                    currentPath.lineTo(state.lineEndX, state.lineEndY);
                } else {
                    currentPath.lineTo(centerX, centerY);
                }
                canvas.drawPath(currentPath, mPathPaint);
            }
            lastX = centerX;
            lastY = centerY;
        }
        // draw last in progress section
        if ((mPatternInProgress || mPatternDisplayMode == DisplayMode.Animate) && anyCircles) {
            currentPath.rewind();
            currentPath.moveTo(lastX, lastY);
            currentPath.lineTo(mInProgressX, mInProgressY);
            mPathPaint.setAlpha((int) (calculateLastSegmentAlpha(mInProgressX, mInProgressY, lastX, lastY) * 255f));
            canvas.drawPath(currentPath, mPathPaint);
        }
    }
}

Example 17 with DisplayListCanvas

use of android.view.DisplayListCanvas in project android_frameworks_base by crdroidandroid.

the class KeyguardAffordanceView method drawBackgroundCircle.

private void drawBackgroundCircle(Canvas canvas) {
    if (mCircleRadius > 0 || mFinishing) {
        if (mFinishing && mSupportHardware && mHwCenterX != null) {
            // Our hardware drawing proparties can be null if the finishing started but we have
            // never drawn before. In that case we are not doing a render thread animation
            // anyway, so we need to use the normal drawing.
            DisplayListCanvas displayListCanvas = (DisplayListCanvas) canvas;
            displayListCanvas.drawCircle(mHwCenterX, mHwCenterY, mHwCircleRadius, mHwCirclePaint);
        } else {
            updateCircleColor();
            canvas.drawCircle(mCenterX, mCenterY, mCircleRadius, mCirclePaint);
        }
    }
}

Example 18 with DisplayListCanvas

use of android.view.DisplayListCanvas in project android_frameworks_base by crdroidandroid.

the class RippleComponent method draw.

/**
     * Draws the ripple to the canvas, inheriting the paint's color and alpha
     * properties.
     *
     * @param c the canvas to which the ripple should be drawn
     * @param p the paint used to draw the ripple
     * @return {@code true} if something was drawn, {@code false} otherwise
     */
public boolean draw(Canvas c, Paint p) {
    final boolean hasDisplayListCanvas = !mForceSoftware && c.isHardwareAccelerated() && c instanceof DisplayListCanvas;
    if (mHasDisplayListCanvas != hasDisplayListCanvas) {
        mHasDisplayListCanvas = hasDisplayListCanvas;
        if (!hasDisplayListCanvas) {
            // We've switched from hardware to non-hardware mode. Panic.
            endHardwareAnimations();
        }
    }
    if (hasDisplayListCanvas) {
        final DisplayListCanvas hw = (DisplayListCanvas) c;
        startPendingAnimation(hw, p);
        if (mHardwareAnimator != null) {
            return drawHardware(hw);
        }
    }
    return drawSoftware(c, p);
}

Example 19 with DisplayListCanvas

use of android.view.DisplayListCanvas in project android_frameworks_base by crdroidandroid.

the class BackdropFrameRenderer method drawColorViews.

private void drawColorViews(int left, int top, int width, int height, boolean fullscreen, Rect systemInsets, Rect stableInsets) {
    if (mSystemBarBackgroundNode == null) {
        return;
    }
    DisplayListCanvas canvas = mSystemBarBackgroundNode.start(width, height);
    mSystemBarBackgroundNode.setLeftTopRightBottom(left, top, left + width, top + height);
    final int topInset = DecorView.getColorViewTopInset(mStableInsets.top, mSystemInsets.top);
    final int bottomInset = DecorView.getColorViewBottomInset(stableInsets.bottom, systemInsets.bottom);
    final int rightInset = DecorView.getColorViewRightInset(stableInsets.right, systemInsets.right);
    final int leftInset = DecorView.getColorViewLeftInset(stableInsets.left, systemInsets.left);
    if (mStatusBarColor != null) {
        mStatusBarColor.setBounds(0, 0, left + width, topInset);
        mStatusBarColor.draw(canvas);
    }
    // However, we need it for the transitions into/out of docked mode.
    if (mNavigationBarColor != null && fullscreen) {
        final int size = DecorView.getNavBarSize(bottomInset, rightInset, leftInset);
        if (DecorView.isNavBarToRightEdge(bottomInset, rightInset)) {
            mNavigationBarColor.setBounds(width - size, 0, width, height);
        } else if (DecorView.isNavBarToLeftEdge(bottomInset, leftInset)) {
            mNavigationBarColor.setBounds(0, 0, size, height);
        } else {
            mNavigationBarColor.setBounds(0, height - size, width, height);
        }
        mNavigationBarColor.draw(canvas);
    }
    mSystemBarBackgroundNode.end(canvas);
    mRenderer.drawRenderNode(mSystemBarBackgroundNode);
}

Example 20 with DisplayListCanvas

use of android.view.DisplayListCanvas in project android_frameworks_base by crdroidandroid.

the class BackdropFrameRenderer method redrawLocked.

/**
     * Redraws the background, the caption and the system inset backgrounds if something changed.
     *
     * @param newBounds The window bounds which needs to be drawn.
     * @param fullscreen Whether the window is currently drawing in fullscreen.
     * @param systemInsets The current visible system insets for the window.
     * @param stableInsets The stable insets for the window.
     */
private void redrawLocked(Rect newBounds, boolean fullscreen, Rect systemInsets, Rect stableInsets) {
    // 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.
    final int captionHeight = mDecorView.getCaptionHeight();
    // Once set to something other then 0 it should be kept that way.
    if (captionHeight != 0) {
        // Remember the height of the caption.
        mLastCaptionHeight = captionHeight;
    }
    // content. If any size is 0, we have to wait for it to be drawn first.
    if ((mLastCaptionHeight == 0 && mDecorView.isShowingCaption()) || 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);
    final Drawable drawable = mUserCaptionBackgroundDrawable != null ? mUserCaptionBackgroundDrawable : mCaptionBackgroundDrawable;
    if (drawable != null) {
        drawable.setBounds(0, 0, left + width, top + mLastCaptionHeight);
        drawable.draw(canvas);
    }
    // The backdrop: clear everything with the background. Clipping is done elsewhere.
    if (mResizingBackgroundDrawable != null) {
        mResizingBackgroundDrawable.setBounds(0, mLastCaptionHeight, left + width, top + height);
        mResizingBackgroundDrawable.draw(canvas);
    }
    mFrameAndBackdropNode.end(canvas);
    drawColorViews(left, top, width, height, fullscreen, systemInsets, stableInsets);
    // We need to render the node explicitly
    mRenderer.drawRenderNode(mFrameAndBackdropNode);
    reportDrawIfNeeded();
}