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

Commit 3f668bee authored by John Reck's avatar John Reck Committed by Automerger Merge Worker
Browse files

Merge "Fix implementation of ANW_read/write parcel" am: 9e818bab am: 53541068 

Original change: https://android-review.googlesource.com/c/platform/frameworks/native/+/2464254



Change-Id: I63f03e58ba654b1667a29e1908f8cd344bb97373
Signed-off-by: default avatarAutomerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
parents 46104b6f 53541068

libs/gui/view/Surface.cpp

+47 −5
Original line number Original line Diff line number Diff line
@@ -16,17 +16,59 @@ 




#define LOG_TAG "Surface"

#define LOG_TAG "Surface"





#include <gui/view/Surface.h>

#include <android/binder_libbinder.h>



#include <android/binder_parcel.h>

#include <android/native_window.h>

#include <binder/Parcel.h>

#include <binder/Parcel.h>



#include <utils/Log.h>



#include <gui/IGraphicBufferProducer.h>

#include <gui/IGraphicBufferProducer.h>

#include <gui/Surface.h>

#include <gui/view/Surface.h>

#include <system/window.h>

#include <utils/Log.h>





namespace android {

namespace android {

namespace view {

namespace view {





// Since this is a parcelable utility and we want to keep the wire format stable, only build this

// when building the system libgui to detect any issues loading the wrong libgui from

// libnativewindow



#if (!defined(__ANDROID_APEX__) && !defined(__ANDROID_VNDK__))



extern "C" status_t android_view_Surface_writeToParcel(ANativeWindow* _Nonnull window,

                                                       Parcel* _Nonnull parcel) {

    int value;

    int err = (*window->query)(window, NATIVE_WINDOW_CONCRETE_TYPE, &value);

    if (err != OK || value != NATIVE_WINDOW_SURFACE) {

        ALOGE("Error: ANativeWindow is not backed by Surface");

        return STATUS_BAD_VALUE;

    }

    // Use a android::view::Surface to parcelize the window

    android::view::Surface shimSurface;

    shimSurface.graphicBufferProducer = android::Surface::getIGraphicBufferProducer(window);

    shimSurface.surfaceControlHandle = android::Surface::getSurfaceControlHandle(window);

    return shimSurface.writeToParcel(parcel);

}



extern "C" status_t android_view_Surface_readFromParcel(

        const Parcel* _Nonnull parcel, ANativeWindow* _Nullable* _Nonnull outWindow) {

    // Use a android::view::Surface to unparcel the window

    android::view::Surface shimSurface;

    status_t ret = shimSurface.readFromParcel(parcel);

    if (ret != OK) {

        ALOGE("%s: Error: Failed to create android::view::Surface from AParcel", __FUNCTION__);

        return STATUS_BAD_VALUE;

    }

    auto surface = sp<android::Surface>::make(shimSurface.graphicBufferProducer, false,

                                              shimSurface.surfaceControlHandle);

    ANativeWindow* anw = surface.get();

    ANativeWindow_acquire(anw);

    *outWindow = anw;

    return STATUS_OK;

}



#endif



status_t Surface::writeToParcel(Parcel* parcel) const {

status_t Surface::writeToParcel(Parcel* parcel) const {

    return writeToParcel(parcel, false);

    return writeToParcel(parcel, false);

}

}

libs/nativewindow/ANativeWindow.cpp

+49 −35
Original line number Original line Diff line number Diff line
@@ -24,14 +24,49 @@ 




#include <private/android/AHardwareBufferHelpers.h>

#include <private/android/AHardwareBufferHelpers.h>





#include <android/binder_libbinder.h>

#include <dlfcn.h>

#include <log/log.h>

#include <log/log.h>

#include <ui/GraphicBuffer.h>

#include <ui/GraphicBuffer.h>

#include <gui/Surface.h>

#include <gui/view/Surface.h>

#include <android/binder_libbinder.h>





using namespace android;

using namespace android;





#if defined(__ANDROID_APEX__) || defined(__ANDROID_VNDK__)

#error libnativewindow can only be built for system

#endif



using android_view_Surface_writeToParcel = status_t (*)(ANativeWindow* _Nonnull window,

                                                        Parcel* _Nonnull parcel);



using android_view_Surface_readFromParcel =

        status_t (*)(const Parcel* _Nonnull parcel, ANativeWindow* _Nullable* _Nonnull outWindow);



struct SurfaceParcelables {

    android_view_Surface_writeToParcel write = nullptr;

