Webview overlay support
The basic idea is to create a child surface control from the root surface control passed from ViewRootImpl to the render thread.
Transactions are sent back to the java layer to get merged.
In case of offscreen layers, SurfaceControl must be disabled.
This new feature is disabled for Vulkan at the moment, a new CL will be used to enable the support.
Bug: 173671170
Test: manual, webview apks
Change-Id: I119405d13eca3c59fd3ec78e50dc7739f78411d4
diff --git a/core/java/android/view/SurfaceControl.java b/core/java/android/view/SurfaceControl.java
index 2c81e89..4977a6e 100644
--- a/core/java/android/view/SurfaceControl.java
+++ b/core/java/android/view/SurfaceControl.java
@@ -2595,6 +2595,16 @@
= sRegistry.registerNativeAllocation(this, mNativeObject);
}
+ /**
+ * Create a transaction object that wraps a native peer.
+ * @hide
+ */
+ Transaction(long nativeObject) {
+ mNativeObject = nativeObject;
+ mFreeNativeResources =
+ sRegistry.registerNativeAllocation(this, mNativeObject);
+ }
+
private Transaction(Parcel in) {
readFromParcel(in);
}
diff --git a/core/java/android/view/ViewRootImpl.java b/core/java/android/view/ViewRootImpl.java
index be8e519..3cfda57 100644
--- a/core/java/android/view/ViewRootImpl.java
+++ b/core/java/android/view/ViewRootImpl.java
@@ -1355,6 +1355,16 @@
}
}
+ private void addASurfaceTransactionCallback() {
+ HardwareRenderer.ASurfaceTransactionCallback callback = (nativeTransactionObj,
+ nativeSurfaceControlObj,
+ frameNr) -> {
+ Transaction t = new Transaction(nativeTransactionObj);
+ mergeWithNextTransaction(t, frameNr);
+ };
+ mAttachInfo.mThreadedRenderer.setASurfaceTransactionCallback(callback);
+ }
+
@UnsupportedAppUsage
private void enableHardwareAcceleration(WindowManager.LayoutParams attrs) {
mAttachInfo.mHardwareAccelerated = false;
@@ -1391,6 +1401,7 @@
final boolean translucent = attrs.format != PixelFormat.OPAQUE || hasSurfaceInsets;
mAttachInfo.mThreadedRenderer = ThreadedRenderer.create(mContext, translucent,
attrs.getTitle().toString());
+ addASurfaceTransactionCallback();
mAttachInfo.mThreadedRenderer.setSurfaceControl(mSurfaceControl);
updateColorModeIfNeeded(attrs.getColorMode());
updateForceDarkMode();
diff --git a/graphics/java/android/graphics/HardwareRenderer.java b/graphics/java/android/graphics/HardwareRenderer.java
index f3dba82..8f1223b 100644
--- a/graphics/java/android/graphics/HardwareRenderer.java
+++ b/graphics/java/android/graphics/HardwareRenderer.java
@@ -754,6 +754,11 @@
}
/** @hide */
+ public void setASurfaceTransactionCallback(ASurfaceTransactionCallback callback) {
+ nSetASurfaceTransactionCallback(mNativeProxy, callback);
+ }
+
+ /** @hide */
public void setFrameCallback(FrameDrawingCallback callback) {
nSetFrameCallback(mNativeProxy, callback);
}
@@ -868,6 +873,23 @@
}
/**
+ * Interface used to receive callbacks when a transaction needs to be merged.
+ *
+ * @hide
+ */
+ public interface ASurfaceTransactionCallback {
+ /**
+ * Invoked during a frame drawing.
+ *
+ * @param aSurfaceTranactionNativeObj the ASurfaceTransaction native object handle
+ * @param aSurfaceControlNativeObj ASurfaceControl native object handle
+ * @param frame The id of the frame being drawn.
+ */
+ void onMergeTransaction(long aSurfaceTranactionNativeObj,
+ long aSurfaceControlNativeObj, long frame);
+ }
+
+ /**
* Interface used to receive callbacks when a frame is being drawn.
*
* @hide
@@ -1342,6 +1364,9 @@
private static native void nSetPictureCaptureCallback(long nativeProxy,
PictureCapturedCallback callback);
+ private static native void nSetASurfaceTransactionCallback(long nativeProxy,
+ ASurfaceTransactionCallback callback);
+
private static native void nSetFrameCallback(long nativeProxy, FrameDrawingCallback callback);
private static native void nSetFrameCompleteCallback(long nativeProxy,
diff --git a/libs/hwui/WebViewFunctorManager.cpp b/libs/hwui/WebViewFunctorManager.cpp
index 671c66f..979678d 100644
--- a/libs/hwui/WebViewFunctorManager.cpp
+++ b/libs/hwui/WebViewFunctorManager.cpp
@@ -18,6 +18,7 @@
#include <private/hwui/WebViewFunctor.h>
#include "Properties.h"
+#include "renderthread/CanvasContext.h"
#include "renderthread/RenderThread.h"
#include <log/log.h>
@@ -115,11 +116,20 @@
ScopedCurrentFunctor currentFunctor(this);
WebViewOverlayData overlayParams = {
- // TODO:
.overlaysMode = OverlaysMode::Disabled,
.getSurfaceControl = currentFunctor.getSurfaceControl,
.mergeTransaction = currentFunctor.mergeTransaction,
};
+
+ if (!drawInfo.isLayer) {
+ renderthread::CanvasContext* activeContext =
+ renderthread::CanvasContext::getActiveContext();
+ if (activeContext != nullptr) {
+ ASurfaceControl* rootSurfaceControl = activeContext->getSurfaceControl();
+ if (rootSurfaceControl) overlayParams.overlaysMode = OverlaysMode::Enabled;
+ }
+ }
+
mCallbacks.gles.draw(mFunctor, mData, drawInfo, overlayParams);
}
@@ -138,11 +148,12 @@
ScopedCurrentFunctor currentFunctor(this);
WebViewOverlayData overlayParams = {
- // TODO
.overlaysMode = OverlaysMode::Disabled,
.getSurfaceControl = currentFunctor.getSurfaceControl,
.mergeTransaction = currentFunctor.mergeTransaction,
};
+
+ // TODO, enable surface control once offscreen mode figured out
mCallbacks.vk.draw(mFunctor, mData, params, overlayParams);
}
@@ -166,15 +177,43 @@
void WebViewFunctor::removeOverlays() {
ScopedCurrentFunctor currentFunctor(this);
mCallbacks.removeOverlays(mFunctor, mData, currentFunctor.mergeTransaction);
+ if (mSurfaceControl) {
+ auto funcs = renderthread::RenderThread::getInstance().getASurfaceControlFunctions();
+ funcs.releaseFunc(mSurfaceControl);
+ mSurfaceControl = nullptr;
+ }
}
ASurfaceControl* WebViewFunctor::getSurfaceControl() {
- // TODO
- return nullptr;
+ ATRACE_NAME("WebViewFunctor::getSurfaceControl");
+ if (mSurfaceControl != nullptr) return mSurfaceControl;
+
+ renderthread::CanvasContext* activeContext = renderthread::CanvasContext::getActiveContext();
+ LOG_ALWAYS_FATAL_IF(activeContext == nullptr, "Null active canvas context!");
+
+ ASurfaceControl* rootSurfaceControl = activeContext->getSurfaceControl();
+ LOG_ALWAYS_FATAL_IF(rootSurfaceControl == nullptr, "Null root surface control!");
+
+ auto funcs = renderthread::RenderThread::getInstance().getASurfaceControlFunctions();
+ mSurfaceControl = funcs.createFunc(rootSurfaceControl, "Webview Overlay SurfaceControl");
+ ASurfaceTransaction* transaction = funcs.transactionCreateFunc();
+ funcs.transactionSetVisibilityFunc(transaction, mSurfaceControl,
+ ASURFACE_TRANSACTION_VISIBILITY_SHOW);
+ funcs.transactionApplyFunc(transaction);
+ funcs.transactionDeleteFunc(transaction);
+ return mSurfaceControl;
}
void WebViewFunctor::mergeTransaction(ASurfaceTransaction* transaction) {
- // TODO
+ ATRACE_NAME("WebViewFunctor::mergeTransaction");
+ if (transaction == nullptr) return;
+ renderthread::CanvasContext* activeContext = renderthread::CanvasContext::getActiveContext();
+ LOG_ALWAYS_FATAL_IF(activeContext == nullptr, "Null active canvas context!");
+ bool done = activeContext->mergeTransaction(transaction, mSurfaceControl);
+ if (!done) {
+ auto funcs = renderthread::RenderThread::getInstance().getASurfaceControlFunctions();
+ funcs.transactionApplyFunc(transaction);
+ }
}
WebViewFunctorManager& WebViewFunctorManager::instance() {
diff --git a/libs/hwui/WebViewFunctorManager.h b/libs/hwui/WebViewFunctorManager.h
index 17b936a..a84cda5 100644
--- a/libs/hwui/WebViewFunctorManager.h
+++ b/libs/hwui/WebViewFunctorManager.h
@@ -91,6 +91,7 @@
RenderMode mMode;
bool mHasContext = false;
bool mCreatedHandle = false;
+ ASurfaceControl* mSurfaceControl = nullptr;
};
class WebViewFunctorManager {
diff --git a/libs/hwui/jni/android_graphics_HardwareRenderer.cpp b/libs/hwui/jni/android_graphics_HardwareRenderer.cpp
index d859541..dd78d58 100644
--- a/libs/hwui/jni/android_graphics_HardwareRenderer.cpp
+++ b/libs/hwui/jni/android_graphics_HardwareRenderer.cpp
@@ -64,6 +64,10 @@
} gHardwareRenderer;
struct {
+ jmethodID onMergeTransaction;
+} gASurfaceTransactionCallback;
+
+struct {
jmethodID onFrameDraw;
} gFrameDrawingCallback;
@@ -509,6 +513,27 @@
}
}
+static void android_view_ThreadedRenderer_setASurfaceTransactionCallback(
+ JNIEnv* env, jobject clazz, jlong proxyPtr, jobject aSurfaceTransactionCallback) {
+ RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
+ if (!aSurfaceTransactionCallback) {
+ proxy->setASurfaceTransactionCallback(nullptr);
+ } else {
+ JavaVM* vm = nullptr;
+ LOG_ALWAYS_FATAL_IF(env->GetJavaVM(&vm) != JNI_OK, "Unable to get Java VM");
+ auto globalCallbackRef = std::make_shared<JGlobalRefHolder>(
+ vm, env->NewGlobalRef(aSurfaceTransactionCallback));
+ proxy->setASurfaceTransactionCallback(
+ [globalCallbackRef](int64_t transObj, int64_t scObj, int64_t frameNr) {
+ JNIEnv* env = getenv(globalCallbackRef->vm());
+ env->CallVoidMethod(globalCallbackRef->object(),
+ gASurfaceTransactionCallback.onMergeTransaction,
+ static_cast<jlong>(transObj), static_cast<jlong>(scObj),
+ static_cast<jlong>(frameNr));
+ });
+ }
+}
+
static void android_view_ThreadedRenderer_setFrameCallback(JNIEnv* env,
jobject clazz, jlong proxyPtr, jobject frameCallback) {
RenderProxy* proxy = reinterpret_cast<RenderProxy*>(proxyPtr);
@@ -762,8 +787,7 @@
{"nSetName", "(JLjava/lang/String;)V", (void*)android_view_ThreadedRenderer_setName},
{"nSetSurface", "(JLandroid/view/Surface;Z)V",
(void*)android_view_ThreadedRenderer_setSurface},
- {"nSetSurfaceControl", "(JJ)V",
- (void*)android_view_ThreadedRenderer_setSurfaceControl},
+ {"nSetSurfaceControl", "(JJ)V", (void*)android_view_ThreadedRenderer_setSurfaceControl},
{"nPause", "(J)Z", (void*)android_view_ThreadedRenderer_pause},
{"nSetStopped", "(JZ)V", (void*)android_view_ThreadedRenderer_setStopped},
{"nSetLightAlpha", "(JFF)V", (void*)android_view_ThreadedRenderer_setLightAlpha},
@@ -804,6 +828,9 @@
{"nSetPictureCaptureCallback",
"(JLandroid/graphics/HardwareRenderer$PictureCapturedCallback;)V",
(void*)android_view_ThreadedRenderer_setPictureCapturedCallbackJNI},
+ {"nSetASurfaceTransactionCallback",
+ "(JLandroid/graphics/HardwareRenderer$ASurfaceTransactionCallback;)V",
+ (void*)android_view_ThreadedRenderer_setASurfaceTransactionCallback},
{"nSetFrameCallback", "(JLandroid/graphics/HardwareRenderer$FrameDrawingCallback;)V",
(void*)android_view_ThreadedRenderer_setFrameCallback},
{"nSetFrameCompleteCallback",
@@ -866,6 +893,11 @@
GetStaticMethodIDOrDie(env, hardwareRenderer, "closeHintSession",
"(Landroid/os/PerformanceHintManager$Session;)V");
+ jclass aSurfaceTransactionCallbackClass =
+ FindClassOrDie(env, "android/graphics/HardwareRenderer$ASurfaceTransactionCallback");
+ gASurfaceTransactionCallback.onMergeTransaction =
+ GetMethodIDOrDie(env, aSurfaceTransactionCallbackClass, "onMergeTransaction", "(JJJ)V");
+
jclass frameCallbackClass = FindClassOrDie(env,
"android/graphics/HardwareRenderer$FrameDrawingCallback");
gFrameDrawingCallback.onFrameDraw = GetMethodIDOrDie(env, frameCallbackClass,
diff --git a/libs/hwui/renderthread/CanvasContext.cpp b/libs/hwui/renderthread/CanvasContext.cpp
index 2482188..bba2207 100644
--- a/libs/hwui/renderthread/CanvasContext.cpp
+++ b/libs/hwui/renderthread/CanvasContext.cpp
@@ -56,6 +56,22 @@
namespace uirenderer {
namespace renderthread {
+namespace {
+class ScopedActiveContext {
+public:
+ ScopedActiveContext(CanvasContext* context) { sActiveContext = context; }
+
+ ~ScopedActiveContext() { sActiveContext = nullptr; }
+
+ static CanvasContext* getActiveContext() { return sActiveContext; }
+
+private:
+ static CanvasContext* sActiveContext;
+};
+
+CanvasContext* ScopedActiveContext::sActiveContext = nullptr;
+} /* namespace */
+
CanvasContext* CanvasContext::create(RenderThread& thread, bool translucent,
RenderNode* rootRenderNode, IContextFactory* contextFactory) {
auto renderType = Properties::getRenderPipelineType();
@@ -473,6 +489,7 @@
return;
}
+ ScopedActiveContext activeContext(this);
mCurrentFrameInfo->set(FrameInfoIndex::FrameInterval) =
mRenderThread.timeLord().frameIntervalNanos();
@@ -880,6 +897,17 @@
return windowDirty;
}
+CanvasContext* CanvasContext::getActiveContext() {
+ return ScopedActiveContext::getActiveContext();
+}
+
+bool CanvasContext::mergeTransaction(ASurfaceTransaction* transaction, ASurfaceControl* control) {
+ if (!mASurfaceTransactionCallback) return false;
+ std::invoke(mASurfaceTransactionCallback, reinterpret_cast<int64_t>(transaction),
+ reinterpret_cast<int64_t>(control), getFrameNumber());
+ return true;
+}
+
} /* namespace renderthread */
} /* namespace uirenderer */
} /* namespace android */
diff --git a/libs/hwui/renderthread/CanvasContext.h b/libs/hwui/renderthread/CanvasContext.h
index 74f426e..af1ebb2 100644
--- a/libs/hwui/renderthread/CanvasContext.h
+++ b/libs/hwui/renderthread/CanvasContext.h
@@ -109,6 +109,8 @@
*/
GrDirectContext* getGrContext() const { return mRenderThread.getGrContext(); }
+ ASurfaceControl* getSurfaceControl() const { return mSurfaceControl; }
+
// Won't take effect until next EGLSurface creation
void setSwapBehavior(SwapBehavior swapBehavior);
@@ -201,6 +203,15 @@
static void onSurfaceStatsAvailable(void* context, ASurfaceControl* control,
ASurfaceControlStats* stats);
+ void setASurfaceTransactionCallback(
+ const std::function<void(int64_t, int64_t, int64_t)>& callback) {
+ mASurfaceTransactionCallback = callback;
+ }
+
+ bool mergeTransaction(ASurfaceTransaction* transaction, ASurfaceControl* control);
+
+ static CanvasContext* getActiveContext();
+
private:
CanvasContext(RenderThread& thread, bool translucent, RenderNode* rootRenderNode,
IContextFactory* contextFactory, std::unique_ptr<IRenderPipeline> renderPipeline);
@@ -296,6 +307,8 @@
// If set to true, we expect that callbacks into onSurfaceStatsAvailable
bool mExpectSurfaceStats = false;
+
+ std::function<void(int64_t, int64_t, int64_t)> mASurfaceTransactionCallback;
};
} /* namespace renderthread */
diff --git a/libs/hwui/renderthread/RenderProxy.cpp b/libs/hwui/renderthread/RenderProxy.cpp
index 9361abd..1b4b4b9 100644
--- a/libs/hwui/renderthread/RenderProxy.cpp
+++ b/libs/hwui/renderthread/RenderProxy.cpp
@@ -295,6 +295,12 @@
[this, cb = callback]() { mContext->setPictureCapturedCallback(cb); });
}
+void RenderProxy::setASurfaceTransactionCallback(
+ const std::function<void(int64_t, int64_t, int64_t)>& callback) {
+ mRenderThread.queue().post(
+ [this, cb = callback]() { mContext->setASurfaceTransactionCallback(cb); });
+}
+
void RenderProxy::setFrameCallback(std::function<void(int64_t)>&& callback) {
mDrawFrameTask.setFrameCallback(std::move(callback));
}
diff --git a/libs/hwui/renderthread/RenderProxy.h b/libs/hwui/renderthread/RenderProxy.h
index 8d55d3c..288f555 100644
--- a/libs/hwui/renderthread/RenderProxy.h
+++ b/libs/hwui/renderthread/RenderProxy.h
@@ -120,6 +120,8 @@
void drawRenderNode(RenderNode* node);
void setContentDrawBounds(int left, int top, int right, int bottom);
void setPictureCapturedCallback(const std::function<void(sk_sp<SkPicture>&&)>& callback);
+ void setASurfaceTransactionCallback(
+ const std::function<void(int64_t, int64_t, int64_t)>& callback);
void setFrameCallback(std::function<void(int64_t)>&& callback);
void setFrameCompleteCallback(std::function<void(int64_t)>&& callback);
diff --git a/libs/hwui/renderthread/RenderThread.cpp b/libs/hwui/renderthread/RenderThread.cpp
index 682baa6..04aa1cb 100644
--- a/libs/hwui/renderthread/RenderThread.cpp
+++ b/libs/hwui/renderthread/RenderThread.cpp
@@ -54,6 +54,10 @@
ASurfaceControlFunctions::ASurfaceControlFunctions() {
void* handle_ = dlopen("libandroid.so", RTLD_NOW | RTLD_NODELETE);
+ createFunc = (ASC_create)dlsym(handle_, "ASurfaceControl_create");
+ LOG_ALWAYS_FATAL_IF(createFunc == nullptr,
+ "Failed to find required symbol ASurfaceControl_create!");
+
acquireFunc = (ASC_acquire) dlsym(handle_, "ASurfaceControl_acquire");
LOG_ALWAYS_FATAL_IF(acquireFunc == nullptr,
"Failed to find required symbol ASurfaceControl_acquire!");
@@ -81,6 +85,23 @@
"ASurfaceControlStats_getFrameNumber");
LOG_ALWAYS_FATAL_IF(getFrameNumberFunc == nullptr,
"Failed to find required symbol ASurfaceControlStats_getFrameNumber!");
+
+ transactionCreateFunc = (AST_create)dlsym(handle_, "ASurfaceTransaction_create");
+ LOG_ALWAYS_FATAL_IF(transactionCreateFunc == nullptr,
+ "Failed to find required symbol ASurfaceTransaction_create!");
+
+ transactionDeleteFunc = (AST_delete)dlsym(handle_, "ASurfaceTransaction_delete");
+ LOG_ALWAYS_FATAL_IF(transactionDeleteFunc == nullptr,
+ "Failed to find required symbol ASurfaceTransaction_delete!");
+
+ transactionApplyFunc = (AST_apply)dlsym(handle_, "ASurfaceTransaction_apply");
+ LOG_ALWAYS_FATAL_IF(transactionApplyFunc == nullptr,
+ "Failed to find required symbol ASurfaceTransaction_apply!");
+
+ transactionSetVisibilityFunc =
+ (AST_setVisibility)dlsym(handle_, "ASurfaceTransaction_setVisibility");
+ LOG_ALWAYS_FATAL_IF(transactionSetVisibilityFunc == nullptr,
+ "Failed to find required symbol ASurfaceTransaction_setVisibility!");
}
void RenderThread::frameCallback(int64_t frameTimeNanos, void* data) {
diff --git a/libs/hwui/renderthread/RenderThread.h b/libs/hwui/renderthread/RenderThread.h
index 9e5bce7..cd9b923 100644
--- a/libs/hwui/renderthread/RenderThread.h
+++ b/libs/hwui/renderthread/RenderThread.h
@@ -79,25 +79,39 @@
virtual ~VsyncSource() {}
};
+typedef ASurfaceControl* (*ASC_create)(ASurfaceControl* parent, const char* debug_name);
typedef void (*ASC_acquire)(ASurfaceControl* control);
typedef void (*ASC_release)(ASurfaceControl* control);
typedef void (*ASC_registerSurfaceStatsListener)(ASurfaceControl* control, void* context,
ASurfaceControl_SurfaceStatsListener func);
typedef void (*ASC_unregisterSurfaceStatsListener)(void* context,
- ASurfaceControl_SurfaceStatsListener func);
+ ASurfaceControl_SurfaceStatsListener func);
typedef int64_t (*ASCStats_getAcquireTime)(ASurfaceControlStats* stats);
typedef uint64_t (*ASCStats_getFrameNumber)(ASurfaceControlStats* stats);
+typedef ASurfaceTransaction* (*AST_create)();
+typedef void (*AST_delete)(ASurfaceTransaction* transaction);
+typedef void (*AST_apply)(ASurfaceTransaction* transaction);
+typedef void (*AST_setVisibility)(ASurfaceTransaction* transaction,
+ ASurfaceControl* surface_control, int8_t visibility);
+
struct ASurfaceControlFunctions {
ASurfaceControlFunctions();
+
+ ASC_create createFunc;
ASC_acquire acquireFunc;
ASC_release releaseFunc;
ASC_registerSurfaceStatsListener registerListenerFunc;
ASC_unregisterSurfaceStatsListener unregisterListenerFunc;
ASCStats_getAcquireTime getAcquireTimeFunc;
ASCStats_getFrameNumber getFrameNumberFunc;
+
+ AST_create transactionCreateFunc;
+ AST_delete transactionDeleteFunc;
+ AST_apply transactionApplyFunc;
+ AST_setVisibility transactionSetVisibilityFunc;
};
class ChoreographerSource;