Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 797bdc99 authored by Chavi Weingarten's avatar Chavi Weingarten
Browse files

Revert "Send ScreenCaptureListener to native screen capture requ..." 

Revert "Update screen capture functions to accept a ScreenCaptur..."

Revert submission 12404049-async_screencapture

Reason for revert: 168149157, 168154840
Reverted Changes:
I54c34003c:Send ScreenCaptureListener to native screen captur...
I9cbc833f8:Update screen capture functions to accept a Screen...

Change-Id: Ibd2b1e6588aa45fe228ea7c4c43dbf7a5402aaa5
Bug: 168154840
Bug: 168149157
parent 3510924a

cmds/screencap/screencap.cpp

+3 −9
Original line number Diff line number Diff line
@@ -30,9 +30,8 @@ 


#include <binder/ProcessState.h>



#include <gui/ISurfaceComposer.h>

#include <gui/SurfaceComposerClient.h>

#include <gui/SyncScreenCaptureListener.h>

#include <gui/ISurfaceComposer.h>



#include <ui/DisplayInfo.h>

#include <ui/GraphicTypes.h>
@@ -182,18 +181,13 @@ int main(int argc, char** argv) 
    ProcessState::self()->setThreadPoolMaxThreadCount(0);

    ProcessState::self()->startThreadPool();



    sp<SyncScreenCaptureListener> captureListener = new SyncScreenCaptureListener();

    status_t result = ScreenshotClient::captureDisplay(displayId->value, captureListener);

    ScreenCaptureResults captureResults;

    status_t result = ScreenshotClient::captureDisplay(displayId->value, captureResults);

    if (result != NO_ERROR) {

        close(fd);

        return 1;

    }



    ScreenCaptureResults captureResults = captureListener->waitForResults();

    if (captureResults.result != NO_ERROR) {

        close(fd);

        return 1;

    }

    ui::Dataspace dataspace = captureResults.capturedDataspace;

    sp<GraphicBuffer> buffer = captureResults.buffer;

core/java/android/view/SurfaceControl.java

+9 −87
Original line number Diff line number Diff line
@@ -65,9 +65,6 @@ import java.nio.ByteBuffer; 
import java.nio.ByteOrder;

import java.util.ArrayList;

import java.util.Objects;

import java.util.concurrent.CountDownLatch;

import java.util.concurrent.TimeUnit;

import java.util.concurrent.atomic.AtomicReference;