    android_view_Surface_readFromParcel read = nullptr;

};



const SurfaceParcelables* getSurfaceParcelFunctions() {

    static SurfaceParcelables funcs = []() -> SurfaceParcelables {

        SurfaceParcelables ret;

        void* dl = dlopen("libgui.so", RTLD_NOW);

        LOG_ALWAYS_FATAL_IF(!dl, "Failed to find libgui.so");

        ret.write =

                (android_view_Surface_writeToParcel)dlsym(dl, "android_view_Surface_writeToParcel");

        LOG_ALWAYS_FATAL_IF(!ret.write,

                            "libgui.so missing android_view_Surface_writeToParcel; "

                            "loaded wrong libgui?");

        ret.read =

                (android_view_Surface_readFromParcel)dlsym(dl,

                                                           "android_view_Surface_readFromParcel");

        LOG_ALWAYS_FATAL_IF(!ret.read,

                            "libgui.so missing android_view_Surface_readFromParcel; "

                            "loaded wrong libgui?");

        return ret;

    }();

    return &funcs;

}



static int32_t query(ANativeWindow* window, int what) {

static int32_t query(ANativeWindow* window, int what) {

    int value;

    int value;

    int res = window->query(window, what, &value);

    int res = window->query(window, what, &value);
@@ -64,13 +99,6 @@ static bool isDataSpaceValid(ANativeWindow* window, int32_t dataSpace) { 
            return false;

            return false;

    }

    }

}

}

static sp<IGraphicBufferProducer> IGraphicBufferProducer_from_ANativeWindow(ANativeWindow* window) {

    return Surface::getIGraphicBufferProducer(window);

}



static sp<IBinder> SurfaceControlHandle_from_ANativeWindow(ANativeWindow* window) {

    return Surface::getSurfaceControlHandle(window);

}





/**************************************************************************************************

/**************************************************************************************************

 * NDK

 * NDK
@@ -348,38 +376,24 @@ int ANativeWindow_setAutoPrerotation(ANativeWindow* window, bool autoPrerotation 




binder_status_t ANativeWindow_readFromParcel(

binder_status_t ANativeWindow_readFromParcel(

        const AParcel* _Nonnull parcel, ANativeWindow* _Nullable* _Nonnull outWindow) {

        const AParcel* _Nonnull parcel, ANativeWindow* _Nullable* _Nonnull outWindow) {

    const Parcel* nativeParcel = AParcel_viewPlatformParcel(parcel);

    auto funcs = getSurfaceParcelFunctions();



    if (funcs->read == nullptr) {

    // Use a android::view::Surface to unparcel the window

        ALOGE("Failed to load Surface_readFromParcel implementation");

    std::shared_ptr<android::view::Surface> shimSurface = std::shared_ptr<android::view::Surface>();

        return STATUS_FAILED_TRANSACTION;

    status_t ret = shimSurface->readFromParcel(nativeParcel);

    if (ret != OK) {

        ALOGE("%s: Error: Failed to create android::view::Surface from AParcel", __FUNCTION__);

        return STATUS_BAD_VALUE;

    }

    }

    sp<Surface> surface = sp<Surface>::make(

    const Parcel* nativeParcel = AParcel_viewPlatformParcel(parcel);

            shimSurface->graphicBufferProducer, false, shimSurface->surfaceControlHandle);

    return funcs->read(nativeParcel, outWindow);

    ANativeWindow* anw = surface.get();

    ANativeWindow_acquire(anw);

    *outWindow = anw;

    return STATUS_OK;

}

}





binder_status_t ANativeWindow_writeToParcel(

binder_status_t ANativeWindow_writeToParcel(

        ANativeWindow* _Nonnull window, AParcel* _Nonnull parcel) {

        ANativeWindow* _Nonnull window, AParcel* _Nonnull parcel) {

    int value;

    auto funcs = getSurfaceParcelFunctions();

    int err = (*window->query)(window, NATIVE_WINDOW_CONCRETE_TYPE, &value);

    if (funcs->write == nullptr) {

    if (err != OK || value != NATIVE_WINDOW_SURFACE) {

        ALOGE("Failed to load Surface_writeToParcel implementation");

        ALOGE("Error: ANativeWindow is not backed by Surface");

        return STATUS_FAILED_TRANSACTION;

        return STATUS_BAD_VALUE;

    }

    }

    // Use a android::view::Surface to parcelize the window

    std::shared_ptr<android::view::Surface> shimSurface = std::shared_ptr<android::view::Surface>();

    shimSurface->graphicBufferProducer = IGraphicBufferProducer_from_ANativeWindow(window);

    shimSurface->surfaceControlHandle = SurfaceControlHandle_from_ANativeWindow(window);



    Parcel* nativeParcel = AParcel_viewPlatformParcel(parcel);

    Parcel* nativeParcel = AParcel_viewPlatformParcel(parcel);

    return shimSurface->writeToParcel(nativeParcel);

    return funcs->write(window, nativeParcel);

}

}





/**************************************************************************************************

/**************************************************************************************************