Programmatically take screenshot Android 13

Question

I have the following code, which works perfectly fine on Android 12 and below, but for a weird reason, Android 13 takes "black" screenshots, about 95% of the time.

fun setVirtualDisplay() {
    mImageReader = ImageReader.newInstance(
        deviceScreenUtils.getWidth(),
        deviceScreenUtils.getHeight(),
        PixelFormat.RGBA_8888,
        2
    )

    mImageReader?.let {
        val flags =
            DisplayManager.VIRTUAL_DISPLAY_FLAG_OWN_CONTENT_ONLY or DisplayManager.VIRTUAL_DISPLAY_FLAG_PUBLIC

        try {
            mVirtualDisplay = mMediaProjection?.createVirtualDisplay(
                "screen-mirror", deviceScreenUtils.getWidth(), deviceScreenUtils.getHeight(),
                deviceScreenUtils.getDensity(), flags, it.surface, null, null
            )
        } catch (e: Throwable) {
            Log.i(TAG, "Media Projection not longer available...")
            mMediaProjectionIntent = null
            mImageReader = null
        }
    }
}

fun takeScreenshot() {
    Log.i(TAG, "Taking screenshot...")
    val handler = Handler(Looper.getMainLooper())
    mImageReader?.setOnImageAvailableListener({ imageReader ->
        val image = imageReader.acquireLatestImage()
        Log.i(TAG, "Acquiring image...")
        if (image != null) {
            val planes = image.planes
            val buffer = planes[0].buffer
            val pixelStride = planes[0].pixelStride
            val rowStride = planes[0].rowStride
            val rowPadding: Int = rowStride - pixelStride * deviceScreenUtils.getWidthPixels()
            val bitmap = Bitmap.createBitmap(
                deviceScreenUtils.getWidth() + (rowPadding.toFloat() / pixelStride.toFloat()).toInt(),
                deviceScreenUtils.getHeight(),
                Bitmap.Config.ARGB_8888
            )
            bitmap.copyPixelsFromBuffer(buffer)
            image.close()

            fileUtil.saveImage(bitmap)?.let {
                lastScreenshot.onNext(it)
            }
        }

        imageReader.setOnImageAvailableListener(null, handler)
        releaseBuffer()
    }, handler)
}

Did something change for this specific functionality? Or do I have something wrong in the code and it has been magically working on previous versions?

Answer 1

In my testing and observation, there're two issues when using ImageReader with media projection on Android 13

First, the callback result of setOnImageAvailableListener sometimes returns buffer with empty pixels. So we can just wait for the next image until we get a non-empty bitmap

imageReader.setOnImageAvailableListener({ imageReader ->
    val image = imageReader.acquireLatestImage()
    // ... get buffer here
    val bitmap = Bitmap.createBitmap(screenWidth + rowPadding / pixelStride, screenHeight, Bitmap.Config.ARGB_8888)
    bitmap.copyPixelsFromBuffer(buffer)

    // IMPORTANT!
    val isEmptyBitmap = bitmap.isEmptyBitmap()
    if (isEmptyBitmap) {
        // don't stop the listener and let the imageReader continue to run so that we can get next round of image buffer
    } else {
        // save bitmap to file
    }

    }, Handler(Looper.getMainLooper()))

the isEmptyBitmap() is just an extension of Bitmap:

fun Bitmap.isEmptyBitmap(): Boolean {
    val emptyBitmap = Bitmap.createBitmap(width, height, config)
    return this.sameAs(emptyBitmap)
}

The second issue is that, the OnImageAvailableListener sometimes doesn't even callback! In this case, I set a timeout to wait for the result, and when timed-out, recreate the VirtualDisplay object from the same MediaProjection instance and it just works.

I'm using kotlin coroutine so the code snippet may look like:

retry(10) {
    val imageVirtualDisplay = createVirtualDisplay(...)
    try {
        withTimeout(100) {
            // awaitImageAvailable will suspend here to get the non-empty bitmap
            val bitmap = imageReader.awaitImageAvailable(screenWidth, screenHeight)
            // save bitmap to file
        }
    } finally {
        Timber.d("screenshot imageVirtualDisplay release")
        imageVirtualDisplay?.release()
    }
}