/**

 * Handle to an on-screen Surface managed by the system compositor. The SurfaceControl is
@@ -90,10 +87,10 @@ public final class SurfaceControl implements Parcelable { 
    private static native void nativeWriteToParcel(long nativeObject, Parcel out);

    private static native void nativeRelease(long nativeObject);

    private static native void nativeDisconnect(long nativeObject);

    private static native int nativeCaptureDisplay(DisplayCaptureArgs captureArgs,

            ScreenCaptureListener captureListener);

    private static native int nativeCaptureLayers(LayerCaptureArgs captureArgs,

            ScreenCaptureListener captureListener);

    private static native ScreenshotHardwareBuffer nativeCaptureDisplay(

            DisplayCaptureArgs captureArgs);

    private static native ScreenshotHardwareBuffer nativeCaptureLayers(

            LayerCaptureArgs captureArgs);

    private static native long nativeMirrorSurface(long mirrorOfObject);

    private static native long nativeCreateTransaction();

    private static native long nativeGetNativeTransactionFinalizer();
@@ -496,8 +493,6 @@ public final class SurfaceControl implements Parcelable { 
    private static final int INTERNAL_DATASPACE_DISPLAY_P3 = 143261696;

    private static final int INTERNAL_DATASPACE_SCRGB = 411107328;



    private static final int SCREENSHOT_WAIT_TIME_S = 1;



    private void assignNativeObject(long nativeObject, String callsite) {

        if (mNativeObject != 0) {

            release();
@@ -615,13 +610,6 @@ public final class SurfaceControl implements Parcelable { 
        }

    }



    /**

     * @hide

     */

    public abstract static class ScreenCaptureListener {

        abstract void onScreenCaptureComplete(ScreenshotHardwareBuffer hardwareBuffer);

    }



    /**

     * A common arguments class used for various screenshot requests. This contains arguments that

     * are shared between {@link DisplayCaptureArgs} and {@link LayerCaptureArgs}
@@ -697,7 +685,7 @@ public final class SurfaceControl implements Parcelable { 
    /**

     * The arguments class used to make display capture requests.

     *

     * @see #nativeCaptureDisplay(DisplayCaptureArgs, ScreenCaptureListener)

     * @see #nativeCaptureDisplay(DisplayCaptureArgs)

     * @hide

     */

    public static class DisplayCaptureArgs extends CaptureArgs {
@@ -2237,16 +2225,6 @@ public final class SurfaceControl implements Parcelable { 
        return getPhysicalDisplayToken(physicalDisplayIds[0]);

    }



    /**

     * @param captureArgs Arguments about how to take the screenshot

     * @param captureListener A listener to receive the screenshot callback

     * @hide

     */

    public static int captureDisplay(@NonNull DisplayCaptureArgs captureArgs,

            @NonNull ScreenCaptureListener captureListener) {

        return nativeCaptureDisplay(captureArgs, captureListener);

    }



    /**

     * Captures all the surfaces in a display and returns a {@link ScreenshotHardwareBuffer} with

     * the content.
@@ -2254,30 +2232,7 @@ public final class SurfaceControl implements Parcelable { 
     * @hide

     */

    public static ScreenshotHardwareBuffer captureDisplay(DisplayCaptureArgs captureArgs) {

        final AtomicReference<ScreenshotHardwareBuffer> outHardwareBuffer =

                new AtomicReference<>(null);



        final CountDownLatch countDownLatch = new CountDownLatch(1);

        ScreenCaptureListener screenCaptureListener = new ScreenCaptureListener() {

            @Override

            void onScreenCaptureComplete(ScreenshotHardwareBuffer hardwareBuffer) {

                outHardwareBuffer.set(hardwareBuffer);

                countDownLatch.countDown();

            }

        };



        int status = captureDisplay(captureArgs, screenCaptureListener);

        if (status != 0) {

            return null;

        }



        try {

            countDownLatch.await(SCREENSHOT_WAIT_TIME_S, TimeUnit.SECONDS);

        } catch (Exception e) {

            Log.e(TAG, "Failed to wait for captureDisplay result", e);

        }



        return outHardwareBuffer.get();

        return nativeCaptureDisplay(captureArgs);

    }



    /**
@@ -2322,37 +2277,14 @@ public final class SurfaceControl implements Parcelable { 
                .setPixelFormat(format)

                .build();



        return captureLayers(captureArgs);

        return nativeCaptureLayers(captureArgs);

    }



    /**

     * @hide

     */

    public static ScreenshotHardwareBuffer captureLayers(LayerCaptureArgs captureArgs) {

        final AtomicReference<ScreenshotHardwareBuffer> outHardwareBuffer =

                new AtomicReference<>(null);



        final CountDownLatch countDownLatch = new CountDownLatch(1);

        ScreenCaptureListener screenCaptureListener = new ScreenCaptureListener() {

            @Override

            void onScreenCaptureComplete(ScreenshotHardwareBuffer hardwareBuffer) {

                outHardwareBuffer.set(hardwareBuffer);

                countDownLatch.countDown();

            }

        };



        int status = captureLayers(captureArgs, screenCaptureListener);

        if (status != 0) {

            return null;

        }



        try {

            countDownLatch.await(SCREENSHOT_WAIT_TIME_S, TimeUnit.SECONDS);

        } catch (Exception e) {

            Log.e(TAG, "Failed to wait for captureLayers result", e);

        }



        return outHardwareBuffer.get();

        return nativeCaptureLayers(captureArgs);

    }



    /**
@@ -2369,17 +2301,7 @@ public final class SurfaceControl implements Parcelable { 
                .setExcludeLayers(exclude)

                .build();



        return captureLayers(captureArgs);

    }



    /**

     * @param captureArgs Arguments about how to take the screenshot

     * @param captureListener A listener to receive the screenshot callback

     * @hide

     */

    public static int captureLayers(@NonNull LayerCaptureArgs captureArgs,

            @NonNull ScreenCaptureListener captureListener) {

        return nativeCaptureLayers(captureArgs, captureListener);

        return nativeCaptureLayers(captureArgs);

    }



    /**

core/jni/android_view_SurfaceControl.cpp

+34 −76
Original line number Diff line number Diff line
@@ -30,7 +30,6 @@ 
#include <android_runtime/android_hardware_HardwareBuffer.h>

#include <android_runtime/android_view_Surface.h>

#include <android_runtime/android_view_SurfaceSession.h>

#include <gui/IScreenCaptureListener.h>

#include <gui/ISurfaceComposer.h>

#include <gui/Surface.h>

#include <gui/SurfaceComposerClient.h>
@@ -187,11 +186,6 @@ static struct { 
    jmethodID builder;

} gScreenshotHardwareBufferClassInfo;



static struct {

    jclass clazz;

    jmethodID onScreenCaptureComplete;

} gScreenCaptureListenerClassInfo;



static struct {

    jclass clazz;

    jmethodID ctor;
@@ -232,54 +226,6 @@ constexpr ui::Dataspace pickDataspaceFromColorMode(const ui::ColorMode colorMode 
    }

}



class ScreenCaptureListenerWrapper : public BnScreenCaptureListener {

public:

    explicit ScreenCaptureListenerWrapper(JNIEnv* env, jobject jobject) {

        env->GetJavaVM(&mVm);

        screenCaptureListenerObject = env->NewGlobalRef(jobject);

        LOG_ALWAYS_FATAL_IF(!screenCaptureListenerObject, "Failed to make global ref");

    }



    ~ScreenCaptureListenerWrapper() {

        if (screenCaptureListenerObject) {

            getenv()->DeleteGlobalRef(screenCaptureListenerObject);

            screenCaptureListenerObject = nullptr;

        }

    }



    status_t onScreenCaptureComplete(const ScreenCaptureResults& captureResults) {

        JNIEnv* env = getenv();

        if (captureResults.result != NO_ERROR || captureResults.buffer == nullptr) {

            env->CallVoidMethod(screenCaptureListenerObject,

                                gScreenCaptureListenerClassInfo.onScreenCaptureComplete, nullptr);

            return NO_ERROR;

        }

        jobject jhardwareBuffer = android_hardware_HardwareBuffer_createFromAHardwareBuffer(

                env, captureResults.buffer->toAHardwareBuffer());

        const jint namedColorSpace =

                fromDataspaceToNamedColorSpaceValue(captureResults.capturedDataspace);

        jobject screenshotHardwareBuffer =

                env->CallStaticObjectMethod(gScreenshotHardwareBufferClassInfo.clazz,

                                            gScreenshotHardwareBufferClassInfo.builder,

                                            jhardwareBuffer, namedColorSpace,

                                            captureResults.capturedSecureLayers);

        env->CallVoidMethod(screenCaptureListenerObject,

                            gScreenCaptureListenerClassInfo.onScreenCaptureComplete,

                            screenshotHardwareBuffer);

        return NO_ERROR;

    }



private:

    jobject screenCaptureListenerObject;

    JavaVM* mVm;



    JNIEnv* getenv() {

        JNIEnv* env;

        mVm->GetEnv(reinterpret_cast<void**>(&env), JNI_VERSION_1_6);

        return env;

    }

};



// ----------------------------------------------------------------------------



static jlong nativeCreateTransaction(JNIEnv* env, jclass clazz) {
@@ -381,28 +327,36 @@ static DisplayCaptureArgs displayCaptureArgsFromObject(JNIEnv* env, 
    return captureArgs;

}



static jint nativeCaptureDisplay(JNIEnv* env, jclass clazz, jobject displayCaptureArgsObject,

                                 jobject screenCaptureListenerObject) {

static jobject nativeCaptureDisplay(JNIEnv* env, jclass clazz, jobject displayCaptureArgsObject) {

    const DisplayCaptureArgs captureArgs =

            displayCaptureArgsFromObject(env, displayCaptureArgsObject);



    if (captureArgs.displayToken == NULL) {

        return BAD_VALUE;

        return NULL;

    }



    ScreenCaptureResults captureResults;

    status_t res = ScreenshotClient::captureDisplay(captureArgs, captureResults);

    if (res != NO_ERROR) {

        return NULL;

    }



    sp<IScreenCaptureListener> captureListener =

            new ScreenCaptureListenerWrapper(env, screenCaptureListenerObject);

    return ScreenshotClient::captureDisplay(captureArgs, captureListener);

    jobject jhardwareBuffer = android_hardware_HardwareBuffer_createFromAHardwareBuffer(

            env, captureResults.buffer->toAHardwareBuffer());

    const jint namedColorSpace =

            fromDataspaceToNamedColorSpaceValue(captureResults.capturedDataspace);

    return env->CallStaticObjectMethod(gScreenshotHardwareBufferClassInfo.clazz,

                                       gScreenshotHardwareBufferClassInfo.builder, jhardwareBuffer,

                                       namedColorSpace, captureResults.capturedSecureLayers);

}



static jint nativeCaptureLayers(JNIEnv* env, jclass clazz, jobject layerCaptureArgsObject,

                                jobject screenCaptureListenerObject) {

static jobject nativeCaptureLayers(JNIEnv* env, jclass clazz, jobject layerCaptureArgsObject) {

    LayerCaptureArgs captureArgs;

    getCaptureArgs(env, layerCaptureArgsObject, captureArgs);

    SurfaceControl* layer = reinterpret_cast<SurfaceControl*>(

            env->GetLongField(layerCaptureArgsObject, gLayerCaptureArgsClassInfo.layer));

    if (layer == nullptr) {

        return BAD_VALUE;

        return nullptr;

    }



    captureArgs.layerHandle = layer->getHandle();
@@ -426,9 +380,19 @@ static jint nativeCaptureLayers(JNIEnv* env, jclass clazz, jobject layerCaptureA 
        env->ReleaseLongArrayElements(excludeObjectArray, const_cast<jlong*>(objects), JNI_ABORT);

    }



    sp<IScreenCaptureListener> captureListener =

            new ScreenCaptureListenerWrapper(env, screenCaptureListenerObject);

    return ScreenshotClient::captureLayers(captureArgs, captureListener);

    ScreenCaptureResults captureResults;

    status_t res = ScreenshotClient::captureLayers(captureArgs, captureResults);

    if (res != NO_ERROR) {

        return NULL;

    }



    jobject jhardwareBuffer = android_hardware_HardwareBuffer_createFromAHardwareBuffer(

            env, captureResults.buffer->toAHardwareBuffer());

    const jint namedColorSpace =

            fromDataspaceToNamedColorSpaceValue(captureResults.capturedDataspace);

    return env->CallStaticObjectMethod(gScreenshotHardwareBufferClassInfo.clazz,

                                       gScreenshotHardwareBufferClassInfo.builder, jhardwareBuffer,

                                       namedColorSpace, captureResults.capturedSecureLayers);

}



static void nativeApplyTransaction(JNIEnv* env, jclass clazz, jlong transactionObj, jboolean sync) {
@@ -1543,7 +1507,6 @@ static jlong nativeGetHandle(JNIEnv* env, jclass clazz, jlong nativeObject) { 


// ----------------------------------------------------------------------------



// clang-format off

static const JNINativeMethod sSurfaceControlMethods[] = {

    {"nativeCreate", "(Landroid/view/SurfaceSession;Ljava/lang/String;IIIIJLandroid/os/Parcel;)J",

            (void*)nativeCreate },
@@ -1686,10 +1649,12 @@ static const JNINativeMethod sSurfaceControlMethods[] = { 
    {"nativeSetOverrideScalingMode", "(JJI)V",

            (void*)nativeSetOverrideScalingMode },

    {"nativeCaptureDisplay",

            "(Landroid/view/SurfaceControl$DisplayCaptureArgs;Landroid/view/SurfaceControl$ScreenCaptureListener;)I",

            "(Landroid/view/SurfaceControl$DisplayCaptureArgs;)"

            "Landroid/view/SurfaceControl$ScreenshotHardwareBuffer;",

            (void*)nativeCaptureDisplay },

    {"nativeCaptureLayers",

            "(Landroid/view/SurfaceControl$LayerCaptureArgs;Landroid/view/SurfaceControl$ScreenCaptureListener;)I",

            "(Landroid/view/SurfaceControl$LayerCaptureArgs;)"

            "Landroid/view/SurfaceControl$ScreenshotHardwareBuffer;",

            (void*)nativeCaptureLayers },

    {"nativeSetInputWindowInfo", "(JJLandroid/view/InputWindowHandle;)V",

            (void*)nativeSetInputWindowInfo },
@@ -1723,7 +1688,6 @@ static const JNINativeMethod sSurfaceControlMethods[] = { 
            (void*)nativeGetHandle },

    {"nativeSetFixedTransformHint", "(JJI)V", (void*)nativeSetFixedTransformHint},

};

// clang-format on



int register_android_view_SurfaceControl(JNIEnv* env)

{
@@ -1892,12 +1856,6 @@ int register_android_view_SurfaceControl(JNIEnv* env) 
    gLayerCaptureArgsClassInfo.childrenOnly =

            GetFieldIDOrDie(env, layerCaptureArgsClazz, "mChildrenOnly", "Z");



    jclass screenCaptureListenerClazz =

            FindClassOrDie(env, "android/view/SurfaceControl$ScreenCaptureListener");

    gScreenCaptureListenerClassInfo.clazz = MakeGlobalRefOrDie(env, screenCaptureListenerClazz);

    gScreenCaptureListenerClassInfo.onScreenCaptureComplete =

            GetMethodIDOrDie(env, screenCaptureListenerClazz, "onScreenCaptureComplete",

                             "(Landroid/view/SurfaceControl$ScreenshotHardwareBuffer;)V");

    return err;

}