android-10.0.0_r47/s

/*
 * Copyright (C) 2016 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 android.view.cts;

import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertNotNull;
import static org.junit.Assert.assertTrue;
import static org.junit.Assert.fail;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;

import android.app.Instrumentation;
import android.content.Context;
import android.content.pm.ActivityInfo;
import android.graphics.Bitmap;
import android.graphics.Bitmap.Config;
import android.graphics.Color;
import android.graphics.ColorSpace;
import android.graphics.Rect;
import android.graphics.SurfaceTexture;
import android.os.Debug;
import android.os.Debug.MemoryInfo;
import android.util.Half;
import android.util.Log;
import android.view.PixelCopy;
import android.view.Surface;
import android.view.View;
import android.view.Window;
import android.view.WindowManager;

import androidx.test.InstrumentationRegistry;
import androidx.test.filters.LargeTest;
import androidx.test.filters.MediumTest;
import androidx.test.rule.ActivityTestRule;
import androidx.test.runner.AndroidJUnit4;

import com.android.compatibility.common.util.SynchronousPixelCopy;

import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.rules.TestRule;
import org.junit.runner.Description;
import org.junit.runner.RunWith;
import org.junit.runners.model.Statement;

import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;

@MediumTest
@RunWith(AndroidJUnit4.class)
public class PixelCopyTest {
    private static final String TAG = "PixelCopyTests";

    @Rule
    public ActivityTestRule<PixelCopyGLProducerCtsActivity> mGLSurfaceViewActivityRule =
            new ActivityTestRule<>(PixelCopyGLProducerCtsActivity.class, false, false);

    @Rule
    public ActivityTestRule<PixelCopyVideoSourceActivity> mVideoSourceActivityRule =
            new ActivityTestRule<>(PixelCopyVideoSourceActivity.class, false, false);

    @Rule
    public ActivityTestRule<PixelCopyViewProducerActivity> mWindowSourceActivityRule =
            new ActivityTestRule<>(PixelCopyViewProducerActivity.class, false, false);

    @Rule
    public ActivityTestRule<PixelCopyWideGamutViewProducerActivity>
            mWideGamutWindowSourceActivityRule = new ActivityTestRule<>(
                    PixelCopyWideGamutViewProducerActivity.class, false, false);

    @Rule
    public ActivityTestRule<PixelCopyViewProducerDialogActivity> mDialogSourceActivityRule =
            new ActivityTestRule<>(PixelCopyViewProducerDialogActivity.class, false, false);

    @Rule
    public SurfaceTextureRule mSurfaceRule = new SurfaceTextureRule();

    private Instrumentation mInstrumentation;
    private SynchronousPixelCopy mCopyHelper;

    @Before
    public void setup() {
        mInstrumentation = InstrumentationRegistry.getInstrumentation();
        assertNotNull(mInstrumentation);
        mCopyHelper = new SynchronousPixelCopy();
    }

    @Test(expected = IllegalArgumentException.class)
    public void testNullDest() {
        Bitmap dest = null;
        mCopyHelper.request(mSurfaceRule.getSurface(), dest);
    }

    @Test(expected = IllegalArgumentException.class)
    public void testRecycledDest() {
        Bitmap dest = Bitmap.createBitmap(5, 5, Config.ARGB_8888);
        dest.recycle();
        mCopyHelper.request(mSurfaceRule.getSurface(), dest);
    }

    @Test
    public void testNoSourceData() {
        Bitmap dest = Bitmap.createBitmap(5, 5, Bitmap.Config.ARGB_8888);
        int result = mCopyHelper.request(mSurfaceRule.getSurface(), dest);
        assertEquals(PixelCopy.ERROR_SOURCE_NO_DATA, result);
    }

    @Test(expected = IllegalArgumentException.class)
    public void testEmptySourceRectSurface() {
        Bitmap dest = Bitmap.createBitmap(5, 5, Bitmap.Config.ARGB_8888);
        mCopyHelper.request(mSurfaceRule.getSurface(), new Rect(), dest);
    }

    @Test(expected = IllegalArgumentException.class)
    public void testEmptySourceRectWindow() {
        Bitmap dest = Bitmap.createBitmap(5, 5, Bitmap.Config.ARGB_8888);
        mCopyHelper.request(mock(Window.class), new Rect(), dest);
    }

    @Test(expected = IllegalArgumentException.class)
    public void testInvalidSourceRectSurface() {
        Bitmap dest = Bitmap.createBitmap(5, 5, Bitmap.Config.ARGB_8888);
        mCopyHelper.request(mSurfaceRule.getSurface(), new Rect(10, 10, 0, 0), dest);
    }

    @Test(expected = IllegalArgumentException.class)
    public void testInvalidSourceRectWindow() {
        Bitmap dest = Bitmap.createBitmap(5, 5, Bitmap.Config.ARGB_8888);
        mCopyHelper.request(mock(Window.class), new Rect(10, 10, 0, 0), dest);
    }

    @Test(expected = IllegalArgumentException.class)
    public void testNoDecorView() {
        Bitmap dest = Bitmap.createBitmap(5, 5, Bitmap.Config.ARGB_8888);
        Window mockWindow = mock(Window.class);
        mCopyHelper.request(mockWindow, dest);
    }

    @Test(expected = IllegalArgumentException.class)
    public void testNoViewRoot() {
        Bitmap dest = Bitmap.createBitmap(5, 5, Bitmap.Config.ARGB_8888);
        Window mockWindow = mock(Window.class);
        View view = new View(mInstrumentation.getTargetContext());
        when(mockWindow.peekDecorView()).thenReturn(view);
        mCopyHelper.request(mockWindow, dest);
    }

    private PixelCopyGLProducerCtsActivity waitForGlProducerActivity() {
        CountDownLatch swapFence = new CountDownLatch(2);

        PixelCopyGLProducerCtsActivity activity =
                mGLSurfaceViewActivityRule.launchActivity(null);
        activity.setSwapFence(swapFence);

        try {
            while (!swapFence.await(5, TimeUnit.MILLISECONDS)) {
                activity.getView().requestRender();
            }
        } catch (InterruptedException ex) {
            fail("Interrupted, error=" + ex.getMessage());
        }
        return activity;
    }

    @Test
    public void testGlProducerFullsize() {
        PixelCopyGLProducerCtsActivity activity = waitForGlProducerActivity();
        Bitmap bitmap = Bitmap.createBitmap(100, 100, Config.ARGB_8888);
        int result = mCopyHelper.request(activity.getView(), bitmap);
        assertEquals("Fullsize copy request failed", PixelCopy.SUCCESS, result);
        assertEquals(100, bitmap.getWidth());
        assertEquals(100, bitmap.getHeight());
        assertEquals(Config.ARGB_8888, bitmap.getConfig());
        assertBitmapQuadColor(bitmap,
                Color.RED, Color.GREEN, Color.BLUE, Color.BLACK);
    }

    @Test
    public void testGlProducerCropTopLeft() {
        PixelCopyGLProducerCtsActivity activity = waitForGlProducerActivity();
        Bitmap bitmap = Bitmap.createBitmap(100, 100, Config.ARGB_8888);
        int result = mCopyHelper.request(activity.getView(), new Rect(0, 0, 50, 50), bitmap);
        assertEquals("Scaled copy request failed", PixelCopy.SUCCESS, result);
        assertBitmapQuadColor(bitmap,
                Color.RED, Color.RED, Color.RED, Color.RED);
    }

    @Test
    public void testGlProducerCropCenter() {
        PixelCopyGLProducerCtsActivity activity = waitForGlProducerActivity();
        Bitmap bitmap = Bitmap.createBitmap(100, 100, Config.ARGB_8888);
        int result = mCopyHelper.request(activity.getView(), new Rect(25, 25, 75, 75), bitmap);
        assertEquals("Scaled copy request failed", PixelCopy.SUCCESS, result);
        assertBitmapQuadColor(bitmap,
                Color.RED, Color.GREEN, Color.BLUE, Color.BLACK);
    }

    @Test
    public void testGlProducerCropBottomHalf() {
        PixelCopyGLProducerCtsActivity activity = waitForGlProducerActivity();
        Bitmap bitmap = Bitmap.createBitmap(100, 100, Config.ARGB_8888);
        int result = mCopyHelper.request(activity.getView(), new Rect(0, 50, 100, 100), bitmap);
        assertEquals("Scaled copy request failed", PixelCopy.SUCCESS, result);
        assertBitmapQuadColor(bitmap,
                Color.BLUE, Color.BLACK, Color.BLUE, Color.BLACK);
    }

    @Test
    public void testGlProducerCropClamping() {
        PixelCopyGLProducerCtsActivity activity = waitForGlProducerActivity();
        Bitmap bitmap = Bitmap.createBitmap(100, 100, Config.ARGB_8888);
        int result = mCopyHelper.request(activity.getView(), new Rect(50, -50, 150, 50), bitmap);
        assertEquals("Scaled copy request failed", PixelCopy.SUCCESS, result);
        assertBitmapQuadColor(bitmap,
                Color.GREEN, Color.GREEN, Color.GREEN, Color.GREEN);
    }

    @Test
    public void testGlProducerScaling() {
        // Since we only sample mid-pixel of each qudrant, filtering
        // quality isn't tested
        PixelCopyGLProducerCtsActivity activity = waitForGlProducerActivity();
        Bitmap bitmap = Bitmap.createBitmap(20, 20, Config.ARGB_8888);
        int result = mCopyHelper.request(activity.getView(), bitmap);
        assertEquals("Scaled copy request failed", PixelCopy.SUCCESS, result);
        // Make sure nothing messed with the bitmap
        assertEquals(20, bitmap.getWidth());
        assertEquals(20, bitmap.getHeight());
        assertEquals(Config.ARGB_8888, bitmap.getConfig());
        assertBitmapQuadColor(bitmap,
                Color.RED, Color.GREEN, Color.BLUE, Color.BLACK);
    }

    @Test
    public void testReuseBitmap() {
        // Since we only sample mid-pixel of each qudrant, filtering
        // quality isn't tested
        PixelCopyGLProducerCtsActivity activity = waitForGlProducerActivity();
        Bitmap bitmap = Bitmap.createBitmap(20, 20, Config.ARGB_8888);
        int result = mCopyHelper.request(activity.getView(), bitmap);
        // Make sure nothing messed with the bitmap
        assertEquals(20, bitmap.getWidth());
        assertEquals(20, bitmap.getHeight());
        assertEquals(Config.ARGB_8888, bitmap.getConfig());
        assertBitmapQuadColor(bitmap,
                Color.RED, Color.GREEN, Color.BLUE, Color.BLACK);
        int generationId = bitmap.getGenerationId();
        result = mCopyHelper.request(activity.getView(), bitmap);
        // Make sure nothing messed with the bitmap
        assertEquals(20, bitmap.getWidth());
        assertEquals(20, bitmap.getHeight());
        assertEquals(Config.ARGB_8888, bitmap.getConfig());
        assertBitmapQuadColor(bitmap,
                Color.RED, Color.GREEN, Color.BLUE, Color.BLACK);
        assertNotEquals(generationId, bitmap.getGenerationId());
    }

    private Window waitForWindowProducerActivity() {
        PixelCopyViewProducerActivity activity =
                mWindowSourceActivityRule.launchActivity(null);
        activity.waitForFirstDrawCompleted(10, TimeUnit.SECONDS);
        return activity.getWindow();
    }

    private Rect makeWindowRect(int left, int top, int right, int bottom) {
        Rect r = new Rect(left, top, right, bottom);
        mWindowSourceActivityRule.getActivity().normalizedToSurface(r);
        return r;
    }

    @Test
    public void testWindowProducer() {
        Bitmap bitmap;
        Window window = waitForWindowProducerActivity();
        PixelCopyViewProducerActivity activity = mWindowSourceActivityRule.getActivity();
        do {
            Rect src = makeWindowRect(0, 0, 100, 100);
            bitmap = Bitmap.createBitmap(src.width(), src.height(), Config.ARGB_8888);
            int result = mCopyHelper.request(window, src, bitmap);
            assertEquals("Fullsize copy request failed", PixelCopy.SUCCESS, result);
            assertEquals(Config.ARGB_8888, bitmap.getConfig());
            assertBitmapQuadColor(bitmap,
                    Color.RED, Color.GREEN, Color.BLUE, Color.BLACK);
            assertBitmapEdgeColor(bitmap, Color.YELLOW);
        } while (activity.rotate());
    }

    @Test
    public void testWindowProducerCropTopLeft() {
        Window window = waitForWindowProducerActivity();
        Bitmap bitmap = Bitmap.createBitmap(100, 100, Config.ARGB_8888);
        PixelCopyViewProducerActivity activity = mWindowSourceActivityRule.getActivity();
        do {
            int result = mCopyHelper.request(window, makeWindowRect(0, 0, 50, 50), bitmap);
            assertEquals("Scaled copy request failed", PixelCopy.SUCCESS, result);
            assertBitmapQuadColor(bitmap,
                    Color.RED, Color.RED, Color.RED, Color.RED);
        } while (activity.rotate());
    }

    @Test
    public void testWindowProducerCropCenter() {
        Window window = waitForWindowProducerActivity();
        Bitmap bitmap = Bitmap.createBitmap(100, 100, Config.ARGB_8888);
        PixelCopyViewProducerActivity activity = mWindowSourceActivityRule.getActivity();
        do {
            int result = mCopyHelper.request(window, makeWindowRect(25, 25, 75, 75), bitmap);
            assertEquals("Scaled copy request failed", PixelCopy.SUCCESS, result);
            assertBitmapQuadColor(bitmap,
                    Color.RED, Color.GREEN, Color.BLUE, Color.BLACK);
        } while (activity.rotate());
    }

    @Test
    public void testWindowProducerCropBottomHalf() {
        Window window = waitForWindowProducerActivity();
        Bitmap bitmap = Bitmap.createBitmap(100, 100, Config.ARGB_8888);
        PixelCopyViewProducerActivity activity = mWindowSourceActivityRule.getActivity();
        do {
            int result = mCopyHelper.request(window, makeWindowRect(0, 50, 100, 100), bitmap);
            assertEquals("Scaled copy request failed", PixelCopy.SUCCESS, result);
            assertBitmapQuadColor(bitmap,
                    Color.BLUE, Color.BLACK, Color.BLUE, Color.BLACK);
        } while (activity.rotate());
    }

    @Test
    public void testWindowProducerScaling() {
        // Since we only sample mid-pixel of each qudrant, filtering
        // quality isn't tested
        Window window = waitForWindowProducerActivity();
        Bitmap bitmap = Bitmap.createBitmap(20, 20, Config.ARGB_8888);
        PixelCopyViewProducerActivity activity = mWindowSourceActivityRule.getActivity();
        do {
            int result = mCopyHelper.request(window, bitmap);
            assertEquals("Scaled copy request failed", PixelCopy.SUCCESS, result);
            // Make sure nothing messed with the bitmap
            assertEquals(20, bitmap.getWidth());
            assertEquals(20, bitmap.getHeight());
            assertEquals(Config.ARGB_8888, bitmap.getConfig());
            assertBitmapQuadColor(bitmap,
                    Color.RED, Color.GREEN, Color.BLUE, Color.BLACK);
        } while (activity.rotate());
    }

    @Test
    public void testWindowProducerCopyToRGBA16F() {
        Window window = waitForWindowProducerActivity();
        PixelCopyViewProducerActivity activity = mWindowSourceActivityRule.getActivity();

        Bitmap bitmap;
        do {
            Rect src = makeWindowRect(0, 0, 100, 100);
            bitmap = Bitmap.createBitmap(src.width(), src.height(), Config.RGBA_F16);
            int result = mCopyHelper.request(window, src, bitmap);
            // On OpenGL ES 2.0 devices a copy to RGBA_F16 can fail because there's
            // not support for float textures
            if (result != PixelCopy.ERROR_DESTINATION_INVALID) {
                assertEquals("Fullsize copy request failed", PixelCopy.SUCCESS, result);
                assertEquals(Config.RGBA_F16, bitmap.getConfig());
                assertBitmapQuadColor(bitmap,
                        Color.RED, Color.GREEN, Color.BLUE, Color.BLACK);
                assertBitmapEdgeColor(bitmap, Color.YELLOW);
            }
        } while (activity.rotate());
    }

    private Window waitForWideGamutWindowProducerActivity() {
        PixelCopyWideGamutViewProducerActivity activity =
                mWideGamutWindowSourceActivityRule.launchActivity(null);
        activity.waitForFirstDrawCompleted(10, TimeUnit.SECONDS);
        return activity.getWindow();
    }

    private Rect makeWideGamutWindowRect(int left, int top, int right, int bottom) {
        Rect r = new Rect(left, top, right, bottom);
        mWideGamutWindowSourceActivityRule.getActivity().offsetForContent(r);
        return r;
    }

    @Test
    public void testWideGamutWindowProducerCopyToRGBA8888() {
        Window window = waitForWideGamutWindowProducerActivity();
        assertEquals(
                ActivityInfo.COLOR_MODE_WIDE_COLOR_GAMUT, window.getAttributes().getColorMode());

        // Early out if the device does not support wide color gamut rendering
        if (!window.isWideColorGamut()) {
            return;
        }

        PixelCopyWideGamutViewProducerActivity activity =
                mWideGamutWindowSourceActivityRule.getActivity();

        Bitmap bitmap;
        do {
            Rect src = makeWideGamutWindowRect(0, 0, 128, 128);
            bitmap = Bitmap.createBitmap(src.width(), src.height(), Config.ARGB_8888);
            int result = mCopyHelper.request(window, src, bitmap);

            assertEquals("Fullsize copy request failed", PixelCopy.SUCCESS, result);
            assertEquals(Config.ARGB_8888, bitmap.getConfig());

            assertEquals("Top left", Color.RED, bitmap.getPixel(32, 32));
            assertEquals("Top right", Color.GREEN, bitmap.getPixel(96, 32));
            assertEquals("Bottom left", Color.BLUE, bitmap.getPixel(32, 96));
            assertEquals("Bottom right", Color.YELLOW, bitmap.getPixel(96, 96));
        } while (activity.rotate());
    }

    @Test
    public void testWideGamutWindowProducerCopyToRGBA16F() {
        Window window = waitForWideGamutWindowProducerActivity();
        assertEquals(
                ActivityInfo.COLOR_MODE_WIDE_COLOR_GAMUT, window.getAttributes().getColorMode());

        // Early out if the device does not support wide color gamut rendering
        if (!window.isWideColorGamut()) {
            return;
        }

        PixelCopyWideGamutViewProducerActivity activity =
                mWideGamutWindowSourceActivityRule.getActivity();
        final WindowManager windowManager = (WindowManager) activity.getSystemService(
                Context.WINDOW_SERVICE);
        final ColorSpace colorSpace = windowManager.getDefaultDisplay()
                .getPreferredWideGamutColorSpace();
        final ColorSpace.Connector proPhotoToDisplayWideColorSpace = ColorSpace.connect(
                ColorSpace.get(ColorSpace.Named.PRO_PHOTO_RGB), colorSpace);
        final ColorSpace.Connector displayWideColorSpaceToExtendedSrgb = ColorSpace.connect(
                colorSpace, ColorSpace.get(ColorSpace.Named.EXTENDED_SRGB));

        final float[] intermediateRed = proPhotoToDisplayWideColorSpace.transform(1.0f, 0.0f, 0.0f);
        final float[] intermediateGreen = proPhotoToDisplayWideColorSpace
                .transform(0.0f, 1.0f, 0.0f);
        final float[] intermediateBlue = proPhotoToDisplayWideColorSpace
                .transform(0.0f, 0.0f, 1.0f);
        final float[] intermediateYellow = proPhotoToDisplayWideColorSpace
                .transform(1.0f, 1.0f, 0.0f);

        final float[] expectedRed = displayWideColorSpaceToExtendedSrgb.transform(intermediateRed);
        final float[] expectedGreen = displayWideColorSpaceToExtendedSrgb
                .transform(intermediateGreen);
        final float[] expectedBlue = displayWideColorSpaceToExtendedSrgb
                .transform(intermediateBlue);
        final float[] expectedYellow = displayWideColorSpaceToExtendedSrgb
                .transform(intermediateYellow);

        Bitmap bitmap;
        int i = 0;
        do {
            Rect src = makeWideGamutWindowRect(0, 0, 128, 128);
            bitmap = Bitmap.createBitmap(src.width(), src.height(), Config.RGBA_F16, true,
                    ColorSpace.get(ColorSpace.Named.EXTENDED_SRGB));
            int result = mCopyHelper.request(window, src, bitmap);

            assertEquals("Fullsize copy request failed", PixelCopy.SUCCESS, result);
            assertEquals(Config.RGBA_F16, bitmap.getConfig());

            ByteBuffer dst = ByteBuffer.allocateDirect(bitmap.getAllocationByteCount());
            bitmap.copyPixelsToBuffer(dst);
            dst.rewind();
            dst.order(ByteOrder.LITTLE_ENDIAN);

            // ProPhoto RGB red in scRGB-nl
            assertEqualsRgba16f("Top left",     bitmap, 32, 32, dst, expectedRed[0],
                    expectedRed[1], expectedRed[2], 1.0f);
            // ProPhoto RGB green in scRGB-nl
            assertEqualsRgba16f("Top right",    bitmap, 96, 32, dst, expectedGreen[0],
                    expectedGreen[1], expectedGreen[2], 1.0f);
            // ProPhoto RGB blue in scRGB-nl
            assertEqualsRgba16f("Bottom left",  bitmap, 32, 96, dst, expectedBlue[0],
                    expectedBlue[1], expectedBlue[2], 1.0f);
            // ProPhoto RGB yellow in scRGB-nl
            assertEqualsRgba16f("Bottom right", bitmap, 96, 96, dst, expectedYellow[0],
                    expectedYellow[1], expectedYellow[2], 1.0f);
        } while (activity.rotate());
    }

    private Window waitForDialogProducerActivity() {
        PixelCopyViewProducerActivity activity =
                mDialogSourceActivityRule.launchActivity(null);
        activity.waitForFirstDrawCompleted(10, TimeUnit.SECONDS);
        return activity.getWindow();
    }

    private Rect makeDialogRect(int left, int top, int right, int bottom) {
        Rect r = new Rect(left, top, right, bottom);
        mDialogSourceActivityRule.getActivity().normalizedToSurface(r);
        return r;
    }

    @Test
    public void testDialogProducer() {
        Bitmap bitmap;
        Window window = waitForDialogProducerActivity();
        PixelCopyViewProducerActivity activity = mDialogSourceActivityRule.getActivity();
        do {
            Rect src = makeDialogRect(0, 0, 100, 100);
            bitmap = Bitmap.createBitmap(src.width(), src.height(), Config.ARGB_8888);
            int result = mCopyHelper.request(window, src, bitmap);
            assertEquals("Fullsize copy request failed", PixelCopy.SUCCESS, result);
            assertEquals(Config.ARGB_8888, bitmap.getConfig());
            assertBitmapQuadColor(bitmap,
                    Color.RED, Color.GREEN, Color.BLUE, Color.BLACK);
            assertBitmapEdgeColor(bitmap, Color.YELLOW);
        } while (activity.rotate());
    }

    @Test
    public void testDialogProducerCropTopLeft() {
        Window window = waitForDialogProducerActivity();
        Bitmap bitmap = Bitmap.createBitmap(100, 100, Config.ARGB_8888);
        PixelCopyViewProducerActivity activity = mDialogSourceActivityRule.getActivity();
        do {
            int result = mCopyHelper.request(window, makeDialogRect(0, 0, 50, 50), bitmap);
            assertEquals("Scaled copy request failed", PixelCopy.SUCCESS, result);
            assertBitmapQuadColor(bitmap,
                    Color.RED, Color.RED, Color.RED, Color.RED);
        } while (activity.rotate());
    }

    @Test
    public void testDialogProducerCropCenter() {
        Window window = waitForDialogProducerActivity();
        Bitmap bitmap = Bitmap.createBitmap(100, 100, Config.ARGB_8888);
        PixelCopyViewProducerActivity activity = mDialogSourceActivityRule.getActivity();
        do {
            int result = mCopyHelper.request(window, makeDialogRect(25, 25, 75, 75), bitmap);
            assertEquals("Scaled copy request failed", PixelCopy.SUCCESS, result);
            assertBitmapQuadColor(bitmap,
                    Color.RED, Color.GREEN, Color.BLUE, Color.BLACK);
        } while (activity.rotate());
    }

    @Test
    public void testDialogProducerCropBottomHalf() {
        Window window = waitForDialogProducerActivity();
        Bitmap bitmap = Bitmap.createBitmap(100, 100, Config.ARGB_8888);
        PixelCopyViewProducerActivity activity = mDialogSourceActivityRule.getActivity();
        do {
            int result = mCopyHelper.request(window, makeDialogRect(0, 50, 100, 100), bitmap);
            assertEquals("Scaled copy request failed", PixelCopy.SUCCESS, result);
            assertBitmapQuadColor(bitmap,
                    Color.BLUE, Color.BLACK, Color.BLUE, Color.BLACK);
        } while (activity.rotate());
    }

    @Test
    public void testDialogProducerScaling() {
        // Since we only sample mid-pixel of each qudrant, filtering
        // quality isn't tested
        Window window = waitForDialogProducerActivity();
        Bitmap bitmap = Bitmap.createBitmap(20, 20, Config.ARGB_8888);
        PixelCopyViewProducerActivity activity = mDialogSourceActivityRule.getActivity();
        do {
            int result = mCopyHelper.request(window, bitmap);
            assertEquals("Scaled copy request failed", PixelCopy.SUCCESS, result);
            // Make sure nothing messed with the bitmap
            assertEquals(20, bitmap.getWidth());
            assertEquals(20, bitmap.getHeight());
            assertEquals(Config.ARGB_8888, bitmap.getConfig());
            assertBitmapQuadColor(bitmap,
                    Color.RED, Color.GREEN, Color.BLUE, Color.BLACK);
        } while (activity.rotate());
    }

    @Test
    public void testDialogProducerCopyToRGBA16F() {
        Window window = waitForDialogProducerActivity();
        PixelCopyViewProducerActivity activity = mDialogSourceActivityRule.getActivity();

        Bitmap bitmap;
        do {
            Rect src = makeDialogRect(0, 0, 100, 100);
            bitmap = Bitmap.createBitmap(src.width(), src.height(), Config.RGBA_F16);
            int result = mCopyHelper.request(window, src, bitmap);
            // On OpenGL ES 2.0 devices a copy to RGBA_F16 can fail because there's
            // not support for float textures
            if (result != PixelCopy.ERROR_DESTINATION_INVALID) {
                assertEquals("Fullsize copy request failed", PixelCopy.SUCCESS, result);
                assertEquals(Config.RGBA_F16, bitmap.getConfig());
                assertBitmapQuadColor(bitmap,
                        Color.RED, Color.GREEN, Color.BLUE, Color.BLACK);
                assertBitmapEdgeColor(bitmap, Color.YELLOW);
            }
        } while (activity.rotate());
    }

    private static void assertEqualsRgba16f(String message, Bitmap bitmap, int x, int y,
            ByteBuffer dst, float r, float g, float b, float a) {
        int index = y * bitmap.getRowBytes() + (x << 3);
        short cR = dst.getShort(index);
        short cG = dst.getShort(index + 2);
        short cB = dst.getShort(index + 4);
        short cA = dst.getShort(index + 6);

        assertEquals(message, r, Half.toFloat(cR), 0.01);
        assertEquals(message, g, Half.toFloat(cG), 0.01);
        assertEquals(message, b, Half.toFloat(cB), 0.01);
        assertEquals(message, a, Half.toFloat(cA), 0.01);
    }

    private void runGcAndFinalizersSync() {
        final CountDownLatch fence = new CountDownLatch(1);
        new Object() {
            @Override
            protected void finalize() throws Throwable {
                try {
                    fence.countDown();
                } finally {
                    super.finalize();
                }
            }
        };
        try {
            do {
                Runtime.getRuntime().gc();
                Runtime.getRuntime().runFinalization();
            } while (!fence.await(100, TimeUnit.MILLISECONDS));
        } catch (InterruptedException ex) {
            throw new RuntimeException(ex);
        }
        Runtime.getRuntime().gc();
    }

    private void assertNotLeaking(int iteration, MemoryInfo start, MemoryInfo end) {
        Debug.getMemoryInfo(end);
        if (end.getTotalPss() - start.getTotalPss() > 2000 /* kB */) {
            runGcAndFinalizersSync();
            Debug.getMemoryInfo(end);
            if (end.getTotalPss() - start.getTotalPss() > 2000 /* kB */) {
                // Guarded by if so we don't continually generate garbage for the
                // assertion string.
                assertEquals("Memory leaked, iteration=" + iteration,
                        start.getTotalPss(), end.getTotalPss(),
                        2000 /* kb */);
            }
        }
    }

    @Test
    @LargeTest
    public void testNotLeaking() {
        try {
            CountDownLatch swapFence = new CountDownLatch(2);

            PixelCopyGLProducerCtsActivity activity =
                    mGLSurfaceViewActivityRule.launchActivity(null);
            activity.setSwapFence(swapFence);

            while (!swapFence.await(5, TimeUnit.MILLISECONDS)) {
                activity.getView().requestRender();
            }

            // Test a fullsize copy
            Bitmap bitmap = Bitmap.createBitmap(100, 100, Config.ARGB_8888);

            MemoryInfo meminfoStart = new MemoryInfo();
            MemoryInfo meminfoEnd = new MemoryInfo();

            for (int i = 0; i < 1000; i++) {
                if (i == 2) {
                    // Not really the "start" but by having done a couple
                    // we've fully initialized any state that may be required,
                    // so memory usage should be stable now
                    runGcAndFinalizersSync();
                    Debug.getMemoryInfo(meminfoStart);
                }
                if (i % 100 == 5) {
                    assertNotLeaking(i, meminfoStart, meminfoEnd);
                }
                int result = mCopyHelper.request(activity.getView(), bitmap);
                assertEquals("Copy request failed", PixelCopy.SUCCESS, result);
                // Make sure nothing messed with the bitmap
                assertEquals(100, bitmap.getWidth());
                assertEquals(100, bitmap.getHeight());
                assertEquals(Config.ARGB_8888, bitmap.getConfig());
                assertBitmapQuadColor(bitmap,
                        Color.RED, Color.GREEN, Color.BLUE, Color.BLACK);
            }

            assertNotLeaking(1000, meminfoStart, meminfoEnd);

        } catch (InterruptedException e) {
            fail("Interrupted, error=" + e.getMessage());
        }
    }

    @Test
    public void testVideoProducer() throws InterruptedException {
        PixelCopyVideoSourceActivity activity =
                mVideoSourceActivityRule.launchActivity(null);
        if (!activity.canPlayVideo()) {
            Log.i(TAG, "Skipping testVideoProducer, video codec isn't supported");
            return;
        }
        // This returns when the video has been prepared and playback has
        // been started, it doesn't necessarily means a frame has actually been
        // produced. There sadly isn't a callback for that.
        // So we'll try for up to 900ms after this event to acquire a frame, otherwise
        // it's considered a timeout.
        activity.waitForPlaying();
        assertTrue("Failed to start video playback", activity.canPlayVideo());
        Bitmap bitmap = Bitmap.createBitmap(100, 100, Config.ARGB_8888);
        int copyResult = PixelCopy.ERROR_SOURCE_NO_DATA;
        for (int i = 0; i < 30; i++) {
            copyResult = mCopyHelper.request(activity.getVideoView(), bitmap);
            if (copyResult != PixelCopy.ERROR_SOURCE_NO_DATA) {
                break;
            }
            Thread.sleep(30);
        }
        assertEquals(PixelCopy.SUCCESS, copyResult);
        // A large threshold is used because decoder accuracy is covered in the
        // media CTS tests, so we are mainly interested in verifying that rotation
        // and YUV->RGB conversion were handled properly.
        assertBitmapQuadColor(bitmap, Color.RED, Color.GREEN, Color.BLUE, Color.BLACK, 30);

        // Test that cropping works.
        copyResult = mCopyHelper.request(activity.getVideoView(), new Rect(0, 0, 50, 50), bitmap);
        assertEquals("Scaled copy request failed", PixelCopy.SUCCESS, copyResult);
        assertBitmapQuadColor(bitmap,
                Color.RED, Color.RED, Color.RED, Color.RED, 30);

        copyResult = mCopyHelper.request(activity.getVideoView(), new Rect(25, 25, 75, 75), bitmap);
        assertEquals("Scaled copy request failed", PixelCopy.SUCCESS, copyResult);
        assertBitmapQuadColor(bitmap,
                Color.RED, Color.GREEN, Color.BLUE, Color.BLACK, 30);

        copyResult = mCopyHelper.request(activity.getVideoView(), new Rect(0, 50, 100, 100), bitmap);
        assertEquals("Scaled copy request failed", PixelCopy.SUCCESS, copyResult);
        assertBitmapQuadColor(bitmap,
                Color.BLUE, Color.BLACK, Color.BLUE, Color.BLACK, 30);

        // Test that clamping works
        copyResult = mCopyHelper.request(activity.getVideoView(), new Rect(50, -50, 150, 50), bitmap);
        assertEquals("Scaled copy request failed", PixelCopy.SUCCESS, copyResult);
        assertBitmapQuadColor(bitmap,
                Color.GREEN, Color.GREEN, Color.GREEN, Color.GREEN, 30);
    }

    private static int getPixelFloatPos(Bitmap bitmap, float xpos, float ypos) {
        return bitmap.getPixel((int) (bitmap.getWidth() * xpos), (int) (bitmap.getHeight() * ypos));
    }

    public static void assertBitmapQuadColor(Bitmap bitmap, int topLeft, int topRight,
                int bottomLeft, int bottomRight) {
        // Just quickly sample 4 pixels in the various regions.
        assertEquals("Top left " + Integer.toHexString(topLeft) + ", actual= "
                + Integer.toHexString(getPixelFloatPos(bitmap, .25f, .25f)),
                topLeft, getPixelFloatPos(bitmap, .25f, .25f));
        assertEquals("Top right", topRight, getPixelFloatPos(bitmap, .75f, .25f));
        assertEquals("Bottom left", bottomLeft, getPixelFloatPos(bitmap, .25f, .75f));
        assertEquals("Bottom right", bottomRight, getPixelFloatPos(bitmap, .75f, .75f));
    }

    private void assertBitmapQuadColor(Bitmap bitmap, int topLeft, int topRight,
            int bottomLeft, int bottomRight, int threshold) {
        // Just quickly sample 4 pixels in the various regions.
        assertTrue("Top left", pixelsAreSame(topLeft, getPixelFloatPos(bitmap, .25f, .25f),
                threshold));
        assertTrue("Top right", pixelsAreSame(topRight, getPixelFloatPos(bitmap, .75f, .25f),
                threshold));
        assertTrue("Bottom left", pixelsAreSame(bottomLeft, getPixelFloatPos(bitmap, .25f, .75f),
                threshold));
        assertTrue("Bottom right", pixelsAreSame(bottomRight, getPixelFloatPos(bitmap, .75f, .75f),
                threshold));
    }

    private void assertBitmapEdgeColor(Bitmap bitmap, int edgeColor) {
        // Just quickly sample a few pixels on the edge and assert
        // they are edge color, then assert that just inside the edge is a different color
        assertBitmapColor("Top edge", bitmap, edgeColor, bitmap.getWidth() / 2, 1);
        assertBitmapNotColor("Top edge", bitmap, edgeColor, bitmap.getWidth() / 2, 2);

        assertBitmapColor("Left edge", bitmap, edgeColor, 1, bitmap.getHeight() / 2);
        assertBitmapNotColor("Left edge", bitmap, edgeColor, 2, bitmap.getHeight() / 2);

        assertBitmapColor("Bottom edge", bitmap, edgeColor,
                bitmap.getWidth() / 2, bitmap.getHeight() - 2);
        assertBitmapNotColor("Bottom edge", bitmap, edgeColor,
                bitmap.getWidth() / 2, bitmap.getHeight() - 3);

        assertBitmapColor("Right edge", bitmap, edgeColor,
                bitmap.getWidth() - 2, bitmap.getHeight() / 2);
        assertBitmapNotColor("Right edge", bitmap, edgeColor,
                bitmap.getWidth() - 3, bitmap.getHeight() / 2);
    }

    private boolean pixelsAreSame(int ideal, int given, int threshold) {
        int error = Math.abs(Color.red(ideal) - Color.red(given));
        error += Math.abs(Color.green(ideal) - Color.green(given));
        error += Math.abs(Color.blue(ideal) - Color.blue(given));
        return (error < threshold);
    }

    private void assertBitmapColor(String debug, Bitmap bitmap, int color, int x, int y) {
        int pixel = bitmap.getPixel(x, y);
        if (!pixelsAreSame(color, pixel, 10)) {
            fail(debug + "; expected=" + Integer.toHexString(color) + ", actual="
                    + Integer.toHexString(pixel));
        }
    }

    private void assertBitmapNotColor(String debug, Bitmap bitmap, int color, int x, int y) {
        int pixel = bitmap.getPixel(x, y);
        if (pixelsAreSame(color, pixel, 10)) {
            fail(debug + "; actual=" + Integer.toHexString(pixel)
                    + " shouldn't have matched " + Integer.toHexString(color));
        }
    }

    private static class SurfaceTextureRule implements TestRule {
        private SurfaceTexture mSurfaceTexture = null;
        private Surface mSurface = null;

        private void createIfNecessary() {
            mSurfaceTexture = new SurfaceTexture(false);
            mSurface = new Surface(mSurfaceTexture);
        }

        public Surface getSurface() {
            createIfNecessary();
            return mSurface;
        }

        @Override
        public Statement apply(Statement base, Description description) {
            return new CreateSurfaceTextureStatement(base);
        }

        private class CreateSurfaceTextureStatement extends Statement {

            private final Statement mBase;

            public CreateSurfaceTextureStatement(Statement base) {
                mBase = base;
            }

            @Override
            public void evaluate() throws Throwable {
                try {
                    mBase.evaluate();
                } finally {
                    try {
                        if (mSurface != null) mSurface.release();
                    } catch (Throwable t) {}
                    try {
                        if (mSurfaceTexture != null) mSurfaceTexture.release();
                    } catch (Throwable t) {}
                }
            }
        }
    }
}