the implementation of awaitImageAvailable:

suspend fun ImageReader.awaitImageAvailable(screenWidth: Int, screenHeight: Int): Bitmap =
suspendCancellableCoroutine { cont ->
    setOnImageAvailableListener({ imageReader ->

        val image = imageReader.acquireLatestImage() ?: throw Error("get screen image result failed")

        val planes = image.planes
        val buffer = planes[0].buffer

        val pixelStride = planes[0].pixelStride
        val rowStride = planes[0].rowStride
        val rowPadding: Int = rowStride - pixelStride * screenWidth
        var bitmap =
            Bitmap.createBitmap(screenWidth + rowPadding / pixelStride, screenHeight, Bitmap.Config.ARGB_8888)
        bitmap.copyPixelsFromBuffer(buffer)
        bitmap = Bitmap.createBitmap(bitmap, 0, 0, screenWidth, screenHeight)
        image.close()

        if (!bitmap.isEmptyBitmap()) {
            Timber.d("image not empty")
            setOnImageAvailableListener(null, null)
            cont.resume(bitmap)
        } else {
            Timber.w("image empty")
        }
    }, Handler(Looper.getMainLooper()))

    cont.invokeOnCancellation { setOnImageAvailableListener(null, null) }
}

Answer 2

Step 1:

private fun captureScreenShot(view: View): Bitmap {
    val returnedBitmap = Bitmap.createBitmap(view.width, view.height, Bitmap.Config.ARGB_8888)
    val canvas = Canvas(returnedBitmap)
    val bgDrawable = view.background
    if (bgDrawable != null) bgDrawable.draw(canvas)
    else canvas.drawColor(Color.WHITE)
    view.draw(canvas)
    return returnedBitmap
}

below step 2 is inside oncreate method step 2:

val btn: Button = findViewById(R.id.btn)
    val image: ImageView =findViewById(R.id.image)

    btn.setOnClickListener{
        val constraintLayout: ConstraintLayout = findViewById(R.id.container)
        val screenshot: Bitmap =captureScreenShot(constraintLayout)
        image.setImageBitmap(screenshot)
    }

Answer 3

 val bitmap = IntentShareUtils.captureBitmapFromView(binding.root)
 val shareUrl = IntentShareUtils.saveToSharedImage(this, bitmap)
 IntentShareUtils.shareEtc(this, shareUrl)

public static Bitmap captureBitmapFromView(View v) {
    Bitmap b = Bitmap.createBitmap(v.getMeasuredWidth(), v.getMeasuredHeight(), Bitmap.Config.ARGB_8888);
    Canvas c = new Canvas(b);
    v.layout(v.getLeft(), v.getTop(), v.getRight(), v.getBottom());
    v.draw(c);
    return b;
}

public static String saveToSharedImage(Context context, Bitmap bitmap) {
    if (bitmap == null) {
        return "";
    }
    File externalFilesDir = context.getExternalFilesDir("share_image");
    if (!externalFilesDir.exists()) {
        externalFilesDir.mkdir();
    }
    File file = new File(externalFilesDir, "share_image.jpg");
    if (file.exists()) {
        file.delete();
    }
    try {
        file.createNewFile();
    } catch (IOException e) {
        e.printStackTrace();
    }
    try {
        OutputStream fileOutputStream = new FileOutputStream(file);
        bitmap.compress(Bitmap.CompressFormat.PNG, 100, fileOutputStream);
        fileOutputStream.close();
    } catch (IOException e2) {
        e2.printStackTrace();
    }
    String absolutePath = file.getAbsolutePath();

    return absolutePath;
}

public static void shareEtc(Context context, String file_path) {
    Intent intent = new Intent("android.intent.action.SEND");
    intent.setType("image/*");

    Parcelable c;
    if (Build.VERSION.SDK_INT >= 23) {
        c = getUri(context, file_path);
    } else {
        c = getUri(file_path);
    }

    intent.putExtra("android.intent.extra.STREAM", c);
    context.startActivity(Intent.createChooser(intent, "Share to"));
}