Merge "Don't request profile owner as user if we don't have a valid user"
diff --git a/api/current.txt b/api/current.txt
index 568f4c4..f750e33 100755
--- a/api/current.txt
+++ b/api/current.txt
@@ -41867,6 +41867,9 @@
field public static final java.lang.String KEY_ALWAYS_SHOW_EMERGENCY_ALERT_ONOFF_BOOL = "always_show_emergency_alert_onoff_bool";
field public static final java.lang.String KEY_APN_EXPAND_BOOL = "apn_expand_bool";
field public static final java.lang.String KEY_AUTO_RETRY_ENABLED_BOOL = "auto_retry_enabled_bool";
+ field public static final java.lang.String KEY_CALL_BARRING_SUPPORTS_DEACTIVATE_ALL_BOOL = "call_barring_supports_deactivate_all_bool";
+ field public static final java.lang.String KEY_CALL_BARRING_SUPPORTS_PASSWORD_CHANGE_BOOL = "call_barring_supports_password_change_bool";
+ field public static final java.lang.String KEY_CALL_BARRING_VISIBILITY_BOOL = "call_barring_visibility_bool";
field public static final java.lang.String KEY_CALL_FORWARDING_BLOCKS_WHILE_ROAMING_STRING_ARRAY = "call_forwarding_blocks_while_roaming_string_array";
field public static final java.lang.String KEY_CARRIER_ALLOW_TURNOFF_IMS_BOOL = "carrier_allow_turnoff_ims_bool";
field public static final java.lang.String KEY_CARRIER_DATA_CALL_PERMANENT_FAILURE_STRINGS = "carrier_data_call_permanent_failure_strings";
@@ -44486,6 +44489,11 @@
method public abstract void chooseHeight(java.lang.CharSequence, int, int, int, int, android.graphics.Paint.FontMetricsInt);
}
+ public static class LineHeightSpan.Standard implements android.text.style.LineHeightSpan {
+ ctor public LineHeightSpan.Standard(int);
+ method public void chooseHeight(java.lang.CharSequence, int, int, int, int, android.graphics.Paint.FontMetricsInt);
+ }
+
public static abstract interface LineHeightSpan.WithDensity implements android.text.style.LineHeightSpan {
method public abstract void chooseHeight(java.lang.CharSequence, int, int, int, int, android.graphics.Paint.FontMetricsInt, android.text.TextPaint);
}
diff --git a/core/java/android/inputmethodservice/InputMethodService.java b/core/java/android/inputmethodservice/InputMethodService.java
index 46671b2..9295bb7 100644
--- a/core/java/android/inputmethodservice/InputMethodService.java
+++ b/core/java/android/inputmethodservice/InputMethodService.java
@@ -62,7 +62,6 @@
import android.view.ViewTreeObserver;
import android.view.Window;
import android.view.WindowManager;
-import android.view.WindowManager.BadTokenException;
import android.view.animation.AnimationUtils;
import android.view.inputmethod.CompletionInfo;
import android.view.inputmethod.CursorAnchorInfo;
@@ -354,7 +353,6 @@
SoftInputWindow mWindow;
boolean mInitialized;
boolean mWindowCreated;
- boolean mWindowAdded;
boolean mWindowVisible;
boolean mWindowWasVisible;
boolean mInShowWindow;
@@ -559,16 +557,7 @@
if (DEBUG) Log.v(TAG, "showSoftInput()");
boolean wasVis = isInputViewShown();
if (dispatchOnShowInputRequested(flags, false)) {
- try {
- showWindow(true);
- } catch (BadTokenException e) {
- // We have ignored BadTokenException here since Jelly Bean MR-2 (API Level 18).
- // We could ignore BadTokenException in InputMethodService#showWindow() instead,
- // but it may break assumptions for those who override #showWindow() that we can
- // detect errors in #showWindow() by checking BadTokenException.
- // TODO: Investigate its feasibility. Update JavaDoc of #showWindow() of
- // whether it's OK to override #showWindow() or not.
- }
+ showWindow(true);
}
clearInsetOfPreviousIme();
// If user uses hard keyboard, IME button should always be shown.
@@ -986,13 +975,7 @@
mRootView.getViewTreeObserver().removeOnComputeInternalInsetsListener(
mInsetsComputer);
doFinishInput();
- if (mWindowAdded) {
- // Disable exit animation for the current IME window
- // to avoid the race condition between the exit and enter animations
- // when the current IME is being switched to another one.
- mWindow.getWindow().setWindowAnimations(0);
- mWindow.dismiss();
- }
+ mWindow.dismissForDestroyIfNecessary();
if (mSettingsObserver != null) {
mSettingsObserver.unregister();
mSettingsObserver = null;
@@ -1778,7 +1761,6 @@
public void showWindow(boolean showInput) {
if (DEBUG) Log.v(TAG, "Showing window: showInput=" + showInput
+ " mShowInputRequested=" + mShowInputRequested
- + " mWindowAdded=" + mWindowAdded
+ " mWindowCreated=" + mWindowCreated
+ " mWindowVisible=" + mWindowVisible
+ " mInputStarted=" + mInputStarted
@@ -1788,27 +1770,12 @@
Log.w(TAG, "Re-entrance in to showWindow");
return;
}
-
- try {
- mWindowWasVisible = mWindowVisible;
- mInShowWindow = true;
- showWindowInner(showInput);
- } catch (BadTokenException e) {
- // BadTokenException is a normal consequence in certain situations, e.g., swapping IMEs
- // while there is a DO_SHOW_SOFT_INPUT message in the IIMethodWrapper queue.
- if (DEBUG) Log.v(TAG, "BadTokenException: IME is done.");
- mWindowVisible = false;
- mWindowAdded = false;
- // Rethrow the exception to preserve the existing behavior. Some IMEs may have directly
- // called this method and relied on this exception for some clean-up tasks.
- // TODO: Give developers a clear guideline of whether it's OK to call this method or
- // InputMethodService#requestShowSelf(int) should always be used instead.
- throw e;
- } finally {
- // TODO: Is it OK to set true when we get BadTokenException?
- mWindowWasVisible = true;
- mInShowWindow = false;
- }
+
+ mWindowWasVisible = mWindowVisible;
+ mInShowWindow = true;
+ showWindowInner(showInput);
+ mWindowWasVisible = true;
+ mInShowWindow = false;
}
void showWindowInner(boolean showInput) {
@@ -1825,9 +1792,8 @@
initialize();
updateFullscreenMode();
updateInputViewShown();
-
- if (!mWindowAdded || !mWindowCreated) {
- mWindowAdded = true;
+
+ if (!mWindowCreated) {
mWindowCreated = true;
initialize();
if (DEBUG) Log.v(TAG, "CALL: onCreateCandidatesView");
@@ -2852,8 +2818,7 @@
@Override protected void dump(FileDescriptor fd, PrintWriter fout, String[] args) {
final Printer p = new PrintWriterPrinter(fout);
p.println("Input method service state for " + this + ":");
- p.println(" mWindowCreated=" + mWindowCreated
- + " mWindowAdded=" + mWindowAdded);
+ p.println(" mWindowCreated=" + mWindowCreated);
p.println(" mWindowVisible=" + mWindowVisible
+ " mWindowWasVisible=" + mWindowWasVisible
+ " mInShowWindow=" + mInShowWindow);
diff --git a/core/java/android/inputmethodservice/SoftInputWindow.java b/core/java/android/inputmethodservice/SoftInputWindow.java
index 795117e..b4b8887 100644
--- a/core/java/android/inputmethodservice/SoftInputWindow.java
+++ b/core/java/android/inputmethodservice/SoftInputWindow.java
@@ -16,15 +16,22 @@
package android.inputmethodservice;
+import static java.lang.annotation.RetentionPolicy.SOURCE;
+
+import android.annotation.IntDef;
import android.app.Dialog;
import android.content.Context;
import android.graphics.Rect;
+import android.os.Debug;
import android.os.IBinder;
+import android.util.Log;
import android.view.Gravity;
import android.view.KeyEvent;
import android.view.MotionEvent;
import android.view.WindowManager;
+import java.lang.annotation.Retention;
+
/**
* A SoftInputWindow is a Dialog that is intended to be used for a top-level input
* method window. It will be displayed along the edge of the screen, moving
@@ -33,6 +40,9 @@
* @hide
*/
public class SoftInputWindow extends Dialog {
+ private static final boolean DEBUG = false;
+ private static final String TAG = "SoftInputWindow";
+
final String mName;
final Callback mCallback;
final KeyEvent.Callback mKeyEventCallback;
@@ -42,16 +52,65 @@
final boolean mTakesFocus;
private final Rect mBounds = new Rect();
+ @Retention(SOURCE)
+ @IntDef(value = {SoftInputWindowState.TOKEN_PENDING, SoftInputWindowState.TOKEN_SET,
+ SoftInputWindowState.SHOWN_AT_LEAST_ONCE, SoftInputWindowState.REJECTED_AT_LEAST_ONCE})
+ private @interface SoftInputWindowState {
+ /**
+ * The window token is not set yet.
+ */
+ int TOKEN_PENDING = 0;
+ /**
+ * The window token was set, but the window is not shown yet.
+ */
+ int TOKEN_SET = 1;
+ /**
+ * The window was shown at least once.
+ */
+ int SHOWN_AT_LEAST_ONCE = 2;
+ /**
+ * {@link android.view.WindowManager.BadTokenException} was sent when calling
+ * {@link Dialog#show()} at least once.
+ */
+ int REJECTED_AT_LEAST_ONCE = 3;
+ /**
+ * The window is considered destroyed. Any incoming request should be ignored.
+ */
+ int DESTROYED = 4;
+ }
+
+ @SoftInputWindowState
+ private int mWindowState = SoftInputWindowState.TOKEN_PENDING;
+
public interface Callback {
public void onBackPressed();
}
public void setToken(IBinder token) {
- WindowManager.LayoutParams lp = getWindow().getAttributes();
- lp.token = token;
- getWindow().setAttributes(lp);
+ switch (mWindowState) {
+ case SoftInputWindowState.TOKEN_PENDING:
+ // Normal scenario. Nothing to worry about.
+ WindowManager.LayoutParams lp = getWindow().getAttributes();
+ lp.token = token;
+ getWindow().setAttributes(lp);
+ updateWindowState(SoftInputWindowState.TOKEN_SET);
+ return;
+ case SoftInputWindowState.TOKEN_SET:
+ case SoftInputWindowState.SHOWN_AT_LEAST_ONCE:
+ case SoftInputWindowState.REJECTED_AT_LEAST_ONCE:
+ throw new IllegalStateException("setToken can be called only once");
+ case SoftInputWindowState.DESTROYED:
+ // Just ignore. Since there are multiple event queues from the token is issued
+ // in the system server to the timing when it arrives here, it can be delivered
+ // after the is already destroyed. No one should be blamed because of such an
+ // unfortunate but possible scenario.
+ Log.i(TAG, "Ignoring setToken() because window is already destroyed.");
+ return;
+ default:
+ throw new IllegalStateException("Unexpected state=" + mWindowState);
+ }
}
-
+
/**
* Create a SoftInputWindow that uses a custom style.
*
@@ -190,4 +249,109 @@
getWindow().setFlags(windowSetFlags, windowModFlags);
}
+
+ @Override
+ public final void show() {
+ switch (mWindowState) {
+ case SoftInputWindowState.TOKEN_PENDING:
+ throw new IllegalStateException("Window token is not set yet.");
+ case SoftInputWindowState.TOKEN_SET:
+ case SoftInputWindowState.SHOWN_AT_LEAST_ONCE:
+ // Normal scenario. Nothing to worry about.
+ try {
+ super.show();
+ updateWindowState(SoftInputWindowState.SHOWN_AT_LEAST_ONCE);
+ } catch (WindowManager.BadTokenException e) {
+ // Just ignore this exception. Since show() can be requested from other
+ // components such as the system and there could be multiple event queues before
+ // the request finally arrives here, the system may have already invalidated the
+ // window token attached to our window. In such a scenario, receiving
+ // BadTokenException here is an expected behavior. We just ignore it and update
+ // the state so that we do not touch this window later.
+ Log.i(TAG, "Probably the IME window token is already invalidated."
+ + " show() does nothing.");
+ updateWindowState(SoftInputWindowState.REJECTED_AT_LEAST_ONCE);
+ }
+ return;
+ case SoftInputWindowState.REJECTED_AT_LEAST_ONCE:
+ // Just ignore. In general we cannot completely avoid this kind of race condition.
+ Log.i(TAG, "Not trying to call show() because it was already rejected once.");
+ return;
+ case SoftInputWindowState.DESTROYED:
+ // Just ignore. In general we cannot completely avoid this kind of race condition.
+ Log.i(TAG, "Ignoring show() because the window is already destroyed.");
+ return;
+ default:
+ throw new IllegalStateException("Unexpected state=" + mWindowState);
+ }
+ }
+
+ final void dismissForDestroyIfNecessary() {
+ switch (mWindowState) {
+ case SoftInputWindowState.TOKEN_PENDING:
+ case SoftInputWindowState.TOKEN_SET:
+ // nothing to do because the window has never been shown.
+ updateWindowState(SoftInputWindowState.DESTROYED);
+ return;
+ case SoftInputWindowState.SHOWN_AT_LEAST_ONCE:
+ // Disable exit animation for the current IME window
+ // to avoid the race condition between the exit and enter animations
+ // when the current IME is being switched to another one.
+ try {
+ getWindow().setWindowAnimations(0);
+ dismiss();
+ } catch (WindowManager.BadTokenException e) {
+ // Just ignore this exception. Since show() can be requested from other
+ // components such as the system and there could be multiple event queues before
+ // the request finally arrives here, the system may have already invalidated the
+ // window token attached to our window. In such a scenario, receiving
+ // BadTokenException here is an expected behavior. We just ignore it and update
+ // the state so that we do not touch this window later.
+ Log.i(TAG, "Probably the IME window token is already invalidated. "
+ + "No need to dismiss it.");
+ }
+ // Either way, consider that the window is destroyed.
+ updateWindowState(SoftInputWindowState.DESTROYED);
+ return;
+ case SoftInputWindowState.REJECTED_AT_LEAST_ONCE:
+ // Just ignore. In general we cannot completely avoid this kind of race condition.
+ Log.i(TAG,
+ "Not trying to dismiss the window because it is most likely unnecessary.");
+ // Anyway, consider that the window is destroyed.
+ updateWindowState(SoftInputWindowState.DESTROYED);
+ return;
+ case SoftInputWindowState.DESTROYED:
+ throw new IllegalStateException(
+ "dismissForDestroyIfNecessary can be called only once");
+ default:
+ throw new IllegalStateException("Unexpected state=" + mWindowState);
+ }
+ }
+
+ private void updateWindowState(@SoftInputWindowState int newState) {
+ if (DEBUG) {
+ if (mWindowState != newState) {
+ Log.d(TAG, "WindowState: " + stateToString(mWindowState) + " -> "
+ + stateToString(newState) + " @ " + Debug.getCaller());
+ }
+ }
+ mWindowState = newState;
+ }
+
+ private static String stateToString(@SoftInputWindowState int state) {
+ switch (state) {
+ case SoftInputWindowState.TOKEN_PENDING:
+ return "TOKEN_PENDING";
+ case SoftInputWindowState.TOKEN_SET:
+ return "TOKEN_SET";
+ case SoftInputWindowState.SHOWN_AT_LEAST_ONCE:
+ return "SHOWN_AT_LEAST_ONCE";
+ case SoftInputWindowState.REJECTED_AT_LEAST_ONCE:
+ return "REJECTED_AT_LEAST_ONCE";
+ case SoftInputWindowState.DESTROYED:
+ return "DESTROYED";
+ default:
+ throw new IllegalStateException("Unknown state=" + state);
+ }
+ }
}
diff --git a/core/java/android/text/style/LineHeightSpan.java b/core/java/android/text/style/LineHeightSpan.java
index 50ee5f3..2742ae0 100644
--- a/core/java/android/text/style/LineHeightSpan.java
+++ b/core/java/android/text/style/LineHeightSpan.java
@@ -16,11 +16,16 @@
package android.text.style;
+import android.annotation.IntRange;
+import android.annotation.NonNull;
+import android.annotation.Px;
import android.graphics.Paint;
import android.text.TextPaint;
+import com.android.internal.util.Preconditions;
+
/**
- * The classes that affect the height of the line should implement this interface.
+ * The classes that affect the line height of paragraph should implement this interface.
*/
public interface LineHeightSpan extends ParagraphStyle, WrapTogetherSpan {
/**
@@ -38,8 +43,8 @@
Paint.FontMetricsInt fm);
/**
- * The classes that affect the height of the line with respect to density, should implement this
- * interface.
+ * The classes that affect the line height of paragraph with respect to density,
+ * should implement this interface.
*/
public interface WithDensity extends LineHeightSpan {
@@ -57,4 +62,38 @@
int spanstartv, int lineHeight,
Paint.FontMetricsInt fm, TextPaint paint);
}
+
+ /**
+ * Default implementation of the {@link LineHeightSpan}, which changes the line height of the
+ * attached paragraph.
+ * <p>
+ * LineHeightSpan will change the line height of the entire paragraph, even though it
+ * covers only part of the paragraph.
+ * </p>
+ */
+ class Standard implements LineHeightSpan {
+
+ private final @Px int mHeight;
+ /**
+ * Set the line height of the paragraph to <code>height</code> physical pixels.
+ */
+ public Standard(@Px @IntRange(from = 1) int height) {
+ Preconditions.checkArgument(height > 0, "Height:" + height + "must be positive");
+ mHeight = height;
+ }
+
+ @Override
+ public void chooseHeight(@NonNull CharSequence text, int start, int end,
+ int spanstartv, int lineHeight,
+ @NonNull Paint.FontMetricsInt fm) {
+ final int originHeight = fm.descent - fm.ascent;
+ // If original height is not positive, do nothing.
+ if (originHeight <= 0) {
+ return;
+ }
+ final float ratio = mHeight * 1.0f / originHeight;
+ fm.descent = Math.round(fm.descent * ratio);
+ fm.ascent = fm.descent - mHeight;
+ }
+ }
}
diff --git a/core/jni/android/graphics/ColorFilter.cpp b/core/jni/android/graphics/ColorFilter.cpp
index 6ebf35c..3fcedd0 100644
--- a/core/jni/android/graphics/ColorFilter.cpp
+++ b/core/jni/android/graphics/ColorFilter.cpp
@@ -22,6 +22,8 @@
#include "SkColorFilter.h"
#include "SkColorMatrixFilter.h"
+#include <Caches.h>
+
namespace android {
using namespace uirenderer;
diff --git a/core/jni/android/graphics/Matrix.cpp b/core/jni/android/graphics/Matrix.cpp
index 755fcfb..f8bb77a 100644
--- a/core/jni/android/graphics/Matrix.cpp
+++ b/core/jni/android/graphics/Matrix.cpp
@@ -20,6 +20,7 @@
#include "SkMatrix.h"
#include "core_jni_helpers.h"
+#include <Caches.h>
#include <jni.h>
namespace android {
diff --git a/core/jni/android/graphics/Shader.cpp b/core/jni/android/graphics/Shader.cpp
index 68f5bef..cff7720 100644
--- a/core/jni/android/graphics/Shader.cpp
+++ b/core/jni/android/graphics/Shader.cpp
@@ -6,6 +6,7 @@
#include "SkBlendMode.h"
#include "core_jni_helpers.h"
+#include <Caches.h>
#include <jni.h>
using namespace android::uirenderer;
diff --git a/core/jni/android/graphics/SurfaceTexture.cpp b/core/jni/android/graphics/SurfaceTexture.cpp
index 3e464c6..d098a35 100644
--- a/core/jni/android/graphics/SurfaceTexture.cpp
+++ b/core/jni/android/graphics/SurfaceTexture.cpp
@@ -36,7 +36,6 @@
#include "jni.h"
#include <nativehelper/JNIHelp.h>
#include <nativehelper/ScopedLocalRef.h>
-#include "surfacetexture/SurfaceTexture.h"
// ----------------------------------------------------------------------------
@@ -81,10 +80,10 @@
// ----------------------------------------------------------------------------
static void SurfaceTexture_setSurfaceTexture(JNIEnv* env, jobject thiz,
- const sp<SurfaceTexture>& surfaceTexture)
+ const sp<GLConsumer>& surfaceTexture)
{
- SurfaceTexture* const p =
- (SurfaceTexture*)env->GetLongField(thiz, fields.surfaceTexture);
+ GLConsumer* const p =
+ (GLConsumer*)env->GetLongField(thiz, fields.surfaceTexture);
if (surfaceTexture.get()) {
surfaceTexture->incStrong((void*)SurfaceTexture_setSurfaceTexture);
}
@@ -109,10 +108,10 @@
}
static void SurfaceTexture_setFrameAvailableListener(JNIEnv* env,
- jobject thiz, sp<SurfaceTexture::FrameAvailableListener> listener)
+ jobject thiz, sp<GLConsumer::FrameAvailableListener> listener)
{
- SurfaceTexture::FrameAvailableListener* const p =
- (SurfaceTexture::FrameAvailableListener*)
+ GLConsumer::FrameAvailableListener* const p =
+ (GLConsumer::FrameAvailableListener*)
env->GetLongField(thiz, fields.frameAvailableListener);
if (listener.get()) {
listener->incStrong((void*)SurfaceTexture_setSurfaceTexture);
@@ -123,8 +122,8 @@
env->SetLongField(thiz, fields.frameAvailableListener, (jlong)listener.get());
}
-sp<SurfaceTexture> SurfaceTexture_getSurfaceTexture(JNIEnv* env, jobject thiz) {
- return (SurfaceTexture*)env->GetLongField(thiz, fields.surfaceTexture);
+sp<GLConsumer> SurfaceTexture_getSurfaceTexture(JNIEnv* env, jobject thiz) {
+ return (GLConsumer*)env->GetLongField(thiz, fields.surfaceTexture);
}
sp<IGraphicBufferProducer> SurfaceTexture_getProducer(JNIEnv* env, jobject thiz) {
@@ -132,7 +131,7 @@
}
sp<ANativeWindow> android_SurfaceTexture_getNativeWindow(JNIEnv* env, jobject thiz) {
- sp<SurfaceTexture> surfaceTexture(SurfaceTexture_getSurfaceTexture(env, thiz));
+ sp<GLConsumer> surfaceTexture(SurfaceTexture_getSurfaceTexture(env, thiz));
sp<IGraphicBufferProducer> producer(SurfaceTexture_getProducer(env, thiz));
sp<Surface> surfaceTextureClient(surfaceTexture != NULL ? new Surface(producer) : NULL);
return surfaceTextureClient;
@@ -145,7 +144,7 @@
// ----------------------------------------------------------------------------
-class JNISurfaceTextureContext : public SurfaceTexture::FrameAvailableListener
+class JNISurfaceTextureContext : public GLConsumer::FrameAvailableListener
{
public:
JNISurfaceTextureContext(JNIEnv* env, jobject weakThiz, jclass clazz);
@@ -267,12 +266,12 @@
consumer->setMaxBufferCount(1);
}
- sp<SurfaceTexture> surfaceTexture;
+ sp<GLConsumer> surfaceTexture;
if (isDetached) {
- surfaceTexture = new SurfaceTexture(consumer, GL_TEXTURE_EXTERNAL_OES,
+ surfaceTexture = new GLConsumer(consumer, GL_TEXTURE_EXTERNAL_OES,
true, !singleBufferMode);
} else {
- surfaceTexture = new SurfaceTexture(consumer, texName,
+ surfaceTexture = new GLConsumer(consumer, texName,
GL_TEXTURE_EXTERNAL_OES, true, !singleBufferMode);
}
@@ -307,7 +306,7 @@
static void SurfaceTexture_finalize(JNIEnv* env, jobject thiz)
{
- sp<SurfaceTexture> surfaceTexture(SurfaceTexture_getSurfaceTexture(env, thiz));
+ sp<GLConsumer> surfaceTexture(SurfaceTexture_getSurfaceTexture(env, thiz));
surfaceTexture->setFrameAvailableListener(0);
SurfaceTexture_setFrameAvailableListener(env, thiz, 0);
SurfaceTexture_setSurfaceTexture(env, thiz, 0);
@@ -316,13 +315,13 @@
static void SurfaceTexture_setDefaultBufferSize(
JNIEnv* env, jobject thiz, jint width, jint height) {
- sp<SurfaceTexture> surfaceTexture(SurfaceTexture_getSurfaceTexture(env, thiz));
+ sp<GLConsumer> surfaceTexture(SurfaceTexture_getSurfaceTexture(env, thiz));
surfaceTexture->setDefaultBufferSize(width, height);
}
static void SurfaceTexture_updateTexImage(JNIEnv* env, jobject thiz)
{
- sp<SurfaceTexture> surfaceTexture(SurfaceTexture_getSurfaceTexture(env, thiz));
+ sp<GLConsumer> surfaceTexture(SurfaceTexture_getSurfaceTexture(env, thiz));
status_t err = surfaceTexture->updateTexImage();
if (err == INVALID_OPERATION) {
jniThrowException(env, IllegalStateException, "Unable to update texture contents (see "
@@ -334,7 +333,7 @@
static void SurfaceTexture_releaseTexImage(JNIEnv* env, jobject thiz)
{
- sp<SurfaceTexture> surfaceTexture(SurfaceTexture_getSurfaceTexture(env, thiz));
+ sp<GLConsumer> surfaceTexture(SurfaceTexture_getSurfaceTexture(env, thiz));
status_t err = surfaceTexture->releaseTexImage();
if (err == INVALID_OPERATION) {
jniThrowException(env, IllegalStateException, "Unable to release texture contents (see "
@@ -346,20 +345,20 @@
static jint SurfaceTexture_detachFromGLContext(JNIEnv* env, jobject thiz)
{
- sp<SurfaceTexture> surfaceTexture(SurfaceTexture_getSurfaceTexture(env, thiz));
+ sp<GLConsumer> surfaceTexture(SurfaceTexture_getSurfaceTexture(env, thiz));
return surfaceTexture->detachFromContext();
}
static jint SurfaceTexture_attachToGLContext(JNIEnv* env, jobject thiz, jint tex)
{
- sp<SurfaceTexture> surfaceTexture(SurfaceTexture_getSurfaceTexture(env, thiz));
+ sp<GLConsumer> surfaceTexture(SurfaceTexture_getSurfaceTexture(env, thiz));
return surfaceTexture->attachToContext((GLuint)tex);
}
static void SurfaceTexture_getTransformMatrix(JNIEnv* env, jobject thiz,
jfloatArray jmtx)
{
- sp<SurfaceTexture> surfaceTexture(SurfaceTexture_getSurfaceTexture(env, thiz));
+ sp<GLConsumer> surfaceTexture(SurfaceTexture_getSurfaceTexture(env, thiz));
float* mtx = env->GetFloatArrayElements(jmtx, NULL);
surfaceTexture->getTransformMatrix(mtx);
env->ReleaseFloatArrayElements(jmtx, mtx, 0);
@@ -367,19 +366,19 @@
static jlong SurfaceTexture_getTimestamp(JNIEnv* env, jobject thiz)
{
- sp<SurfaceTexture> surfaceTexture(SurfaceTexture_getSurfaceTexture(env, thiz));
+ sp<GLConsumer> surfaceTexture(SurfaceTexture_getSurfaceTexture(env, thiz));
return surfaceTexture->getTimestamp();
}
static void SurfaceTexture_release(JNIEnv* env, jobject thiz)
{
- sp<SurfaceTexture> surfaceTexture(SurfaceTexture_getSurfaceTexture(env, thiz));
+ sp<GLConsumer> surfaceTexture(SurfaceTexture_getSurfaceTexture(env, thiz));
surfaceTexture->abandon();
}
static jboolean SurfaceTexture_isReleased(JNIEnv* env, jobject thiz)
{
- sp<SurfaceTexture> surfaceTexture(SurfaceTexture_getSurfaceTexture(env, thiz));
+ sp<GLConsumer> surfaceTexture(SurfaceTexture_getSurfaceTexture(env, thiz));
return surfaceTexture->isAbandoned();
}
diff --git a/core/jni/android_view_TextureLayer.cpp b/core/jni/android_view_TextureLayer.cpp
index 1ccb6a8..d3a447f 100644
--- a/core/jni/android_view_TextureLayer.cpp
+++ b/core/jni/android_view_TextureLayer.cpp
@@ -67,7 +67,8 @@
static void TextureLayer_setSurfaceTexture(JNIEnv* env, jobject clazz,
jlong layerUpdaterPtr, jobject surface) {
DeferredLayerUpdater* layer = reinterpret_cast<DeferredLayerUpdater*>(layerUpdaterPtr);
- layer->setSurfaceTexture(SurfaceTexture_getSurfaceTexture(env, surface));
+ sp<GLConsumer> surfaceTexture(SurfaceTexture_getSurfaceTexture(env, surface));
+ layer->setSurfaceTexture(surfaceTexture);
}
static void TextureLayer_updateSurfaceTexture(JNIEnv* env, jobject clazz,
diff --git a/core/jni/include/android_runtime/android_graphics_SurfaceTexture.h b/core/jni/include/android_runtime/android_graphics_SurfaceTexture.h
index 0ad2587..c534d4b 100644
--- a/core/jni/include/android_runtime/android_graphics_SurfaceTexture.h
+++ b/core/jni/include/android_runtime/android_graphics_SurfaceTexture.h
@@ -23,14 +23,14 @@
namespace android {
+class GLConsumer;
class IGraphicBufferProducer;
-class SurfaceTexture;
extern sp<ANativeWindow> android_SurfaceTexture_getNativeWindow(JNIEnv* env, jobject thiz);
extern bool android_SurfaceTexture_isInstanceOf(JNIEnv* env, jobject thiz);
-/* Gets the underlying C++ SurfaceTexture object from a SurfaceTexture Java object. */
-extern sp<SurfaceTexture> SurfaceTexture_getSurfaceTexture(JNIEnv* env, jobject thiz);
+/* Gets the underlying GLConsumer from a SurfaceTexture Java object. */
+extern sp<GLConsumer> SurfaceTexture_getSurfaceTexture(JNIEnv* env, jobject thiz);
/* gets the producer end of the SurfaceTexture */
extern sp<IGraphicBufferProducer> SurfaceTexture_getProducer(JNIEnv* env, jobject thiz);
diff --git a/core/res/res/values/strings.xml b/core/res/res/values/strings.xml
index d733207..365e4a4 100644
--- a/core/res/res/values/strings.xml
+++ b/core/res/res/values/strings.xml
@@ -2881,55 +2881,55 @@
<!-- Title for EditText context menu [CHAR LIMIT=20] -->
<string name="editTextMenuTitle">Text actions</string>
- <!-- Label for item in the text selection menu to trigger an Email app [CHAR LIMIT=20] -->
+ <!-- Label for item in the text selection menu to trigger an Email app. Should be a verb. [CHAR LIMIT=20] -->
<string name="email">Email</string>
<!-- Accessibility description for an item in the text selection menu to trigger an Email app [CHAR LIMIT=NONE] -->
<string name="email_desc">Email selected address</string>
- <!-- Label for item in the text selection menu to trigger a Dialer app [CHAR LIMIT=20] -->
+ <!-- Label for item in the text selection menu to trigger a Dialer app. Should be a verb. [CHAR LIMIT=20] -->
<string name="dial">Call</string>
<!-- Accessibility description for an item in the text selection menu to call a phone number [CHAR LIMIT=NONE] -->
<string name="dial_desc">Call selected phone number</string>
- <!-- Label for item in the text selection menu to trigger a Map app [CHAR LIMIT=20] -->
+ <!-- Label for item in the text selection menu to trigger a Map app. Should be a verb. [CHAR LIMIT=20] -->
<string name="map">Map</string>
<!-- Accessibility description for an item in the text selection menu to open maps for an address [CHAR LIMIT=NONE] -->
<string name="map_desc">Locate selected address</string>
- <!-- Label for item in the text selection menu to trigger a Browser app [CHAR LIMIT=20] -->
+ <!-- Label for item in the text selection menu to trigger a Browser app. Should be a verb. [CHAR LIMIT=20] -->
<string name="browse">Open</string>
<!-- Accessibility description for an item in the text selection menu to open a URL in a browser [CHAR LIMIT=NONE] -->
<string name="browse_desc">Open selected URL</string>
- <!-- Label for item in the text selection menu to trigger an SMS app [CHAR LIMIT=20] -->
+ <!-- Label for item in the text selection menu to trigger an SMS app. Should be a verb. [CHAR LIMIT=20] -->
<string name="sms">Message</string>
<!-- Accessibility description for an item in the text selection menu to send an SMS to a phone number [CHAR LIMIT=NONE] -->
<string name="sms_desc">Message selected phone number</string>
- <!-- Label for item in the text selection menu to trigger adding a contact [CHAR LIMIT=20] -->
+ <!-- Label for item in the text selection menu to trigger adding a contact. Should be a verb. [CHAR LIMIT=20] -->
<string name="add_contact">Add</string>
<!-- Accessibility description for an item in the text selection menu to add the selected detail to contacts [CHAR LIMIT=NONE] -->
<string name="add_contact_desc">Add to contacts</string>
- <!-- Label for item in the text selection menu to view the calendar for the selected time/date [CHAR LIMIT=20] -->
+ <!-- Label for item in the text selection menu to view the calendar for the selected time/date. Should be a verb. [CHAR LIMIT=20] -->
<string name="view_calendar">View</string>
<!-- Accessibility description for an item in the text selection menu to view the calendar for a date [CHAR LIMIT=NONE]-->
<string name="view_calendar_desc">View selected time in calendar</string>
- <!-- Label for item in the text selection menu to create a calendar event at the selected time/date [CHAR LIMIT=20] -->
+ <!-- Label for item in the text selection menu to create a calendar event at the selected time/date. Should be a verb. [CHAR LIMIT=20] -->
<string name="add_calendar_event">Schedule</string>
<!-- Accessibility description for an item in the text selection menu to schedule an event for a date [CHAR LIMIT=NONE] -->
<string name="add_calendar_event_desc">Schedule event for selected time</string>
- <!-- Label for item in the text selection menu to track a selected flight number [CHAR LIMIT=20] -->
+ <!-- Label for item in the text selection menu to track a selected flight number. Should be a verb. [CHAR LIMIT=20] -->
<string name="view_flight">Track</string>
<!-- Accessibility description for an item in the text selection menu to track a flight [CHAR LIMIT=NONE] -->
diff --git a/libs/hwui/Android.bp b/libs/hwui/Android.bp
index b7ffb5d..edce305 100644
--- a/libs/hwui/Android.bp
+++ b/libs/hwui/Android.bp
@@ -72,6 +72,7 @@
"libft2",
"libminikin",
"libandroidfw",
+ "libcrypto",
],
static_libs: [
"libEGL_blobCache",
@@ -175,7 +176,9 @@
"pipeline/skia/SkiaRecordingCanvas.cpp",
"pipeline/skia/SkiaVulkanPipeline.cpp",
"pipeline/skia/VectorDrawableAtlas.cpp",
+ "renderstate/PixelBufferState.cpp",
"renderstate/RenderState.cpp",
+ "renderstate/TextureState.cpp",
"renderthread/CacheManager.cpp",
"renderthread/CanvasContext.cpp",
"renderthread/DrawFrameTask.cpp",
@@ -187,9 +190,6 @@
"renderthread/TimeLord.cpp",
"renderthread/Frame.cpp",
"service/GraphicsStatsService.cpp",
- "surfacetexture/EGLConsumer.cpp",
- "surfacetexture/ImageConsumer.cpp",
- "surfacetexture/SurfaceTexture.cpp",
"thread/TaskManager.cpp",
"utils/Blur.cpp",
"utils/Color.cpp",
@@ -201,6 +201,7 @@
"AnimationContext.cpp",
"Animator.cpp",
"AnimatorManager.cpp",
+ "Caches.cpp",
"CanvasState.cpp",
"CanvasTransform.cpp",
"ClipArea.cpp",
@@ -209,6 +210,7 @@
"DeviceInfo.cpp",
"FrameInfo.cpp",
"FrameInfoVisualizer.cpp",
+ "GlLayer.cpp",
"GpuMemoryTracker.cpp",
"HardwareBitmapUploader.cpp",
"Interpolator.cpp",
@@ -218,6 +220,7 @@
"Matrix.cpp",
"EglReadback.cpp",
"PathParser.cpp",
+ "PixelBuffer.cpp",
"ProfileData.cpp",
"ProfileDataContainer.cpp",
"Properties.cpp",
@@ -229,7 +232,9 @@
"ResourceCache.cpp",
"SkiaCanvas.cpp",
"Snapshot.cpp",
+ "Texture.cpp",
"VectorDrawable.cpp",
+ "VkLayer.cpp",
"protos/graphicsstats.proto",
],
diff --git a/libs/hwui/Caches.cpp b/libs/hwui/Caches.cpp
new file mode 100644
index 0000000..2541444
--- /dev/null
+++ b/libs/hwui/Caches.cpp
@@ -0,0 +1,103 @@
+/*
+ * Copyright (C) 2010 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.
+ */
+
+#include "Caches.h"
+
+#include "GlLayer.h"
+#include "Properties.h"
+#include "renderstate/RenderState.h"
+#include "utils/GLUtils.h"
+
+#include <cutils/properties.h>
+#include <utils/Log.h>
+#include <utils/String8.h>
+
+namespace android {
+namespace uirenderer {
+
+Caches* Caches::sInstance = nullptr;
+
+///////////////////////////////////////////////////////////////////////////////
+// Macros
+///////////////////////////////////////////////////////////////////////////////
+
+#if DEBUG_CACHE_FLUSH
+#define FLUSH_LOGD(...) ALOGD(__VA_ARGS__)
+#else
+#define FLUSH_LOGD(...)
+#endif
+
+///////////////////////////////////////////////////////////////////////////////
+// Constructors/destructor
+///////////////////////////////////////////////////////////////////////////////
+
+Caches::Caches(RenderState& renderState) : mInitialized(false) {
+ INIT_LOGD("Creating OpenGL renderer caches");
+ init();
+ initStaticProperties();
+}
+
+bool Caches::init() {
+ if (mInitialized) return false;
+
+ ATRACE_NAME("Caches::init");
+
+ mRegionMesh = nullptr;
+
+ mInitialized = true;
+
+ mPixelBufferState = new PixelBufferState();
+ mTextureState = new TextureState();
+ mTextureState->constructTexture(*this);
+
+ return true;
+}
+
+void Caches::initStaticProperties() {
+ // OpenGL ES 3.0+ specific features
+ gpuPixelBuffersEnabled = extensions().hasPixelBufferObjects() &&
+ property_get_bool(PROPERTY_ENABLE_GPU_PIXEL_BUFFERS, true);
+}
+
+void Caches::terminate() {
+ if (!mInitialized) return;
+ mRegionMesh.reset(nullptr);
+
+ clearGarbage();
+
+ delete mPixelBufferState;
+ mPixelBufferState = nullptr;
+ delete mTextureState;
+ mTextureState = nullptr;
+ mInitialized = false;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Memory management
+///////////////////////////////////////////////////////////////////////////////
+
+void Caches::clearGarbage() {}
+
+void Caches::flush(FlushMode mode) {
+ clearGarbage();
+ glFinish();
+ // Errors during cleanup should be considered non-fatal, dump them and
+ // and move on. TODO: All errors or just errors like bad surface?
+ GLUtils::dumpGLErrors();
+}
+
+}; // namespace uirenderer
+}; // namespace android
diff --git a/libs/hwui/Caches.h b/libs/hwui/Caches.h
new file mode 100644
index 0000000..642f9dc
--- /dev/null
+++ b/libs/hwui/Caches.h
@@ -0,0 +1,135 @@
+/*
+ * Copyright (C) 2010 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.
+ */
+
+#pragma once
+
+#include "DeviceInfo.h"
+#include "Extensions.h"
+#include "ResourceCache.h"
+#include "renderstate/PixelBufferState.h"
+#include "renderstate/TextureState.h"
+#include "thread/TaskManager.h"
+#include "thread/TaskProcessor.h"
+
+#include <memory>
+#include <vector>
+
+#include <GLES3/gl3.h>
+
+#include <utils/KeyedVector.h>
+
+#include <cutils/compiler.h>
+
+#include <SkPath.h>
+
+#include <vector>
+
+namespace android {
+namespace uirenderer {
+
+///////////////////////////////////////////////////////////////////////////////
+// Caches
+///////////////////////////////////////////////////////////////////////////////
+
+class RenderNode;
+class RenderState;
+
+class ANDROID_API Caches {
+public:
+ static Caches& createInstance(RenderState& renderState) {
+ LOG_ALWAYS_FATAL_IF(sInstance, "double create of Caches attempted");
+ sInstance = new Caches(renderState);
+ return *sInstance;
+ }
+
+ static Caches& getInstance() {
+ LOG_ALWAYS_FATAL_IF(!sInstance, "instance not yet created");
+ return *sInstance;
+ }
+
+ static bool hasInstance() { return sInstance != nullptr; }
+
+private:
+ explicit Caches(RenderState& renderState);
+ static Caches* sInstance;
+
+public:
+ enum class FlushMode { Layers = 0, Moderate, Full };
+
+ /**
+ * Initialize caches.
+ */
+ bool init();
+
+ bool isInitialized() { return mInitialized; }
+
+ /**
+ * Flush the cache.
+ *
+ * @param mode Indicates how much of the cache should be flushed
+ */
+ void flush(FlushMode mode);
+
+ /**
+ * Destroys all resources associated with this cache. This should
+ * be called after a flush(FlushMode::Full).
+ */
+ void terminate();
+
+ /**
+ * Call this on each frame to ensure that garbage is deleted from
+ * GPU memory.
+ */
+ void clearGarbage();
+
+ /**
+ * Returns the GL RGBA internal format to use for the current device
+ * If the device supports linear blending and needSRGB is true,
+ * this function returns GL_SRGB8_ALPHA8, otherwise it returns GL_RGBA
+ */
+ constexpr GLint rgbaInternalFormat(bool needSRGB = true) const {
+ return extensions().hasLinearBlending() && needSRGB ? GL_SRGB8_ALPHA8 : GL_RGBA;
+ }
+
+public:
+ TaskManager tasks;
+
+ bool gpuPixelBuffersEnabled;
+
+ const Extensions& extensions() const { return DeviceInfo::get()->extensions(); }
+ PixelBufferState& pixelBufferState() { return *mPixelBufferState; }
+ TextureState& textureState() { return *mTextureState; }
+
+private:
+ void initStaticProperties();
+
+ static void eventMarkNull(GLsizei length, const GLchar* marker) {}
+ static void startMarkNull(GLsizei length, const GLchar* marker) {}
+ static void endMarkNull() {}
+
+ // Used to render layers
+ std::unique_ptr<TextureVertex[]> mRegionMesh;
+
+ bool mInitialized;
+
+ // TODO: move below to RenderState
+ PixelBufferState* mPixelBufferState = nullptr;
+ TextureState* mTextureState = nullptr;
+
+}; // class Caches
+
+}; // namespace uirenderer
+}; // namespace android
diff --git a/libs/hwui/DeferredLayerUpdater.cpp b/libs/hwui/DeferredLayerUpdater.cpp
index 0091655..569de76 100644
--- a/libs/hwui/DeferredLayerUpdater.cpp
+++ b/libs/hwui/DeferredLayerUpdater.cpp
@@ -15,20 +15,27 @@
*/
#include "DeferredLayerUpdater.h"
+#include "GlLayer.h"
+#include "VkLayer.h"
#include "renderstate/RenderState.h"
+#include "renderthread/EglManager.h"
+#include "renderthread/RenderTask.h"
#include "utils/PaintUtils.h"
namespace android {
namespace uirenderer {
-DeferredLayerUpdater::DeferredLayerUpdater(RenderState& renderState)
+DeferredLayerUpdater::DeferredLayerUpdater(RenderState& renderState, CreateLayerFn createLayerFn,
+ Layer::Api layerApi)
: mRenderState(renderState)
, mBlend(false)
, mSurfaceTexture(nullptr)
, mTransform(nullptr)
, mGLContextAttached(false)
, mUpdateTexImage(false)
- , mLayer(nullptr) {
+ , mLayer(nullptr)
+ , mLayerApi(layerApi)
+ , mCreateLayerFn(createLayerFn) {
renderState.registerDeferredLayerUpdater(this);
}
@@ -43,9 +50,13 @@
return;
}
- if (mSurfaceTexture.get() && mGLContextAttached) {
- mSurfaceTexture->detachFromView();
+ if (mSurfaceTexture.get() && mLayerApi == Layer::Api::OpenGL && mGLContextAttached) {
+ status_t err = mSurfaceTexture->detachFromContext();
mGLContextAttached = false;
+ if (err != 0) {
+ // TODO: Elevate to fatal exception
+ ALOGE("Failed to detach SurfaceTexture from context %d", err);
+ }
}
mLayer->postDecStrong();
@@ -64,53 +75,99 @@
void DeferredLayerUpdater::apply() {
if (!mLayer) {
- mLayer = new Layer(mRenderState, mColorFilter, mAlpha, mMode);
+ mLayer = mCreateLayerFn(mRenderState, mWidth, mHeight, mColorFilter, mAlpha, mMode, mBlend);
}
mLayer->setColorFilter(mColorFilter);
mLayer->setAlpha(mAlpha, mMode);
if (mSurfaceTexture.get()) {
- if (!mGLContextAttached) {
- mGLContextAttached = true;
- mUpdateTexImage = true;
- mSurfaceTexture->attachToView();
- }
- if (mUpdateTexImage) {
- mUpdateTexImage = false;
- sk_sp<SkImage> layerImage;
- SkMatrix textureTransform;
- android_dataspace dataSpace;
- bool queueEmpty = true;
- // If the SurfaceTexture queue is in synchronous mode, need to discard all
- // but latest frame. Since we can't tell which mode it is in,
- // do this unconditionally.
- do {
- layerImage = mSurfaceTexture->dequeueImage(textureTransform, dataSpace, &queueEmpty,
- mRenderState);
- } while (layerImage.get() && (!queueEmpty));
- if (layerImage.get()) {
- // force filtration if buffer size != layer size
- bool forceFilter = mWidth != layerImage->width() || mHeight != layerImage->height();
- updateLayer(forceFilter, textureTransform, dataSpace, layerImage);
+ if (mLayer->getApi() == Layer::Api::Vulkan) {
+ if (mUpdateTexImage) {
+ mUpdateTexImage = false;
+ doUpdateVkTexImage();
}
+ } else {
+ LOG_ALWAYS_FATAL_IF(mLayer->getApi() != Layer::Api::OpenGL,
+ "apply surfaceTexture with non GL backend %x, GL %x, VK %x",
+ mLayer->getApi(), Layer::Api::OpenGL, Layer::Api::Vulkan);
+ if (!mGLContextAttached) {
+ mGLContextAttached = true;
+ mUpdateTexImage = true;
+ mSurfaceTexture->attachToContext(static_cast<GlLayer*>(mLayer)->getTextureId());
+ }
+ if (mUpdateTexImage) {
+ mUpdateTexImage = false;
+ doUpdateTexImage();
+ }
+ GLenum renderTarget = mSurfaceTexture->getCurrentTextureTarget();
+ static_cast<GlLayer*>(mLayer)->setRenderTarget(renderTarget);
}
-
if (mTransform) {
- mLayer->getTransform() = *mTransform;
+ mLayer->getTransform().load(*mTransform);
setTransform(nullptr);
}
}
}
-void DeferredLayerUpdater::updateLayer(bool forceFilter, const SkMatrix& textureTransform,
- android_dataspace dataspace, const sk_sp<SkImage>& layerImage) {
+void DeferredLayerUpdater::doUpdateTexImage() {
+ LOG_ALWAYS_FATAL_IF(mLayer->getApi() != Layer::Api::OpenGL,
+ "doUpdateTexImage non GL backend %x, GL %x, VK %x", mLayer->getApi(),
+ Layer::Api::OpenGL, Layer::Api::Vulkan);
+ if (mSurfaceTexture->updateTexImage() == NO_ERROR) {
+ float transform[16];
+
+ int64_t frameNumber = mSurfaceTexture->getFrameNumber();
+ // If the GLConsumer queue is in synchronous mode, need to discard all
+ // but latest frame, using the frame number to tell when we no longer
+ // have newer frames to target. Since we can't tell which mode it is in,
+ // do this unconditionally.
+ int dropCounter = 0;
+ while (mSurfaceTexture->updateTexImage() == NO_ERROR) {
+ int64_t newFrameNumber = mSurfaceTexture->getFrameNumber();
+ if (newFrameNumber == frameNumber) break;
+ frameNumber = newFrameNumber;
+ dropCounter++;
+ }
+
+ bool forceFilter = false;
+ sp<GraphicBuffer> buffer = mSurfaceTexture->getCurrentBuffer();
+ if (buffer != nullptr) {
+ // force filtration if buffer size != layer size
+ forceFilter = mWidth != static_cast<int>(buffer->getWidth()) ||
+ mHeight != static_cast<int>(buffer->getHeight());
+ }
+
+#if DEBUG_RENDERER
+ if (dropCounter > 0) {
+ RENDERER_LOGD("Dropped %d frames on texture layer update", dropCounter);
+ }
+#endif
+ mSurfaceTexture->getTransformMatrix(transform);
+
+ updateLayer(forceFilter, transform, mSurfaceTexture->getCurrentDataSpace());
+ }
+}
+
+void DeferredLayerUpdater::doUpdateVkTexImage() {
+ LOG_ALWAYS_FATAL_IF(mLayer->getApi() != Layer::Api::Vulkan,
+ "updateLayer non Vulkan backend %x, GL %x, VK %x", mLayer->getApi(),
+ Layer::Api::OpenGL, Layer::Api::Vulkan);
+
+ static const mat4 identityMatrix;
+ updateLayer(false, identityMatrix.data, HAL_DATASPACE_UNKNOWN);
+
+ VkLayer* vkLayer = static_cast<VkLayer*>(mLayer);
+ vkLayer->updateTexture();
+}
+
+void DeferredLayerUpdater::updateLayer(bool forceFilter, const float* textureTransform,
+ android_dataspace dataspace) {
mLayer->setBlend(mBlend);
mLayer->setForceFilter(forceFilter);
mLayer->setSize(mWidth, mHeight);
- mLayer->getTexTransform() = textureTransform;
+ mLayer->getTexTransform().load(textureTransform);
mLayer->setDataSpace(dataspace);
- mLayer->setImage(layerImage);
}
void DeferredLayerUpdater::detachSurfaceTexture() {
diff --git a/libs/hwui/DeferredLayerUpdater.h b/libs/hwui/DeferredLayerUpdater.h
index 4c323b8..fe3ee7a 100644
--- a/libs/hwui/DeferredLayerUpdater.h
+++ b/libs/hwui/DeferredLayerUpdater.h
@@ -17,19 +17,18 @@
#pragma once
#include <SkColorFilter.h>
-#include <SkImage.h>
#include <SkMatrix.h>
#include <cutils/compiler.h>
-#include <map>
+#include <gui/GLConsumer.h>
#include <system/graphics.h>
#include <utils/StrongPointer.h>
#include <GLES2/gl2.h>
#include <GLES2/gl2ext.h>
-#include "surfacetexture/SurfaceTexture.h"
#include "Layer.h"
#include "Rect.h"
+#include "renderthread/RenderThread.h"
namespace android {
namespace uirenderer {
@@ -42,7 +41,12 @@
public:
// Note that DeferredLayerUpdater assumes it is taking ownership of the layer
// and will not call incrementRef on it as a result.
- ANDROID_API explicit DeferredLayerUpdater(RenderState& renderState);
+ typedef std::function<Layer*(RenderState& renderState, uint32_t layerWidth,
+ uint32_t layerHeight, sk_sp<SkColorFilter> colorFilter, int alpha,
+ SkBlendMode mode, bool blend)>
+ CreateLayerFn;
+ ANDROID_API explicit DeferredLayerUpdater(RenderState& renderState, CreateLayerFn createLayerFn,
+ Layer::Api layerApi);
ANDROID_API ~DeferredLayerUpdater();
@@ -66,13 +70,13 @@
return false;
}
- ANDROID_API void setSurfaceTexture(const sp<SurfaceTexture>& consumer) {
- if (consumer.get() != mSurfaceTexture.get()) {
- mSurfaceTexture = consumer;
+ ANDROID_API void setSurfaceTexture(const sp<GLConsumer>& texture) {
+ if (texture.get() != mSurfaceTexture.get()) {
+ mSurfaceTexture = texture;
- GLenum target = consumer->getCurrentTextureTarget();
+ GLenum target = texture->getCurrentTextureTarget();
LOG_ALWAYS_FATAL_IF(target != GL_TEXTURE_2D && target != GL_TEXTURE_EXTERNAL_OES,
- "set unsupported SurfaceTexture with target %x", target);
+ "set unsupported GLConsumer with target %x", target);
}
}
@@ -93,11 +97,12 @@
void detachSurfaceTexture();
- void updateLayer(bool forceFilter, const SkMatrix& textureTransform,
- android_dataspace dataspace, const sk_sp<SkImage>& layerImage);
+ void updateLayer(bool forceFilter, const float* textureTransform, android_dataspace dataspace);
void destroyLayer();
+ Layer::Api getBackingLayerApi() { return mLayerApi; }
+
private:
RenderState& mRenderState;
@@ -108,12 +113,17 @@
sk_sp<SkColorFilter> mColorFilter;
int mAlpha = 255;
SkBlendMode mMode = SkBlendMode::kSrcOver;
- sp<SurfaceTexture> mSurfaceTexture;
+ sp<GLConsumer> mSurfaceTexture;
SkMatrix* mTransform;
bool mGLContextAttached;
bool mUpdateTexImage;
Layer* mLayer;
+ Layer::Api mLayerApi;
+ CreateLayerFn mCreateLayerFn;
+
+ void doUpdateTexImage();
+ void doUpdateVkTexImage();
};
} /* namespace uirenderer */
diff --git a/libs/hwui/GlLayer.cpp b/libs/hwui/GlLayer.cpp
new file mode 100644
index 0000000..432bb85
--- /dev/null
+++ b/libs/hwui/GlLayer.cpp
@@ -0,0 +1,68 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+#include "GlLayer.h"
+
+#include "Caches.h"
+#include "RenderNode.h"
+#include "renderstate/RenderState.h"
+
+namespace android {
+namespace uirenderer {
+
+GlLayer::GlLayer(RenderState& renderState, uint32_t layerWidth, uint32_t layerHeight,
+ sk_sp<SkColorFilter> colorFilter, int alpha, SkBlendMode mode, bool blend)
+ : Layer(renderState, Api::OpenGL, colorFilter, alpha, mode)
+ , caches(Caches::getInstance())
+ , texture(caches) {
+ texture.mWidth = layerWidth;
+ texture.mHeight = layerHeight;
+ texture.blend = blend;
+}
+
+GlLayer::~GlLayer() {
+ // There's a rare possibility that Caches could have been destroyed already
+ // since this method is queued up as a task.
+ // Since this is a reset method, treat this as non-fatal.
+ if (caches.isInitialized() && texture.mId) {
+ texture.deleteTexture();
+ }
+}
+
+void GlLayer::onGlContextLost() {
+ texture.deleteTexture();
+}
+
+void GlLayer::setRenderTarget(GLenum renderTarget) {
+ if (renderTarget != getRenderTarget()) {
+ // new render target: bind with new target, and update filter/wrap
+ texture.mTarget = renderTarget;
+ if (texture.mId) {
+ caches.textureState().bindTexture(texture.target(), texture.mId);
+ }
+ texture.setFilter(GL_NEAREST, false, true);
+ texture.setWrap(GL_CLAMP_TO_EDGE, false, true);
+ }
+}
+
+void GlLayer::generateTexture() {
+ if (!texture.mId) {
+ glGenTextures(1, &texture.mId);
+ }
+}
+
+}; // namespace uirenderer
+}; // namespace android
diff --git a/libs/hwui/GlLayer.h b/libs/hwui/GlLayer.h
new file mode 100644
index 0000000..9f70fda
--- /dev/null
+++ b/libs/hwui/GlLayer.h
@@ -0,0 +1,75 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+#pragma once
+
+#include "Layer.h"
+
+#include "Texture.h"
+
+namespace android {
+namespace uirenderer {
+
+// Forward declarations
+class Caches;
+
+/**
+ * A layer has dimensions and is backed by an OpenGL texture or FBO.
+ */
+class GlLayer : public Layer {
+public:
+ GlLayer(RenderState& renderState, uint32_t layerWidth, uint32_t layerHeight,
+ sk_sp<SkColorFilter> colorFilter, int alpha, SkBlendMode mode, bool blend);
+ virtual ~GlLayer();
+
+ uint32_t getWidth() const override { return texture.mWidth; }
+
+ uint32_t getHeight() const override { return texture.mHeight; }
+
+ void setSize(uint32_t width, uint32_t height) override {
+ texture.updateLayout(width, height, texture.internalFormat(), texture.format(),
+ texture.target());
+ }
+
+ void setBlend(bool blend) override { texture.blend = blend; }
+
+ bool isBlend() const override { return texture.blend; }
+
+ inline GLuint getTextureId() const { return texture.id(); }
+
+ inline GLenum getRenderTarget() const { return texture.target(); }
+
+ void setRenderTarget(GLenum renderTarget);
+
+ void generateTexture();
+
+ /**
+ * Lost the GL context but the layer is still around, mark it invalid internally
+ * so the dtor knows not to do any GL work
+ */
+ void onGlContextLost();
+
+private:
+ Caches& caches;
+
+ /**
+ * The texture backing this layer.
+ */
+ Texture texture;
+}; // struct GlLayer
+
+}; // namespace uirenderer
+}; // namespace android
diff --git a/libs/hwui/GpuMemoryTracker.cpp b/libs/hwui/GpuMemoryTracker.cpp
index a9a7af8..612bfde 100644
--- a/libs/hwui/GpuMemoryTracker.cpp
+++ b/libs/hwui/GpuMemoryTracker.cpp
@@ -14,6 +14,7 @@
* limitations under the License.
*/
+#include "Texture.h"
#include "utils/StringUtils.h"
#include <GpuMemoryTracker.h>
@@ -116,6 +117,22 @@
ATRACE_INT(buf, stats.count);
}
}
+
+ std::vector<const Texture*> freeList;
+ for (const auto& obj : gObjectSet) {
+ if (obj->objectType() == GpuObjectType::Texture) {
+ const Texture* texture = static_cast<Texture*>(obj);
+ if (texture->cleanup) {
+ ALOGE("Leaked texture marked for cleanup! id=%u, size %ux%u", texture->id(),
+ texture->width(), texture->height());
+ freeList.push_back(texture);
+ }
+ }
+ }
+ for (auto& texture : freeList) {
+ const_cast<Texture*>(texture)->deleteTexture();
+ delete texture;
+ }
}
} // namespace uirenderer
diff --git a/libs/hwui/Layer.cpp b/libs/hwui/Layer.cpp
index f59a2e6..fb8f033 100644
--- a/libs/hwui/Layer.cpp
+++ b/libs/hwui/Layer.cpp
@@ -17,17 +17,17 @@
#include "Layer.h"
#include "renderstate/RenderState.h"
-#include "utils/Color.h"
#include <SkToSRGBColorFilter.h>
namespace android {
namespace uirenderer {
-Layer::Layer(RenderState& renderState, sk_sp<SkColorFilter> colorFilter, int alpha,
- SkBlendMode mode)
+Layer::Layer(RenderState& renderState, Api api, sk_sp<SkColorFilter> colorFilter, int alpha,
+ SkBlendMode mode)
: GpuMemoryTracker(GpuObjectType::Layer)
, mRenderState(renderState)
+ , mApi(api)
, mColorFilter(colorFilter)
, alpha(alpha)
, mode(mode) {
@@ -36,8 +36,6 @@
incStrong(nullptr);
buildColorSpaceWithFilter();
renderState.registerLayer(this);
- texTransform.setIdentity();
- transform.setIdentity();
}
Layer::~Layer() {
diff --git a/libs/hwui/Layer.h b/libs/hwui/Layer.h
index c4e4c1c..31878ac 100644
--- a/libs/hwui/Layer.h
+++ b/libs/hwui/Layer.h
@@ -23,9 +23,8 @@
#include <SkColorFilter.h>
#include <SkColorSpace.h>
#include <SkPaint.h>
-#include <SkImage.h>
-#include <SkMatrix.h>
-#include <system/graphics.h>
+
+#include "Matrix.h"
namespace android {
namespace uirenderer {
@@ -41,19 +40,24 @@
*/
class Layer : public VirtualLightRefBase, GpuMemoryTracker {
public:
- Layer(RenderState& renderState, sk_sp<SkColorFilter>, int alpha, SkBlendMode mode);
+ enum class Api {
+ OpenGL = 0,
+ Vulkan = 1,
+ };
+
+ Api getApi() const { return mApi; }
~Layer();
- virtual uint32_t getWidth() const { return mWidth; }
+ virtual uint32_t getWidth() const = 0;
- virtual uint32_t getHeight() const { return mHeight; }
+ virtual uint32_t getHeight() const = 0;
- virtual void setSize(uint32_t width, uint32_t height) { mWidth = width; mHeight = height; }
+ virtual void setSize(uint32_t width, uint32_t height) = 0;
- virtual void setBlend(bool blend) { mBlend = blend; }
+ virtual void setBlend(bool blend) = 0;
- virtual bool isBlend() const { return mBlend; }
+ virtual bool isBlend() const = 0;
inline void setForceFilter(bool forceFilter) { this->forceFilter = forceFilter; }
@@ -80,9 +84,9 @@
inline sk_sp<SkColorFilter> getColorSpaceWithFilter() const { return mColorSpaceWithFilter; }
- inline SkMatrix& getTexTransform() { return texTransform; }
+ inline mat4& getTexTransform() { return texTransform; }
- inline SkMatrix& getTransform() { return transform; }
+ inline mat4& getTransform() { return transform; }
/**
* Posts a decStrong call to the appropriate thread.
@@ -90,17 +94,16 @@
*/
void postDecStrong();
- inline void setImage(const sk_sp<SkImage>& image) { this->layerImage = image; }
-
- inline sk_sp<SkImage> getImage() const { return this->layerImage; }
-
protected:
+ Layer(RenderState& renderState, Api api, sk_sp<SkColorFilter>, int alpha, SkBlendMode mode);
RenderState& mRenderState;
private:
void buildColorSpaceWithFilter();
+ Api mApi;
+
/**
* Color filter used to draw this layer. Optional.
*/
@@ -134,32 +137,12 @@
/**
* Optional texture coordinates transform.
*/
- SkMatrix texTransform;
+ mat4 texTransform;
/**
* Optional transform.
*/
- SkMatrix transform;
-
- /**
- * An image backing the layer.
- */
- sk_sp<SkImage> layerImage;
-
- /**
- * layer width.
- */
- uint32_t mWidth = 0;
-
- /**
- * layer height.
- */
- uint32_t mHeight = 0;
-
- /**
- * enable blending
- */
- bool mBlend = false;
+ mat4 transform;
}; // struct Layer
diff --git a/libs/hwui/PixelBuffer.cpp b/libs/hwui/PixelBuffer.cpp
new file mode 100644
index 0000000..910a988
--- /dev/null
+++ b/libs/hwui/PixelBuffer.cpp
@@ -0,0 +1,156 @@
+/*
+ * Copyright (C) 2013 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.
+ */
+
+#include "PixelBuffer.h"
+
+#include "Debug.h"
+#include "Extensions.h"
+#include "Properties.h"
+#include "renderstate/RenderState.h"
+#include "utils/GLUtils.h"
+
+#include <utils/Log.h>
+
+namespace android {
+namespace uirenderer {
+
+///////////////////////////////////////////////////////////////////////////////
+// CPU pixel buffer
+///////////////////////////////////////////////////////////////////////////////
+
+class CpuPixelBuffer : public PixelBuffer {
+public:
+ CpuPixelBuffer(GLenum format, uint32_t width, uint32_t height);
+
+ uint8_t* map(AccessMode mode = kAccessMode_ReadWrite) override;
+
+ void upload(uint32_t x, uint32_t y, uint32_t width, uint32_t height, int offset) override;
+
+protected:
+ void unmap() override;
+
+private:
+ std::unique_ptr<uint8_t[]> mBuffer;
+};
+
+CpuPixelBuffer::CpuPixelBuffer(GLenum format, uint32_t width, uint32_t height)
+ : PixelBuffer(format, width, height)
+ , mBuffer(new uint8_t[width * height * formatSize(format)]) {}
+
+uint8_t* CpuPixelBuffer::map(AccessMode mode) {
+ if (mAccessMode == kAccessMode_None) {
+ mAccessMode = mode;
+ }
+ return mBuffer.get();
+}
+
+void CpuPixelBuffer::unmap() {
+ mAccessMode = kAccessMode_None;
+}
+
+void CpuPixelBuffer::upload(uint32_t x, uint32_t y, uint32_t width, uint32_t height, int offset) {
+ glTexSubImage2D(GL_TEXTURE_2D, 0, x, y, width, height, mFormat, GL_UNSIGNED_BYTE,
+ &mBuffer[offset]);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// GPU pixel buffer
+///////////////////////////////////////////////////////////////////////////////
+
+class GpuPixelBuffer : public PixelBuffer {
+public:
+ GpuPixelBuffer(GLenum format, uint32_t width, uint32_t height);
+ ~GpuPixelBuffer();
+
+ uint8_t* map(AccessMode mode = kAccessMode_ReadWrite) override;
+
+ void upload(uint32_t x, uint32_t y, uint32_t width, uint32_t height, int offset) override;
+
+protected:
+ void unmap() override;
+
+private:
+ GLuint mBuffer;
+ uint8_t* mMappedPointer;
+ Caches& mCaches;
+};
+
+GpuPixelBuffer::GpuPixelBuffer(GLenum format, uint32_t width, uint32_t height)
+ : PixelBuffer(format, width, height)
+ , mMappedPointer(nullptr)
+ , mCaches(Caches::getInstance()) {
+ glGenBuffers(1, &mBuffer);
+
+ mCaches.pixelBufferState().bind(mBuffer);
+ glBufferData(GL_PIXEL_UNPACK_BUFFER, getSize(), nullptr, GL_DYNAMIC_DRAW);
+ mCaches.pixelBufferState().unbind();
+}
+
+GpuPixelBuffer::~GpuPixelBuffer() {
+ glDeleteBuffers(1, &mBuffer);
+}
+
+uint8_t* GpuPixelBuffer::map(AccessMode mode) {
+ if (mAccessMode == kAccessMode_None) {
+ mCaches.pixelBufferState().bind(mBuffer);
+ mMappedPointer = (uint8_t*)glMapBufferRange(GL_PIXEL_UNPACK_BUFFER, 0, getSize(), mode);
+ if (CC_UNLIKELY(!mMappedPointer)) {
+ GLUtils::dumpGLErrors();
+ LOG_ALWAYS_FATAL("Failed to map PBO");
+ }
+ mAccessMode = mode;
+ mCaches.pixelBufferState().unbind();
+ }
+
+ return mMappedPointer;
+}
+
+void GpuPixelBuffer::unmap() {
+ if (mAccessMode != kAccessMode_None) {
+ if (mMappedPointer) {
+ mCaches.pixelBufferState().bind(mBuffer);
+ GLboolean status = glUnmapBuffer(GL_PIXEL_UNPACK_BUFFER);
+ if (status == GL_FALSE) {
+ ALOGE("Corrupted GPU pixel buffer");
+ }
+ }
+ mAccessMode = kAccessMode_None;
+ mMappedPointer = nullptr;
+ }
+}
+
+void GpuPixelBuffer::upload(uint32_t x, uint32_t y, uint32_t width, uint32_t height, int offset) {
+ // If the buffer is not mapped, unmap() will not bind it
+ mCaches.pixelBufferState().bind(mBuffer);
+ unmap();
+ glTexSubImage2D(GL_TEXTURE_2D, 0, x, y, width, height, mFormat, GL_UNSIGNED_BYTE,
+ reinterpret_cast<void*>(offset));
+ mCaches.pixelBufferState().unbind();
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Factory
+///////////////////////////////////////////////////////////////////////////////
+
+PixelBuffer* PixelBuffer::create(GLenum format, uint32_t width, uint32_t height, BufferType type) {
+ if (type == kBufferType_Auto && Caches::getInstance().gpuPixelBuffersEnabled) {
+ return new GpuPixelBuffer(format, width, height);
+ }
+ return new CpuPixelBuffer(format, width, height);
+}
+
+}; // namespace uirenderer
+}; // namespace android
diff --git a/libs/hwui/PixelBuffer.h b/libs/hwui/PixelBuffer.h
new file mode 100644
index 0000000..e7e341b
--- /dev/null
+++ b/libs/hwui/PixelBuffer.h
@@ -0,0 +1,198 @@
+/*
+ * Copyright (C) 2013 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.
+ */
+
+#ifndef ANDROID_HWUI_PIXEL_BUFFER_H
+#define ANDROID_HWUI_PIXEL_BUFFER_H
+
+#include <GLES3/gl3.h>
+
+#include <log/log.h>
+
+namespace android {
+namespace uirenderer {
+
+/**
+ * Represents a pixel buffer. A pixel buffer will be backed either by a
+ * PBO on OpenGL ES 3.0 and higher or by an array of uint8_t on other
+ * versions. If the buffer is backed by a PBO it will of type
+ * GL_PIXEL_UNPACK_BUFFER.
+ *
+ * To read from or write into a PixelBuffer you must first map the
+ * buffer using the map(AccessMode) method. This method returns a
+ * pointer to the beginning of the buffer.
+ *
+ * Before the buffer can be used by the GPU, for instance to upload
+ * a texture, you must first unmap the buffer. To do so, call the
+ * unmap() method.
+ *
+ * Mapping and unmapping a PixelBuffer can have the side effect of
+ * changing the currently active GL_PIXEL_UNPACK_BUFFER. It is
+ * therefore recommended to call Caches::unbindPixelbuffer() after
+ * using a PixelBuffer to upload to a texture.
+ */
+class PixelBuffer {
+public:
+ enum BufferType { kBufferType_Auto, kBufferType_CPU };
+
+ enum AccessMode {
+ kAccessMode_None = 0,
+ kAccessMode_Read = GL_MAP_READ_BIT,
+ kAccessMode_Write = GL_MAP_WRITE_BIT,
+ kAccessMode_ReadWrite = GL_MAP_READ_BIT | GL_MAP_WRITE_BIT
+ };
+
+ /**
+ * Creates a new PixelBuffer object with the specified format and
+ * dimensions. The buffer is immediately allocated.
+ *
+ * The buffer type specifies how the buffer should be allocated.
+ * By default this method will automatically choose whether to allocate
+ * a CPU or GPU buffer.
+ */
+ static PixelBuffer* create(GLenum format, uint32_t width, uint32_t height,
+ BufferType type = kBufferType_Auto);
+
+ virtual ~PixelBuffer() {}
+
+ /**
+ * Returns the format of this render buffer.
+ */
+ GLenum getFormat() const { return mFormat; }
+
+ /**
+ * Maps this before with the specified access mode. This method
+ * returns a pointer to the region of memory where the buffer was
+ * mapped.
+ *
+ * If the buffer is already mapped when this method is invoked,
+ * this method will return the previously mapped pointer. The
+ * access mode can only be changed by calling unmap() first.
+ *
+ * The specified access mode cannot be kAccessMode_None.
+ */
+ virtual uint8_t* map(AccessMode mode = kAccessMode_ReadWrite) = 0;
+
+ /**
+ * Returns the current access mode for this buffer. If the buffer
+ * is not mapped, this method returns kAccessMode_None.
+ */
+ AccessMode getAccessMode() const { return mAccessMode; }
+
+ /**
+ * Upload the specified rectangle of this pixel buffer as a
+ * GL_TEXTURE_2D texture. Calling this method will trigger
+ * an unmap() if necessary.
+ */
+ virtual void upload(uint32_t x, uint32_t y, uint32_t width, uint32_t height, int offset) = 0;
+
+ /**
+ * Upload the specified rectangle of this pixel buffer as a
+ * GL_TEXTURE_2D texture. Calling this method will trigger
+ * an unmap() if necessary.
+ *
+ * This is a convenience function provided to save callers the
+ * trouble of computing the offset parameter.
+ */
+ void upload(uint32_t x, uint32_t y, uint32_t width, uint32_t height) {
+ upload(x, y, width, height, getOffset(x, y));
+ }
+
+ /**
+ * Returns the width of the render buffer in pixels.
+ */
+ uint32_t getWidth() const { return mWidth; }
+
+ /**
+ * Returns the height of the render buffer in pixels.
+ */
+ uint32_t getHeight() const { return mHeight; }
+
+ /**
+ * Returns the size of this pixel buffer in bytes.
+ */
+ uint32_t getSize() const { return mWidth * mHeight * formatSize(mFormat); }
+
+ /**
+ * Returns the offset of a pixel in this pixel buffer, in bytes.
+ */
+ uint32_t getOffset(uint32_t x, uint32_t y) const {
+ return (y * mWidth + x) * formatSize(mFormat);
+ }
+
+ /**
+ * Returns the number of bytes per pixel in the specified format.
+ *
+ * Supported formats:
+ * GL_ALPHA
+ * GL_RGBA
+ */
+ static uint32_t formatSize(GLenum format) {
+ switch (format) {
+ case GL_ALPHA:
+ return 1;
+ case GL_RGBA:
+ return 4;
+ }
+ return 0;
+ }
+
+ /**
+ * Returns the alpha channel offset in the specified format.
+ *
+ * Supported formats:
+ * GL_ALPHA
+ * GL_RGBA
+ */
+ static uint32_t formatAlphaOffset(GLenum format) {
+ switch (format) {
+ case GL_ALPHA:
+ return 0;
+ case GL_RGBA:
+ return 3;
+ }
+
+ ALOGE("unsupported format: %d", format);
+ return 0;
+ }
+
+protected:
+ /**
+ * Creates a new render buffer in the specified format and dimensions.
+ * The format must be GL_ALPHA or GL_RGBA.
+ */
+ PixelBuffer(GLenum format, uint32_t width, uint32_t height)
+ : mFormat(format), mWidth(width), mHeight(height), mAccessMode(kAccessMode_None) {}
+
+ /**
+ * Unmaps this buffer, if needed. After the buffer is unmapped,
+ * the pointer previously returned by map() becomes invalid and
+ * should not be used.
+ */
+ virtual void unmap() = 0;
+
+ GLenum mFormat;
+
+ uint32_t mWidth;
+ uint32_t mHeight;
+
+ AccessMode mAccessMode;
+
+}; // class PixelBuffer
+
+}; // namespace uirenderer
+}; // namespace android
+
+#endif // ANDROID_HWUI_PIXEL_BUFFER_H
diff --git a/libs/hwui/RenderProperties.h b/libs/hwui/RenderProperties.h
index 7966845..0766e3b 100644
--- a/libs/hwui/RenderProperties.h
+++ b/libs/hwui/RenderProperties.h
@@ -16,6 +16,7 @@
#pragma once
+#include "Caches.h"
#include "DeviceInfo.h"
#include "Outline.h"
#include "Rect.h"
diff --git a/libs/hwui/ResourceCache.cpp b/libs/hwui/ResourceCache.cpp
index 65bee47..464a58d 100644
--- a/libs/hwui/ResourceCache.cpp
+++ b/libs/hwui/ResourceCache.cpp
@@ -15,6 +15,7 @@
*/
#include "ResourceCache.h"
+#include "Caches.h"
namespace android {
@@ -111,9 +112,13 @@
ResourceReference* ref = index >= 0 ? mCache->valueAt(index) : nullptr;
if (ref == nullptr) {
// If we're not tracking this resource, just delete it
- // A Res_png_9patch is actually an array of byte that's larger
- // than sizeof(Res_png_9patch). It must be freed as an array.
- delete[](int8_t*) resource;
+ if (Caches::hasInstance()) {
+ // DEAD CODE
+ } else {
+ // A Res_png_9patch is actually an array of byte that's larger
+ // than sizeof(Res_png_9patch). It must be freed as an array.
+ delete[](int8_t*) resource;
+ }
return;
}
ref->destroyed = true;
@@ -130,10 +135,14 @@
if (ref->destroyed) {
switch (ref->resourceType) {
case kNinePatch: {
- // A Res_png_9patch is actually an array of byte that's larger
- // than sizeof(Res_png_9patch). It must be freed as an array.
- int8_t* patch = (int8_t*)resource;
- delete[] patch;
+ if (Caches::hasInstance()) {
+ // DEAD CODE
+ } else {
+ // A Res_png_9patch is actually an array of byte that's larger
+ // than sizeof(Res_png_9patch). It must be freed as an array.
+ int8_t* patch = (int8_t*)resource;
+ delete[] patch;
+ }
} break;
}
}
diff --git a/libs/hwui/Texture.cpp b/libs/hwui/Texture.cpp
new file mode 100644
index 0000000..1e90eeb
--- /dev/null
+++ b/libs/hwui/Texture.cpp
@@ -0,0 +1,413 @@
+/*
+ * Copyright (C) 2013 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.
+ */
+
+#include "Texture.h"
+#include "Caches.h"
+#include "utils/GLUtils.h"
+#include "utils/MathUtils.h"
+#include "utils/TraceUtils.h"
+
+#include <utils/Log.h>
+
+#include <math/mat4.h>
+
+#include <SkCanvas.h>
+
+namespace android {
+namespace uirenderer {
+
+// Number of bytes used by a texture in the given format
+static int bytesPerPixel(GLint glFormat) {
+ switch (glFormat) {
+ // The wrapped-texture case, usually means a SurfaceTexture
+ case 0:
+ return 0;
+ case GL_LUMINANCE:
+ case GL_ALPHA:
+ return 1;
+ case GL_SRGB8:
+ case GL_RGB:
+ return 3;
+ case GL_SRGB8_ALPHA8:
+ case GL_RGBA:
+ return 4;
+ case GL_RGBA16F:
+ return 8;
+ default:
+ LOG_ALWAYS_FATAL("UNKNOWN FORMAT 0x%x", glFormat);
+ }
+}
+
+void Texture::setWrapST(GLenum wrapS, GLenum wrapT, bool bindTexture, bool force) {
+ if (force || wrapS != mWrapS || wrapT != mWrapT) {
+ mWrapS = wrapS;
+ mWrapT = wrapT;
+
+ if (bindTexture) {
+ mCaches.textureState().bindTexture(mTarget, mId);
+ }
+
+ glTexParameteri(mTarget, GL_TEXTURE_WRAP_S, wrapS);
+ glTexParameteri(mTarget, GL_TEXTURE_WRAP_T, wrapT);
+ }
+}
+
+void Texture::setFilterMinMag(GLenum min, GLenum mag, bool bindTexture, bool force) {
+ if (force || min != mMinFilter || mag != mMagFilter) {
+ mMinFilter = min;
+ mMagFilter = mag;
+
+ if (bindTexture) {
+ mCaches.textureState().bindTexture(mTarget, mId);
+ }
+
+ if (mipMap && min == GL_LINEAR) min = GL_LINEAR_MIPMAP_LINEAR;
+
+ glTexParameteri(mTarget, GL_TEXTURE_MIN_FILTER, min);
+ glTexParameteri(mTarget, GL_TEXTURE_MAG_FILTER, mag);
+ }
+}
+
+void Texture::deleteTexture() {
+ mCaches.textureState().deleteTexture(mId);
+ mId = 0;
+ mTarget = GL_NONE;
+ if (mEglImageHandle != EGL_NO_IMAGE_KHR) {
+ EGLDisplay eglDisplayHandle = eglGetCurrentDisplay();
+ eglDestroyImageKHR(eglDisplayHandle, mEglImageHandle);
+ mEglImageHandle = EGL_NO_IMAGE_KHR;
+ }
+}
+
+bool Texture::updateLayout(uint32_t width, uint32_t height, GLint internalFormat, GLint format,
+ GLenum target) {
+ if (mWidth == width && mHeight == height && mFormat == format &&
+ mInternalFormat == internalFormat && mTarget == target) {
+ return false;
+ }
+ mWidth = width;
+ mHeight = height;
+ mFormat = format;
+ mInternalFormat = internalFormat;
+ mTarget = target;
+ notifySizeChanged(mWidth * mHeight * bytesPerPixel(internalFormat));
+ return true;
+}
+
+void Texture::resetCachedParams() {
+ mWrapS = GL_REPEAT;
+ mWrapT = GL_REPEAT;
+ mMinFilter = GL_NEAREST_MIPMAP_LINEAR;
+ mMagFilter = GL_LINEAR;
+}
+
+void Texture::upload(GLint internalFormat, uint32_t width, uint32_t height, GLenum format,
+ GLenum type, const void* pixels) {
+ GL_CHECKPOINT(MODERATE);
+
+ // We don't have color space information, we assume the data is gamma encoded
+ mIsLinear = false;
+
+ bool needsAlloc = updateLayout(width, height, internalFormat, format, GL_TEXTURE_2D);
+ if (!mId) {
+ glGenTextures(1, &mId);
+ needsAlloc = true;
+ resetCachedParams();
+ }
+ mCaches.textureState().bindTexture(GL_TEXTURE_2D, mId);
+ if (needsAlloc) {
+ glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, mWidth, mHeight, 0, format, type, pixels);
+ } else if (pixels) {
+ glTexSubImage2D(GL_TEXTURE_2D, 0, internalFormat, mWidth, mHeight, 0, format, type, pixels);
+ }
+ GL_CHECKPOINT(MODERATE);
+}
+
+void Texture::uploadHardwareBitmapToTexture(GraphicBuffer* buffer) {
+ EGLDisplay eglDisplayHandle = eglGetCurrentDisplay();
+ if (mEglImageHandle != EGL_NO_IMAGE_KHR) {
+ eglDestroyImageKHR(eglDisplayHandle, mEglImageHandle);
+ mEglImageHandle = EGL_NO_IMAGE_KHR;
+ }
+ mEglImageHandle = eglCreateImageKHR(eglDisplayHandle, EGL_NO_CONTEXT, EGL_NATIVE_BUFFER_ANDROID,
+ buffer->getNativeBuffer(), 0);
+ glEGLImageTargetTexture2DOES(GL_TEXTURE_EXTERNAL_OES, mEglImageHandle);
+}
+
+static void uploadToTexture(bool resize, GLint internalFormat, GLenum format, GLenum type,
+ GLsizei stride, GLsizei bpp, GLsizei width, GLsizei height,
+ const GLvoid* data) {
+ const bool useStride =
+ stride != width && Caches::getInstance().extensions().hasUnpackRowLength();
+ if ((stride == width) || useStride) {
+ if (useStride) {
+ glPixelStorei(GL_UNPACK_ROW_LENGTH, stride);
+ }
+
+ if (resize) {
+ glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, width, height, 0, format, type, data);
+ } else {
+ glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, format, type, data);
+ }
+
+ if (useStride) {
+ glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
+ }
+ } else {
+ // With OpenGL ES 2.0 we need to copy the bitmap in a temporary buffer
+ // if the stride doesn't match the width
+
+ GLvoid* temp = (GLvoid*)malloc(width * height * bpp);
+ if (!temp) return;
+
+ uint8_t* pDst = (uint8_t*)temp;
+ uint8_t* pSrc = (uint8_t*)data;
+ for (GLsizei i = 0; i < height; i++) {
+ memcpy(pDst, pSrc, width * bpp);
+ pDst += width * bpp;
+ pSrc += stride * bpp;
+ }
+
+ if (resize) {
+ glTexImage2D(GL_TEXTURE_2D, 0, internalFormat, width, height, 0, format, type, temp);
+ } else {
+ glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, format, type, temp);
+ }
+
+ free(temp);
+ }
+}
+
+void Texture::colorTypeToGlFormatAndType(const Caches& caches, SkColorType colorType, bool needSRGB,
+ GLint* outInternalFormat, GLint* outFormat,
+ GLint* outType) {
+ switch (colorType) {
+ case kAlpha_8_SkColorType:
+ *outFormat = GL_ALPHA;
+ *outInternalFormat = GL_ALPHA;
+ *outType = GL_UNSIGNED_BYTE;
+ break;
+ case kRGB_565_SkColorType:
+ if (needSRGB) {
+ // We would ideally use a GL_RGB/GL_SRGB8 texture but the
+ // intermediate Skia bitmap needs to be ARGB_8888
+ *outFormat = GL_RGBA;
+ *outInternalFormat = caches.rgbaInternalFormat();
+ *outType = GL_UNSIGNED_BYTE;
+ } else {
+ *outFormat = GL_RGB;
+ *outInternalFormat = GL_RGB;
+ *outType = GL_UNSIGNED_SHORT_5_6_5;
+ }
+ break;
+ // ARGB_4444 is upconverted to RGBA_8888
+ case kARGB_4444_SkColorType:
+ case kN32_SkColorType:
+ *outFormat = GL_RGBA;
+ *outInternalFormat = caches.rgbaInternalFormat(needSRGB);
+ *outType = GL_UNSIGNED_BYTE;
+ break;
+ case kGray_8_SkColorType:
+ *outFormat = GL_LUMINANCE;
+ *outInternalFormat = GL_LUMINANCE;
+ *outType = GL_UNSIGNED_BYTE;
+ break;
+ case kRGBA_F16_SkColorType:
+ if (caches.extensions().getMajorGlVersion() >= 3) {
+ // This format is always linear
+ *outFormat = GL_RGBA;
+ *outInternalFormat = GL_RGBA16F;
+ *outType = GL_HALF_FLOAT;
+ } else {
+ *outFormat = GL_RGBA;
+ *outInternalFormat = caches.rgbaInternalFormat(true);
+ *outType = GL_UNSIGNED_BYTE;
+ }
+ break;
+ default:
+ LOG_ALWAYS_FATAL("Unsupported bitmap colorType: %d", colorType);
+ break;
+ }
+}
+
+SkBitmap Texture::uploadToN32(const SkBitmap& bitmap, bool hasLinearBlending,
+ sk_sp<SkColorSpace> sRGB) {
+ SkBitmap rgbaBitmap;
+ rgbaBitmap.allocPixels(SkImageInfo::MakeN32(bitmap.width(), bitmap.height(),
+ bitmap.info().alphaType(),
+ hasLinearBlending ? sRGB : nullptr));
+ rgbaBitmap.eraseColor(0);
+
+ if (bitmap.colorType() == kRGBA_F16_SkColorType) {
+ // Drawing RGBA_F16 onto ARGB_8888 is not supported
+ bitmap.readPixels(rgbaBitmap.info().makeColorSpace(SkColorSpace::MakeSRGB()),
+ rgbaBitmap.getPixels(), rgbaBitmap.rowBytes(), 0, 0);
+ } else {
+ SkCanvas canvas(rgbaBitmap);
+ canvas.drawBitmap(bitmap, 0.0f, 0.0f, nullptr);
+ }
+
+ return rgbaBitmap;
+}
+
+bool Texture::hasUnsupportedColorType(const SkImageInfo& info, bool hasLinearBlending) {
+ return info.colorType() == kARGB_4444_SkColorType ||
+ (info.colorType() == kRGB_565_SkColorType && hasLinearBlending &&
+ info.colorSpace()->isSRGB()) ||
+ (info.colorType() == kRGBA_F16_SkColorType &&
+ Caches::getInstance().extensions().getMajorGlVersion() < 3);
+}
+
+void Texture::upload(Bitmap& bitmap) {
+ ATRACE_FORMAT("Upload %ux%u Texture", bitmap.width(), bitmap.height());
+
+ // We could also enable mipmapping if both bitmap dimensions are powers
+ // of 2 but we'd have to deal with size changes. Let's keep this simple
+ const bool canMipMap = mCaches.extensions().hasNPot();
+
+ // If the texture had mipmap enabled but not anymore,
+ // force a glTexImage2D to discard the mipmap levels
+ bool needsAlloc = canMipMap && mipMap && !bitmap.hasHardwareMipMap();
+ bool setDefaultParams = false;
+
+ if (!mId) {
+ glGenTextures(1, &mId);
+ needsAlloc = true;
+ setDefaultParams = true;
+ }
+
+ bool hasLinearBlending = mCaches.extensions().hasLinearBlending();
+ bool needSRGB = transferFunctionCloseToSRGB(bitmap.info().colorSpace());
+
+ GLint internalFormat, format, type;
+ colorTypeToGlFormatAndType(mCaches, bitmap.colorType(), needSRGB && hasLinearBlending,
+ &internalFormat, &format, &type);
+
+ // Some devices don't support GL_RGBA16F, so we need to compare the color type
+ // and internal GL format to decide what to do with 16 bit bitmaps
+ bool rgba16fNeedsConversion =
+ bitmap.colorType() == kRGBA_F16_SkColorType && internalFormat != GL_RGBA16F;
+
+ // RGBA16F is always linear extended sRGB
+ if (internalFormat == GL_RGBA16F) {
+ mIsLinear = true;
+ }
+
+ mConnector.reset();
+
+ // Alpha masks don't have color profiles
+ // If an RGBA16F bitmap needs conversion, we know the target will be sRGB
+ if (!mIsLinear && internalFormat != GL_ALPHA && !rgba16fNeedsConversion) {
+ SkColorSpace* colorSpace = bitmap.info().colorSpace();
+ // If the bitmap is sRGB we don't need conversion
+ if (colorSpace != nullptr && !colorSpace->isSRGB()) {
+ SkMatrix44 xyzMatrix(SkMatrix44::kUninitialized_Constructor);
+ if (!colorSpace->toXYZD50(&xyzMatrix)) {
+ ALOGW("Incompatible color space!");
+ } else {
+ SkColorSpaceTransferFn fn;
+ if (!colorSpace->isNumericalTransferFn(&fn)) {
+ ALOGW("Incompatible color space, no numerical transfer function!");
+ } else {
+ float data[16];
+ xyzMatrix.asColMajorf(data);
+
+ ColorSpace::TransferParameters p = {fn.fG, fn.fA, fn.fB, fn.fC,
+ fn.fD, fn.fE, fn.fF};
+ ColorSpace src("Unnamed", mat4f((const float*)&data[0]).upperLeft(), p);
+ mConnector.reset(new ColorSpaceConnector(src, ColorSpace::sRGB()));
+
+ // A non-sRGB color space might have a transfer function close enough to sRGB
+ // that we can save shader instructions by using an sRGB sampler
+ // This is only possible if we have hardware support for sRGB textures
+ if (needSRGB && internalFormat == GL_RGBA && mCaches.extensions().hasSRGB() &&
+ !bitmap.isHardware()) {
+ internalFormat = GL_SRGB8_ALPHA8;
+ }
+ }
+ }
+ }
+ }
+
+ GLenum target = bitmap.isHardware() ? GL_TEXTURE_EXTERNAL_OES : GL_TEXTURE_2D;
+ needsAlloc |= updateLayout(bitmap.width(), bitmap.height(), internalFormat, format, target);
+
+ blend = !bitmap.isOpaque();
+ mCaches.textureState().bindTexture(mTarget, mId);
+
+ // TODO: Handle sRGB gray bitmaps
+ if (CC_UNLIKELY(hasUnsupportedColorType(bitmap.info(), hasLinearBlending))) {
+ SkBitmap skBitmap;
+ bitmap.getSkBitmap(&skBitmap);
+ sk_sp<SkColorSpace> sRGB = SkColorSpace::MakeSRGB();
+ SkBitmap rgbaBitmap = uploadToN32(skBitmap, hasLinearBlending, std::move(sRGB));
+ uploadToTexture(needsAlloc, internalFormat, format, type, rgbaBitmap.rowBytesAsPixels(),
+ rgbaBitmap.bytesPerPixel(), rgbaBitmap.width(), rgbaBitmap.height(),
+ rgbaBitmap.getPixels());
+ } else if (bitmap.isHardware()) {
+ uploadHardwareBitmapToTexture(bitmap.graphicBuffer());
+ } else {
+ uploadToTexture(needsAlloc, internalFormat, format, type, bitmap.rowBytesAsPixels(),
+ bitmap.info().bytesPerPixel(), bitmap.width(), bitmap.height(),
+ bitmap.pixels());
+ }
+
+ if (canMipMap) {
+ mipMap = bitmap.hasHardwareMipMap();
+ if (mipMap) {
+ glGenerateMipmap(GL_TEXTURE_2D);
+ }
+ }
+
+ if (setDefaultParams) {
+ setFilter(GL_NEAREST);
+ setWrap(GL_CLAMP_TO_EDGE);
+ }
+}
+
+void Texture::wrap(GLuint id, uint32_t width, uint32_t height, GLint internalFormat, GLint format,
+ GLenum target) {
+ mId = id;
+ mWidth = width;
+ mHeight = height;
+ mFormat = format;
+ mInternalFormat = internalFormat;
+ mTarget = target;
+ mConnector.reset();
+ // We're wrapping an existing texture, so don't double count this memory
+ notifySizeChanged(0);
+}
+
+TransferFunctionType Texture::getTransferFunctionType() const {
+ if (mConnector.get() != nullptr && mInternalFormat != GL_SRGB8_ALPHA8) {
+ const ColorSpace::TransferParameters& p = mConnector->getSource().getTransferParameters();
+ if (MathUtils::isZero(p.e) && MathUtils::isZero(p.f)) {
+ if (MathUtils::areEqual(p.a, 1.0f) && MathUtils::isZero(p.b) &&
+ MathUtils::isZero(p.c) && MathUtils::isZero(p.d)) {
+ if (MathUtils::areEqual(p.g, 1.0f)) {
+ return TransferFunctionType::None;
+ }
+ return TransferFunctionType::Gamma;
+ }
+ return TransferFunctionType::Limited;
+ }
+ return TransferFunctionType::Full;
+ }
+ return TransferFunctionType::None;
+}
+
+}; // namespace uirenderer
+}; // namespace android
diff --git a/libs/hwui/Texture.h b/libs/hwui/Texture.h
new file mode 100644
index 0000000..5b7e4e2
--- /dev/null
+++ b/libs/hwui/Texture.h
@@ -0,0 +1,228 @@
+/*
+ * Copyright (C) 2010 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.
+ */
+
+#ifndef ANDROID_HWUI_TEXTURE_H
+#define ANDROID_HWUI_TEXTURE_H
+
+#include "GpuMemoryTracker.h"
+#include "hwui/Bitmap.h"
+#include "utils/Color.h"
+
+#include <memory>
+
+#include <math/mat3.h>
+
+#include <ui/ColorSpace.h>
+
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
+#include <GLES2/gl2.h>
+#include <GLES3/gl3.h>
+#include <SkBitmap.h>
+
+namespace android {
+
+class GraphicBuffer;
+
+namespace uirenderer {
+
+class Caches;
+class UvMapper;
+class Layer;
+
+/**
+ * Represents an OpenGL texture.
+ */
+class Texture : public GpuMemoryTracker {
+public:
+ static SkBitmap uploadToN32(const SkBitmap& bitmap, bool hasLinearBlending,
+ sk_sp<SkColorSpace> sRGB);
+ static bool hasUnsupportedColorType(const SkImageInfo& info, bool hasLinearBlending);
+ static void colorTypeToGlFormatAndType(const Caches& caches, SkColorType colorType,
+ bool needSRGB, GLint* outInternalFormat,
+ GLint* outFormat, GLint* outType);
+
+ explicit Texture(Caches& caches) : GpuMemoryTracker(GpuObjectType::Texture), mCaches(caches) {}
+
+ virtual ~Texture() {}
+
+ inline void setWrap(GLenum wrap, bool bindTexture = false, bool force = false) {
+ setWrapST(wrap, wrap, bindTexture, force);
+ }
+
+ virtual void setWrapST(GLenum wrapS, GLenum wrapT, bool bindTexture = false,
+ bool force = false);
+
+ inline void setFilter(GLenum filter, bool bindTexture = false, bool force = false) {
+ setFilterMinMag(filter, filter, bindTexture, force);
+ }
+
+ virtual void setFilterMinMag(GLenum min, GLenum mag, bool bindTexture = false,
+ bool force = false);
+
+ /**
+ * Convenience method to call glDeleteTextures() on this texture's id.
+ */
+ void deleteTexture();
+
+ /**
+ * Sets the width, height, and format of the texture along with allocating
+ * the texture ID. Does nothing if the width, height, and format are already
+ * the requested values.
+ *
+ * The image data is undefined after calling this.
+ */
+ void resize(uint32_t width, uint32_t height, GLint internalFormat, GLint format) {
+ upload(internalFormat, width, height, format,
+ internalFormat == GL_RGBA16F ? GL_HALF_FLOAT : GL_UNSIGNED_BYTE, nullptr);
+ }
+
+ /**
+ * Updates this Texture with the contents of the provided Bitmap,
+ * also setting the appropriate width, height, and format. It is not necessary
+ * to call resize() prior to this.
+ *
+ * Note this does not set the generation from the Bitmap.
+ */
+ void upload(Bitmap& source);
+
+ /**
+ * Basically glTexImage2D/glTexSubImage2D.
+ */
+ void upload(GLint internalFormat, uint32_t width, uint32_t height, GLenum format, GLenum type,
+ const void* pixels);
+
+ /**
+ * Wraps an existing texture.
+ */
+ void wrap(GLuint id, uint32_t width, uint32_t height, GLint internalFormat, GLint format,
+ GLenum target);
+
+ GLuint id() const { return mId; }
+
+ uint32_t width() const { return mWidth; }
+
+ uint32_t height() const { return mHeight; }
+
+ GLint format() const { return mFormat; }
+
+ GLint internalFormat() const { return mInternalFormat; }
+
+ GLenum target() const { return mTarget; }
+
+ /**
+ * Returns nullptr if this texture does not require color space conversion
+ * to sRGB, or a valid pointer to a ColorSpaceConnector if a conversion
+ * is required.
+ */
+ constexpr const ColorSpaceConnector* getColorSpaceConnector() const { return mConnector.get(); }
+
+ constexpr bool hasColorSpaceConversion() const { return mConnector.get() != nullptr; }
+
+ TransferFunctionType getTransferFunctionType() const;
+
+ /**
+ * Returns true if this texture uses a linear encoding format.
+ */
+ constexpr bool isLinear() const { return mIsLinear; }
+
+ /**
+ * Generation of the backing bitmap,
+ */
+ uint32_t generation = 0;
+ /**
+ * Indicates whether the texture requires blending.
+ */
+ bool blend = false;
+ /**
+ * Indicates whether this texture should be cleaned up after use.
+ */
+ bool cleanup = false;
+ /**
+ * Optional, size of the original bitmap.
+ */
+ uint32_t bitmapSize = 0;
+ /**
+ * Indicates whether this texture will use trilinear filtering.
+ */
+ bool mipMap = false;
+
+ /**
+ * Optional, pointer to a texture coordinates mapper.
+ */
+ const UvMapper* uvMapper = nullptr;
+
+ /**
+ * Whether or not the Texture is marked in use and thus not evictable for
+ * the current frame. This is reset at the start of a new frame.
+ */
+ void* isInUse = nullptr;
+
+private:
+ // TODO: Temporarily grant private access to GlLayer, remove once
+ // GlLayer can be de-tangled from being a dual-purpose render target
+ // and external texture wrapper
+ friend class GlLayer;
+
+ // Returns true if the texture layout (size, format, etc.) changed, false if it was the same
+ bool updateLayout(uint32_t width, uint32_t height, GLint internalFormat, GLint format,
+ GLenum target);
+ void uploadHardwareBitmapToTexture(GraphicBuffer* buffer);
+ void resetCachedParams();
+
+ GLuint mId = 0;
+ uint32_t mWidth = 0;
+ uint32_t mHeight = 0;
+ GLint mFormat = 0;
+ GLint mInternalFormat = 0;
+ GLenum mTarget = GL_NONE;
+ EGLImageKHR mEglImageHandle = EGL_NO_IMAGE_KHR;
+
+ /* See GLES spec section 3.8.14
+ * "In the initial state, the value assigned to TEXTURE_MIN_FILTER is
+ * NEAREST_MIPMAP_LINEAR and the value for TEXTURE_MAG_FILTER is LINEAR.
+ * s, t, and r wrap modes are all set to REPEAT."
+ */
+ GLenum mWrapS = GL_REPEAT;
+ GLenum mWrapT = GL_REPEAT;
+ GLenum mMinFilter = GL_NEAREST_MIPMAP_LINEAR;
+ GLenum mMagFilter = GL_LINEAR;
+
+ // Indicates whether the content of the texture is in linear space
+ bool mIsLinear = false;
+
+ Caches& mCaches;
+
+ std::unique_ptr<ColorSpaceConnector> mConnector;
+}; // struct Texture
+
+class AutoTexture {
+public:
+ explicit AutoTexture(Texture* texture) : texture(texture) {}
+ ~AutoTexture() {
+ if (texture && texture->cleanup) {
+ texture->deleteTexture();
+ delete texture;
+ }
+ }
+
+ Texture* const texture;
+}; // class AutoTexture
+
+}; // namespace uirenderer
+}; // namespace android
+
+#endif // ANDROID_HWUI_TEXTURE_H
diff --git a/libs/hwui/VkLayer.cpp b/libs/hwui/VkLayer.cpp
new file mode 100644
index 0000000..30fba7a
--- /dev/null
+++ b/libs/hwui/VkLayer.cpp
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+#include "VkLayer.h"
+
+#include "renderstate/RenderState.h"
+
+#include <SkCanvas.h>
+#include <SkSurface.h>
+
+namespace android {
+namespace uirenderer {
+
+void VkLayer::updateTexture() {
+ sk_sp<SkSurface> surface;
+ SkImageInfo info = SkImageInfo::MakeS32(mWidth, mHeight, kPremul_SkAlphaType);
+ surface = SkSurface::MakeRenderTarget(mRenderState.getGrContext(), SkBudgeted::kNo, info);
+ surface->getCanvas()->clear(SK_ColorBLUE);
+ mImage = surface->makeImageSnapshot();
+}
+
+void VkLayer::onVkContextDestroyed() {
+ mImage = nullptr;
+}
+
+}; // namespace uirenderer
+}; // namespace android
diff --git a/libs/hwui/VkLayer.h b/libs/hwui/VkLayer.h
new file mode 100644
index 0000000..e9664d0
--- /dev/null
+++ b/libs/hwui/VkLayer.h
@@ -0,0 +1,70 @@
+/*
+ * Copyright (C) 2017 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.
+ */
+
+#pragma once
+
+#include "Layer.h"
+
+#include <SkImage.h>
+
+namespace android {
+namespace uirenderer {
+/**
+ * A layer has dimensions and is backed by a VkImage.
+ */
+class VkLayer : public Layer {
+public:
+ VkLayer(RenderState& renderState, uint32_t layerWidth, uint32_t layerHeight,
+ sk_sp<SkColorFilter> colorFilter, int alpha, SkBlendMode mode, bool blend)
+ : Layer(renderState, Api::Vulkan, colorFilter, alpha, mode)
+ , mWidth(layerWidth)
+ , mHeight(layerHeight)
+ , mBlend(blend) {}
+
+ virtual ~VkLayer() {}
+
+ uint32_t getWidth() const override { return mWidth; }
+
+ uint32_t getHeight() const override { return mHeight; }
+
+ void setSize(uint32_t width, uint32_t height) override {
+ mWidth = width;
+ mHeight = height;
+ }
+
+ void setBlend(bool blend) override { mBlend = blend; }
+
+ bool isBlend() const override { return mBlend; }
+
+ sk_sp<SkImage> getImage() { return mImage; }
+
+ void updateTexture();
+
+ // If we've destroyed the vulkan context (VkInstance, VkDevice, etc.), we must make sure to
+ // destroy any VkImages that were made with that context.
+ void onVkContextDestroyed();
+
+private:
+ int mWidth;
+ int mHeight;
+ bool mBlend;
+
+ sk_sp<SkImage> mImage;
+
+}; // struct VkLayer
+
+}; // namespace uirenderer
+}; // namespace android
diff --git a/libs/hwui/hwui/Bitmap.cpp b/libs/hwui/hwui/Bitmap.cpp
index 3939696..a7d37f8 100644
--- a/libs/hwui/hwui/Bitmap.cpp
+++ b/libs/hwui/hwui/Bitmap.cpp
@@ -15,11 +15,11 @@
*/
#include "Bitmap.h"
+#include "Caches.h"
#include "HardwareBitmapUploader.h"
#include "Properties.h"
#include "renderthread/RenderProxy.h"
#include "utils/Color.h"
-#include <utils/Trace.h>
#include <sys/mman.h>
diff --git a/libs/hwui/pipeline/skia/LayerDrawable.cpp b/libs/hwui/pipeline/skia/LayerDrawable.cpp
index fb66b50..c41f6a6 100644
--- a/libs/hwui/pipeline/skia/LayerDrawable.cpp
+++ b/libs/hwui/pipeline/skia/LayerDrawable.cpp
@@ -15,6 +15,8 @@
*/
#include "LayerDrawable.h"
+#include "GlLayer.h"
+#include "VkLayer.h"
#include "GrBackendSurface.h"
#include "SkColorFilter.h"
@@ -39,14 +41,35 @@
return false;
}
// transform the matrix based on the layer
- SkMatrix layerTransform = layer->getTransform();
- sk_sp<SkImage> layerImage = layer->getImage();
+ SkMatrix layerTransform;
+ layer->getTransform().copyTo(layerTransform);
+ sk_sp<SkImage> layerImage;
const int layerWidth = layer->getWidth();
const int layerHeight = layer->getHeight();
+ if (layer->getApi() == Layer::Api::OpenGL) {
+ GlLayer* glLayer = static_cast<GlLayer*>(layer);
+ GrGLTextureInfo externalTexture;
+ externalTexture.fTarget = glLayer->getRenderTarget();
+ externalTexture.fID = glLayer->getTextureId();
+ // The format may not be GL_RGBA8, but given the DeferredLayerUpdater and GLConsumer don't
+ // expose that info we use it as our default. Further, given that we only use this texture
+ // as a source this will not impact how Skia uses the texture. The only potential affect
+ // this is anticipated to have is that for some format types if we are not bound as an OES
+ // texture we may get invalid results for SKP capture if we read back the texture.
+ externalTexture.fFormat = GL_RGBA8;
+ GrBackendTexture backendTexture(layerWidth, layerHeight, GrMipMapped::kNo, externalTexture);
+ layerImage = SkImage::MakeFromTexture(context, backendTexture, kTopLeft_GrSurfaceOrigin,
+ kRGBA_8888_SkColorType, kPremul_SkAlphaType, nullptr);
+ } else {
+ SkASSERT(layer->getApi() == Layer::Api::Vulkan);
+ VkLayer* vkLayer = static_cast<VkLayer*>(layer);
+ canvas->clear(SK_ColorGREEN);
+ layerImage = vkLayer->getImage();
+ }
if (layerImage) {
SkMatrix textureMatrixInv;
- textureMatrixInv = layer->getTexTransform();
+ layer->getTexTransform().copyTo(textureMatrixInv);
// TODO: after skia bug https://bugs.chromium.org/p/skia/issues/detail?id=7075 is fixed
// use bottom left origin and remove flipV and invert transformations.
SkMatrix flipV;
@@ -72,9 +95,6 @@
paint.setAlpha(layer->getAlpha());
paint.setBlendMode(layer->getMode());
paint.setColorFilter(layer->getColorSpaceWithFilter());
- if (layer->getForceFilter()) {
- paint.setFilterQuality(kLow_SkFilterQuality);
- }
const bool nonIdentityMatrix = !matrix.isIdentity();
if (nonIdentityMatrix) {
diff --git a/libs/hwui/pipeline/skia/ShaderCache.cpp b/libs/hwui/pipeline/skia/ShaderCache.cpp
index 6700748..073b481 100644
--- a/libs/hwui/pipeline/skia/ShaderCache.cpp
+++ b/libs/hwui/pipeline/skia/ShaderCache.cpp
@@ -18,6 +18,8 @@
#include <algorithm>
#include <log/log.h>
#include <thread>
+#include <array>
+#include <openssl/sha.h>
#include "FileBlobCache.h"
#include "Properties.h"
#include "utils/TraceUtils.h"
@@ -41,7 +43,40 @@
return sCache;
}
-void ShaderCache::initShaderDiskCache() {
+bool ShaderCache::validateCache(const void* identity, ssize_t size) {
+ if (nullptr == identity && size == 0)
+ return true;
+
+ if (nullptr == identity || size < 0) {
+ if (CC_UNLIKELY(Properties::debugLevel & kDebugCaches)) {
+ ALOGW("ShaderCache::validateCache invalid cache identity");
+ }
+ mBlobCache->clear();
+ return false;
+ }
+
+ SHA256_CTX ctx;
+ SHA256_Init(&ctx);
+
+ SHA256_Update(&ctx, identity, size);
+ mIDHash.resize(SHA256_DIGEST_LENGTH);
+ SHA256_Final(mIDHash.data(), &ctx);
+
+ std::array<uint8_t, SHA256_DIGEST_LENGTH> hash;
+ auto key = sIDKey;
+ auto loaded = mBlobCache->get(&key, sizeof(key), hash.data(), hash.size());
+
+ if (loaded && std::equal(hash.begin(), hash.end(), mIDHash.begin()))
+ return true;
+
+ if (CC_UNLIKELY(Properties::debugLevel & kDebugCaches)) {
+ ALOGW("ShaderCache::validateCache cache validation fails");
+ }
+ mBlobCache->clear();
+ return false;
+}
+
+void ShaderCache::initShaderDiskCache(const void* identity, ssize_t size) {
ATRACE_NAME("initShaderDiskCache");
std::lock_guard<std::mutex> lock(mMutex);
@@ -50,6 +85,7 @@
// desktop / laptop GPUs. Thus, disable the shader disk cache for emulator builds.
if (!Properties::runningInEmulator && mFilename.length() > 0) {
mBlobCache.reset(new FileBlobCache(maxKeySize, maxValueSize, maxTotalSize, mFilename));
+ validateCache(identity, size);
mInitialized = true;
}
}
@@ -104,6 +140,18 @@
return SkData::MakeFromMalloc(valueBuffer, valueSize);
}
+void ShaderCache::saveToDiskLocked() {
+ ATRACE_NAME("ShaderCache::saveToDiskLocked");
+ if (mInitialized && mBlobCache && mSavePending) {
+ if (mIDHash.size()) {
+ auto key = sIDKey;
+ mBlobCache->set(&key, sizeof(key), mIDHash.data(), mIDHash.size());
+ }
+ mBlobCache->writeToFile();
+ }
+ mSavePending = false;
+}
+
void ShaderCache::store(const SkData& key, const SkData& data) {
ATRACE_NAME("ShaderCache::store");
std::lock_guard<std::mutex> lock(mMutex);
@@ -129,11 +177,7 @@
std::thread deferredSaveThread([this]() {
sleep(mDeferredSaveDelay);
std::lock_guard<std::mutex> lock(mMutex);
- ATRACE_NAME("ShaderCache::saveToDisk");
- if (mInitialized && mBlobCache) {
- mBlobCache->writeToFile();
- }
- mSavePending = false;
+ saveToDiskLocked();
});
deferredSaveThread.detach();
}
diff --git a/libs/hwui/pipeline/skia/ShaderCache.h b/libs/hwui/pipeline/skia/ShaderCache.h
index 27473d6..82804cf 100644
--- a/libs/hwui/pipeline/skia/ShaderCache.h
+++ b/libs/hwui/pipeline/skia/ShaderCache.h
@@ -40,12 +40,21 @@
ANDROID_API static ShaderCache& get();
/**
- * "initShaderDiskCache" loads the serialized cache contents from disk and puts the ShaderCache
- * into an initialized state, such that it is able to insert and retrieve entries from the
- * cache. This should be called when HWUI pipeline is initialized. When not in the initialized
- * state the load and store methods will return without performing any cache operations.
+ * initShaderDiskCache" loads the serialized cache contents from disk,
+ * optionally checks that the on-disk cache matches a provided identity,
+ * and puts the ShaderCache into an initialized state, such that it is
+ * able to insert and retrieve entries from the cache. If identity is
+ * non-null and validation fails, the cache is initialized but contains
+ * no data. If size is less than zero, the cache is initilaized but
+ * contains no data.
+ *
+ * This should be called when HWUI pipeline is initialized. When not in
+ * the initialized state the load and store methods will return without
+ * performing any cache operations.
*/
- virtual void initShaderDiskCache();
+ virtual void initShaderDiskCache(const void *identity, ssize_t size);
+
+ virtual void initShaderDiskCache() { initShaderDiskCache(nullptr, 0); }
/**
* "setFilename" sets the name of the file that should be used to store
@@ -83,6 +92,19 @@
BlobCache* getBlobCacheLocked();
/**
+ * "validateCache" updates the cache to match the given identity. If the
+ * cache currently has the wrong identity, all entries in the cache are cleared.
+ */
+ bool validateCache(const void* identity, ssize_t size);
+
+ /**
+ * "saveToDiskLocked" attemps to save the current contents of the cache to
+ * disk. If the identity hash exists, we will insert the identity hash into
+ * the cache for next validation.
+ */
+ void saveToDiskLocked();
+
+ /**
* "mInitialized" indicates whether the ShaderCache is in the initialized
* state. It is initialized to false at construction time, and gets set to
* true when initialize is called.
@@ -111,6 +133,15 @@
std::string mFilename;
/**
+ * "mIDHash" is the current identity hash for the cache validation. It is
+ * initialized to an empty vector at construction time, and its content is
+ * generated in the call of the validateCache method. An empty vector
+ * indicates that cache validation is not performed, and the hash should
+ * not be stored on disk.
+ */
+ std::vector<uint8_t> mIDHash;
+
+ /**
* "mSavePending" indicates whether or not a deferred save operation is
* pending. Each time a key/value pair is inserted into the cache via
* load, a deferred save is initiated if one is not already pending.
@@ -140,6 +171,11 @@
*/
static ShaderCache sCache;
+ /**
+ * "sIDKey" is the cache key of the identity hash
+ */
+ static constexpr uint8_t sIDKey = 0;
+
friend class ShaderCacheTestUtils; //used for unit testing
};
diff --git a/libs/hwui/pipeline/skia/SkiaOpenGLPipeline.cpp b/libs/hwui/pipeline/skia/SkiaOpenGLPipeline.cpp
index 2ae3723..78f5a71 100644
--- a/libs/hwui/pipeline/skia/SkiaOpenGLPipeline.cpp
+++ b/libs/hwui/pipeline/skia/SkiaOpenGLPipeline.cpp
@@ -17,6 +17,7 @@
#include "SkiaOpenGLPipeline.h"
#include "DeferredLayerUpdater.h"
+#include "GlLayer.h"
#include "LayerDrawable.h"
#include "SkiaPipeline.h"
#include "SkiaProfileRenderer.h"
@@ -186,9 +187,18 @@
return false;
}
+static Layer* createLayer(RenderState& renderState, uint32_t layerWidth, uint32_t layerHeight,
+ sk_sp<SkColorFilter> colorFilter, int alpha, SkBlendMode mode,
+ bool blend) {
+ GlLayer* layer =
+ new GlLayer(renderState, layerWidth, layerHeight, colorFilter, alpha, mode, blend);
+ layer->generateTexture();
+ return layer;
+}
+
DeferredLayerUpdater* SkiaOpenGLPipeline::createTextureLayer() {
mRenderThread.requireGlContext();
- return new DeferredLayerUpdater(mRenderThread.renderState());
+ return new DeferredLayerUpdater(mRenderThread.renderState(), createLayer, Layer::Api::OpenGL);
}
void SkiaOpenGLPipeline::onStop() {
diff --git a/libs/hwui/pipeline/skia/SkiaVulkanPipeline.cpp b/libs/hwui/pipeline/skia/SkiaVulkanPipeline.cpp
index 5f2eee4..b2519fe 100644
--- a/libs/hwui/pipeline/skia/SkiaVulkanPipeline.cpp
+++ b/libs/hwui/pipeline/skia/SkiaVulkanPipeline.cpp
@@ -20,6 +20,7 @@
#include "Readback.h"
#include "SkiaPipeline.h"
#include "SkiaProfileRenderer.h"
+#include "VkLayer.h"
#include "renderstate/RenderState.h"
#include "renderthread/Frame.h"
@@ -113,10 +114,16 @@
return false;
}
+static Layer* createLayer(RenderState& renderState, uint32_t layerWidth, uint32_t layerHeight,
+ sk_sp<SkColorFilter> colorFilter, int alpha, SkBlendMode mode,
+ bool blend) {
+ return new VkLayer(renderState, layerWidth, layerHeight, colorFilter, alpha, mode, blend);
+}
+
DeferredLayerUpdater* SkiaVulkanPipeline::createTextureLayer() {
mVkManager.initialize();
- return new DeferredLayerUpdater(mRenderThread.renderState());
+ return new DeferredLayerUpdater(mRenderThread.renderState(), createLayer, Layer::Api::Vulkan);
}
void SkiaVulkanPipeline::onStop() {}
diff --git a/libs/hwui/renderstate/PixelBufferState.cpp b/libs/hwui/renderstate/PixelBufferState.cpp
new file mode 100644
index 0000000..3a6efb8
--- /dev/null
+++ b/libs/hwui/renderstate/PixelBufferState.cpp
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2015 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.
+ */
+#include "renderstate/PixelBufferState.h"
+
+namespace android {
+namespace uirenderer {
+
+PixelBufferState::PixelBufferState() : mCurrentPixelBuffer(0) {}
+
+bool PixelBufferState::bind(GLuint buffer) {
+ if (mCurrentPixelBuffer != buffer) {
+ glBindBuffer(GL_PIXEL_UNPACK_BUFFER, buffer);
+ mCurrentPixelBuffer = buffer;
+ return true;
+ }
+ return false;
+}
+
+bool PixelBufferState::unbind() {
+ if (mCurrentPixelBuffer) {
+ glBindBuffer(GL_PIXEL_UNPACK_BUFFER, 0);
+ mCurrentPixelBuffer = 0;
+ return true;
+ }
+ return false;
+}
+
+} /* namespace uirenderer */
+} /* namespace android */
diff --git a/libs/hwui/renderstate/PixelBufferState.h b/libs/hwui/renderstate/PixelBufferState.h
new file mode 100644
index 0000000..f7ae6c5
--- /dev/null
+++ b/libs/hwui/renderstate/PixelBufferState.h
@@ -0,0 +1,38 @@
+/*
+ * Copyright (C) 2015 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.
+ */
+#ifndef RENDERSTATE_PIXELBUFFERSTATE_H
+#define RENDERSTATE_PIXELBUFFERSTATE_H
+
+#include <GLES3/gl3.h>
+
+namespace android {
+namespace uirenderer {
+
+class PixelBufferState {
+ friend class Caches; // TODO: move to RenderState
+public:
+ bool bind(GLuint buffer);
+ bool unbind();
+
+private:
+ PixelBufferState();
+ GLuint mCurrentPixelBuffer;
+};
+
+} /* namespace uirenderer */
+} /* namespace android */
+
+#endif // RENDERSTATE_PIXELBUFFERSTATE_H
diff --git a/libs/hwui/renderstate/RenderState.cpp b/libs/hwui/renderstate/RenderState.cpp
index b524bcb..3be84f5 100644
--- a/libs/hwui/renderstate/RenderState.cpp
+++ b/libs/hwui/renderstate/RenderState.cpp
@@ -16,6 +16,8 @@
#include "renderstate/RenderState.h"
#include <GpuMemoryTracker.h>
#include "DeferredLayerUpdater.h"
+#include "GlLayer.h"
+#include "VkLayer.h"
#include "Snapshot.h"
#include "renderthread/CanvasContext.h"
@@ -37,11 +39,44 @@
RenderState::~RenderState() {
}
-void RenderState::onContextCreated() {
+void RenderState::onGLContextCreated() {
+ GpuMemoryTracker::onGpuContextCreated();
+
+ // This is delayed because the first access of Caches makes GL calls
+ if (!mCaches) {
+ mCaches = &Caches::createInstance(*this);
+ }
+ mCaches->init();
+}
+
+static void layerLostGlContext(Layer* layer) {
+ LOG_ALWAYS_FATAL_IF(layer->getApi() != Layer::Api::OpenGL,
+ "layerLostGlContext on non GL layer");
+ static_cast<GlLayer*>(layer)->onGlContextLost();
+}
+
+void RenderState::onGLContextDestroyed() {
+ // TODO: reset all cached state in state objects
+ std::for_each(mActiveLayers.begin(), mActiveLayers.end(), layerLostGlContext);
+
+ mCaches->terminate();
+
+ destroyLayersInUpdater();
+ GpuMemoryTracker::onGpuContextDestroyed();
+}
+
+void RenderState::onVkContextCreated() {
GpuMemoryTracker::onGpuContextCreated();
}
-void RenderState::onContextDestroyed() {
+static void layerDestroyedVkContext(Layer* layer) {
+ LOG_ALWAYS_FATAL_IF(layer->getApi() != Layer::Api::Vulkan,
+ "layerLostVkContext on non Vulkan layer");
+ static_cast<VkLayer*>(layer)->onVkContextDestroyed();
+}
+
+void RenderState::onVkContextDestroyed() {
+ std::for_each(mActiveLayers.begin(), mActiveLayers.end(), layerDestroyedVkContext);
destroyLayersInUpdater();
GpuMemoryTracker::onGpuContextDestroyed();
}
@@ -50,6 +85,10 @@
return mRenderThread.getGrContext();
}
+void RenderState::flush(Caches::FlushMode mode) {
+ if (mCaches) mCaches->flush(mode);
+}
+
void RenderState::onBitmapDestroyed(uint32_t pixelRefId) {
// DEAD CODE
}
@@ -87,6 +126,42 @@
glDeleteFramebuffers(1, &fbo);
}
+void RenderState::invokeFunctor(Functor* functor, DrawGlInfo::Mode mode, DrawGlInfo* info) {
+ if (mode == DrawGlInfo::kModeProcessNoContext) {
+ // If there's no context we don't need to interrupt as there's
+ // no gl state to save/restore
+ (*functor)(mode, info);
+ } else {
+ interruptForFunctorInvoke();
+ (*functor)(mode, info);
+ resumeFromFunctorInvoke();
+ }
+}
+
+void RenderState::interruptForFunctorInvoke() {
+ mCaches->textureState().resetActiveTexture();
+ debugOverdraw(false, false);
+ // TODO: We need a way to know whether the functor is sRGB aware (b/32072673)
+ if (mCaches->extensions().hasLinearBlending() && mCaches->extensions().hasSRGBWriteControl()) {
+ glDisable(GL_FRAMEBUFFER_SRGB_EXT);
+ }
+}
+
+void RenderState::resumeFromFunctorInvoke() {
+ if (mCaches->extensions().hasLinearBlending() && mCaches->extensions().hasSRGBWriteControl()) {
+ glEnable(GL_FRAMEBUFFER_SRGB_EXT);
+ }
+
+ glViewport(0, 0, mViewportWidth, mViewportHeight);
+ glBindFramebuffer(GL_FRAMEBUFFER, mFramebuffer);
+ debugOverdraw(false, false);
+
+ glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
+
+ mCaches->textureState().activateTexture(0);
+ mCaches->textureState().resetBoundTextures();
+}
+
void RenderState::debugOverdraw(bool enable, bool clear) {
// DEAD CODE
}
@@ -115,9 +190,5 @@
// DEAD CODE
}
-renderthread::RenderThread& RenderState::getRenderThread() {
- return mRenderThread;
-}
-
} /* namespace uirenderer */
} /* namespace android */
diff --git a/libs/hwui/renderstate/RenderState.h b/libs/hwui/renderstate/RenderState.h
index f39aa4b..97785a4 100644
--- a/libs/hwui/renderstate/RenderState.h
+++ b/libs/hwui/renderstate/RenderState.h
@@ -16,6 +16,8 @@
#ifndef RENDERSTATE_H
#define RENDERSTATE_H
+#include "Caches.h"
+#include "renderstate/PixelBufferState.h"
#include "utils/Macros.h"
#include <GLES2/gl2.h>
@@ -32,6 +34,7 @@
namespace android {
namespace uirenderer {
+class Caches;
class Layer;
class DeferredLayerUpdater;
@@ -41,16 +44,22 @@
class RenderThread;
}
+// TODO: Replace Cache's GL state tracking with this. For now it's more a thin
// wrapper of Caches for users to migrate to.
class RenderState {
PREVENT_COPY_AND_ASSIGN(RenderState);
friend class renderthread::RenderThread;
+ friend class Caches;
friend class renderthread::CacheManager;
public:
- void onContextCreated();
- void onContextDestroyed();
+ void onGLContextCreated();
+ void onGLContextDestroyed();
+ void onVkContextCreated();
+ void onVkContextDestroyed();
+
+ void flush(Caches::FlushMode flushMode);
void onBitmapDestroyed(uint32_t pixelRefId);
void setViewport(GLsizei width, GLsizei height);
@@ -61,6 +70,8 @@
GLuint createFramebuffer();
void deleteFramebuffer(GLuint fbo);
+ void invokeFunctor(Functor* functor, DrawGlInfo::Mode mode, DrawGlInfo* info);
+
void debugOverdraw(bool enable, bool clear);
void registerLayer(Layer* layer) { mActiveLayers.insert(layer); }
@@ -90,15 +101,16 @@
void dump();
- renderthread::RenderThread& getRenderThread();
-
private:
+ void interruptForFunctorInvoke();
+ void resumeFromFunctorInvoke();
void destroyLayersInUpdater();
explicit RenderState(renderthread::RenderThread& thread);
~RenderState();
renderthread::RenderThread& mRenderThread;
+ Caches* mCaches = nullptr;
std::set<Layer*> mActiveLayers;
std::set<DeferredLayerUpdater*> mActiveLayerUpdaters;
diff --git a/libs/hwui/renderstate/TextureState.cpp b/libs/hwui/renderstate/TextureState.cpp
new file mode 100644
index 0000000..470b4f5
--- /dev/null
+++ b/libs/hwui/renderstate/TextureState.cpp
@@ -0,0 +1,147 @@
+/*
+ * Copyright (C) 2015 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.
+ */
+#include "renderstate/TextureState.h"
+
+#include "Caches.h"
+#include "utils/TraceUtils.h"
+
+#include <GLES3/gl3.h>
+#include <SkBitmap.h>
+#include <SkCanvas.h>
+#include <memory>
+
+namespace android {
+namespace uirenderer {
+
+// Width of mShadowLutTexture, defines how accurate the shadow alpha lookup table is
+static const int SHADOW_LUT_SIZE = 128;
+
+// Must define as many texture units as specified by kTextureUnitsCount
+const GLenum kTextureUnits[] = {GL_TEXTURE0, GL_TEXTURE1, GL_TEXTURE2, GL_TEXTURE3};
+
+TextureState::TextureState() : mTextureUnit(0) {
+ glActiveTexture(kTextureUnits[0]);
+ resetBoundTextures();
+
+ GLint maxTextureUnits;
+ glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &maxTextureUnits);
+ LOG_ALWAYS_FATAL_IF(maxTextureUnits < kTextureUnitsCount,
+ "At least %d texture units are required!", kTextureUnitsCount);
+ glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+}
+
+TextureState::~TextureState() {
+ if (mShadowLutTexture != nullptr) {
+ mShadowLutTexture->deleteTexture();
+ }
+}
+
+/**
+ * Maps shadow geometry 'alpha' varying (1 for darkest, 0 for transparent) to
+ * darkness at that spot. Input values of 0->1 should be mapped within the same
+ * range, but can affect the curve for a different visual falloff.
+ *
+ * This is used to populate the shadow LUT texture for quick lookup in the
+ * shadow shader.
+ */
+static float computeShadowOpacity(float ratio) {
+ // exponential falloff function provided by UX
+ float val = 1 - ratio;
+ return exp(-val * val * 4.0) - 0.018;
+}
+
+void TextureState::constructTexture(Caches& caches) {
+ if (mShadowLutTexture == nullptr) {
+ mShadowLutTexture.reset(new Texture(caches));
+
+ unsigned char bytes[SHADOW_LUT_SIZE];
+ for (int i = 0; i < SHADOW_LUT_SIZE; i++) {
+ float inputRatio = i / (SHADOW_LUT_SIZE - 1.0f);
+ bytes[i] = computeShadowOpacity(inputRatio) * 255;
+ }
+ mShadowLutTexture->upload(GL_ALPHA, SHADOW_LUT_SIZE, 1, GL_ALPHA, GL_UNSIGNED_BYTE, &bytes);
+ mShadowLutTexture->setFilter(GL_LINEAR);
+ mShadowLutTexture->setWrap(GL_CLAMP_TO_EDGE);
+ }
+}
+
+void TextureState::activateTexture(GLuint textureUnit) {
+ LOG_ALWAYS_FATAL_IF(textureUnit >= kTextureUnitsCount,
+ "Tried to use texture unit index %d, only %d exist", textureUnit,
+ kTextureUnitsCount);
+ if (mTextureUnit != textureUnit) {
+ glActiveTexture(kTextureUnits[textureUnit]);
+ mTextureUnit = textureUnit;
+ }
+}
+
+void TextureState::resetActiveTexture() {
+ mTextureUnit = -1;
+}
+
+void TextureState::bindTexture(GLuint texture) {
+ if (mBoundTextures[mTextureUnit] != texture) {
+ glBindTexture(GL_TEXTURE_2D, texture);
+ mBoundTextures[mTextureUnit] = texture;
+ }
+}
+
+void TextureState::bindTexture(GLenum target, GLuint texture) {
+ if (target == GL_TEXTURE_2D) {
+ bindTexture(texture);
+ } else {
+ // GLConsumer directly calls glBindTexture() with
+ // target=GL_TEXTURE_EXTERNAL_OES, don't cache this target
+ // since the cached state could be stale
+ glBindTexture(target, texture);
+ }
+}
+
+void TextureState::deleteTexture(GLuint texture) {
+ // When glDeleteTextures() is called on a currently bound texture,
+ // OpenGL ES specifies that the texture is then considered unbound
+ // Consider the following series of calls:
+ //
+ // glGenTextures -> creates texture name 2
+ // glBindTexture(2)
+ // glDeleteTextures(2) -> 2 is now unbound
+ // glGenTextures -> can return 2 again
+ //
+ // If we don't call glBindTexture(2) after the second glGenTextures
+ // call, any texture operation will be performed on the default
+ // texture (name=0)
+
+ unbindTexture(texture);
+
+ glDeleteTextures(1, &texture);
+}
+
+void TextureState::resetBoundTextures() {
+ for (int i = 0; i < kTextureUnitsCount; i++) {
+ mBoundTextures[i] = 0;
+ }
+}
+
+void TextureState::unbindTexture(GLuint texture) {
+ for (int i = 0; i < kTextureUnitsCount; i++) {
+ if (mBoundTextures[i] == texture) {
+ mBoundTextures[i] = 0;
+ }
+ }
+}
+
+} /* namespace uirenderer */
+} /* namespace android */
diff --git a/libs/hwui/renderstate/TextureState.h b/libs/hwui/renderstate/TextureState.h
new file mode 100644
index 0000000..f1996d4
--- /dev/null
+++ b/libs/hwui/renderstate/TextureState.h
@@ -0,0 +1,98 @@
+/*
+ * Copyright (C) 2015 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.
+ */
+#ifndef RENDERSTATE_TEXTURESTATE_H
+#define RENDERSTATE_TEXTURESTATE_H
+
+#include "Texture.h"
+#include "Vertex.h"
+
+#include <GLES2/gl2.h>
+#include <GLES2/gl2ext.h>
+#include <memory>
+
+namespace android {
+namespace uirenderer {
+
+class Texture;
+
+class TextureState {
+ friend class Caches; // TODO: move to RenderState
+public:
+ void constructTexture(Caches& caches);
+
+ /**
+ * Activate the specified texture unit. The texture unit must
+ * be specified using an integer number (0 for GL_TEXTURE0 etc.)
+ */
+ void activateTexture(GLuint textureUnit);
+
+ /**
+ * Invalidate the cached value of the active texture unit.
+ */
+ void resetActiveTexture();
+
+ /**
+ * Binds the specified texture as a GL_TEXTURE_2D texture.
+ * All texture bindings must be performed with this method or
+ * bindTexture(GLenum, GLuint).
+ */
+ void bindTexture(GLuint texture);
+
+ /**
+ * Binds the specified texture with the specified render target.
+ * All texture bindings must be performed with this method or
+ * bindTexture(GLuint).
+ */
+ void bindTexture(GLenum target, GLuint texture);
+
+ /**
+ * Deletes the specified texture and clears it from the cache
+ * of bound textures.
+ * All textures must be deleted using this method.
+ */
+ void deleteTexture(GLuint texture);
+
+ /**
+ * Signals that the cache of bound textures should be cleared.
+ * Other users of the context may have altered which textures are bound.
+ */
+ void resetBoundTextures();
+
+ /**
+ * Clear the cache of bound textures.
+ */
+ void unbindTexture(GLuint texture);
+
+ Texture* getShadowLutTexture() { return mShadowLutTexture.get(); }
+
+private:
+ // total number of texture units available for use
+ static const int kTextureUnitsCount = 4;
+
+ TextureState();
+ ~TextureState();
+ GLuint mTextureUnit;
+
+ // Caches texture bindings for the GL_TEXTURE_2D target
+ GLuint mBoundTextures[kTextureUnitsCount];
+
+ std::unique_ptr<Texture> mShadowLutTexture;
+};
+
+} /* namespace uirenderer */
+} /* namespace android */
+
+#endif // RENDERSTATE_BLEND_H
diff --git a/libs/hwui/renderthread/CacheManager.cpp b/libs/hwui/renderthread/CacheManager.cpp
index c45eeda..82bfc49 100644
--- a/libs/hwui/renderthread/CacheManager.cpp
+++ b/libs/hwui/renderthread/CacheManager.cpp
@@ -21,7 +21,6 @@
#include "RenderThread.h"
#include "pipeline/skia/ShaderCache.h"
#include "pipeline/skia/SkiaMemoryTracer.h"
-#include "Properties.h"
#include "renderstate/RenderState.h"
#include <GrContextOptions.h>
@@ -51,7 +50,6 @@
mVectorDrawableAtlas = new skiapipeline::VectorDrawableAtlas(
mMaxSurfaceArea / 2,
skiapipeline::VectorDrawableAtlas::StorageMode::disallowSharedSurface);
- skiapipeline::ShaderCache::get().initShaderDiskCache();
}
void CacheManager::reset(sk_sp<GrContext> context) {
@@ -104,7 +102,7 @@
}
};
-void CacheManager::configureContext(GrContextOptions* contextOptions) {
+void CacheManager::configureContext(GrContextOptions* contextOptions, const void* identity, ssize_t size) {
contextOptions->fAllowPathMaskCaching = true;
float screenMP = mMaxSurfaceArea / 1024.0f / 1024.0f;
@@ -134,7 +132,9 @@
contextOptions->fExecutor = mTaskProcessor.get();
}
- contextOptions->fPersistentCache = &skiapipeline::ShaderCache::get();
+ auto& cache = skiapipeline::ShaderCache::get();
+ cache.initShaderDiskCache(identity, size);
+ contextOptions->fPersistentCache = &cache;
contextOptions->fGpuPathRenderers &= ~GpuPathRenderers::kCoverageCounting;
}
@@ -215,12 +215,11 @@
log.appendFormat(" Layer Info:\n");
}
- const char* layerType = Properties::getRenderPipelineType() == RenderPipelineType::SkiaGL
- ? "GlLayer" : "VkLayer";
size_t layerMemoryTotal = 0;
for (std::set<Layer*>::iterator it = renderState->mActiveLayers.begin();
it != renderState->mActiveLayers.end(); it++) {
const Layer* layer = *it;
+ const char* layerType = layer->getApi() == Layer::Api::OpenGL ? "GlLayer" : "VkLayer";
log.appendFormat(" %s size %dx%d\n", layerType, layer->getWidth(),
layer->getHeight());
layerMemoryTotal += layer->getWidth() * layer->getHeight() * 4;
diff --git a/libs/hwui/renderthread/CacheManager.h b/libs/hwui/renderthread/CacheManager.h
index 7d73352..35fc91a 100644
--- a/libs/hwui/renderthread/CacheManager.h
+++ b/libs/hwui/renderthread/CacheManager.h
@@ -44,7 +44,7 @@
public:
enum class TrimMemoryMode { Complete, UiHidden };
- void configureContext(GrContextOptions* context);
+ void configureContext(GrContextOptions* context, const void* identity, ssize_t size);
void trimMemory(TrimMemoryMode mode);
void trimStaleResources();
void dumpMemoryUsage(String8& log, const RenderState* renderState = nullptr);
diff --git a/libs/hwui/renderthread/CanvasContext.cpp b/libs/hwui/renderthread/CanvasContext.cpp
index 8b07d1d..5d72523 100644
--- a/libs/hwui/renderthread/CanvasContext.cpp
+++ b/libs/hwui/renderthread/CanvasContext.cpp
@@ -18,6 +18,7 @@
#include <GpuMemoryTracker.h>
#include "AnimationContext.h"
+#include "Caches.h"
#include "EglManager.h"
#include "Frame.h"
#include "LayerUpdateQueue.h"
@@ -494,6 +495,13 @@
}
GpuMemoryTracker::onFrameCompleted();
+#ifdef BUGREPORT_FONT_CACHE_USAGE
+ auto renderType = Properties::getRenderPipelineType();
+ if (RenderPipelineType::OpenGL == renderType) {
+ Caches& caches = Caches::getInstance();
+ caches.fontRenderer.getFontRenderer().historyTracker().frameCompleted();
+ }
+#endif
}
// Called by choreographer to do an RT-driven animation
diff --git a/libs/hwui/renderthread/EglManager.cpp b/libs/hwui/renderthread/EglManager.cpp
index 5f8d7ad..cd21822 100644
--- a/libs/hwui/renderthread/EglManager.cpp
+++ b/libs/hwui/renderthread/EglManager.cpp
@@ -18,7 +18,6 @@
#include <cutils/properties.h>
#include <log/log.h>
-#include <private/gui/SyncFeatures.h>
#include <utils/Trace.h>
#include "utils/StringUtils.h"
@@ -465,109 +464,6 @@
return preserved;
}
-status_t EglManager::fenceWait(sp<Fence>& fence) {
- if (!hasEglContext()) {
- ALOGE("EglManager::fenceWait: EGLDisplay not initialized");
- return INVALID_OPERATION;
- }
-
- if (SyncFeatures::getInstance().useWaitSync() &&
- SyncFeatures::getInstance().useNativeFenceSync()) {
- // Block GPU on the fence.
- // Create an EGLSyncKHR from the current fence.
- int fenceFd = fence->dup();
- if (fenceFd == -1) {
- ALOGE("EglManager::fenceWait: error dup'ing fence fd: %d", errno);
- return -errno;
- }
- EGLint attribs[] = {
- EGL_SYNC_NATIVE_FENCE_FD_ANDROID, fenceFd,
- EGL_NONE
- };
- EGLSyncKHR sync = eglCreateSyncKHR(mEglDisplay,
- EGL_SYNC_NATIVE_FENCE_ANDROID, attribs);
- if (sync == EGL_NO_SYNC_KHR) {
- close(fenceFd);
- ALOGE("EglManager::fenceWait: error creating EGL fence: %#x", eglGetError());
- return UNKNOWN_ERROR;
- }
-
- // XXX: The spec draft is inconsistent as to whether this should
- // return an EGLint or void. Ignore the return value for now, as
- // it's not strictly needed.
- eglWaitSyncKHR(mEglDisplay, sync, 0);
- EGLint eglErr = eglGetError();
- eglDestroySyncKHR(mEglDisplay, sync);
- if (eglErr != EGL_SUCCESS) {
- ALOGE("EglManager::fenceWait: error waiting for EGL fence: %#x", eglErr);
- return UNKNOWN_ERROR;
- }
- } else {
- // Block CPU on the fence.
- status_t err = fence->waitForever("EglManager::fenceWait");
- if (err != NO_ERROR) {
- ALOGE("EglManager::fenceWait: error waiting for fence: %d", err);
- return err;
- }
- }
- return OK;
-}
-
-status_t EglManager::createReleaseFence(bool useFenceSync, EGLSyncKHR* eglFence,
- sp<Fence>& nativeFence) {
- if (!hasEglContext()) {
- ALOGE("EglManager::createReleaseFence: EGLDisplay not initialized");
- return INVALID_OPERATION;
- }
-
- if (SyncFeatures::getInstance().useNativeFenceSync()) {
- EGLSyncKHR sync = eglCreateSyncKHR(mEglDisplay,
- EGL_SYNC_NATIVE_FENCE_ANDROID, nullptr);
- if (sync == EGL_NO_SYNC_KHR) {
- ALOGE("EglManager::createReleaseFence: error creating EGL fence: %#x",
- eglGetError());
- return UNKNOWN_ERROR;
- }
- glFlush();
- int fenceFd = eglDupNativeFenceFDANDROID(mEglDisplay, sync);
- eglDestroySyncKHR(mEglDisplay, sync);
- if (fenceFd == EGL_NO_NATIVE_FENCE_FD_ANDROID) {
- ALOGE("EglManager::createReleaseFence: error dup'ing native fence "
- "fd: %#x", eglGetError());
- return UNKNOWN_ERROR;
- }
- nativeFence = new Fence(fenceFd);
- *eglFence = EGL_NO_SYNC_KHR;
- } else if (useFenceSync && SyncFeatures::getInstance().useFenceSync()) {
- if (*eglFence != EGL_NO_SYNC_KHR) {
- // There is already a fence for the current slot. We need to
- // wait on that before replacing it with another fence to
- // ensure that all outstanding buffer accesses have completed
- // before the producer accesses it.
- EGLint result = eglClientWaitSyncKHR(mEglDisplay, *eglFence, 0, 1000000000);
- if (result == EGL_FALSE) {
- ALOGE("EglManager::createReleaseFence: error waiting for previous fence: %#x",
- eglGetError());
- return UNKNOWN_ERROR;
- } else if (result == EGL_TIMEOUT_EXPIRED_KHR) {
- ALOGE("EglManager::createReleaseFence: timeout waiting for previous fence");
- return TIMED_OUT;
- }
- eglDestroySyncKHR(mEglDisplay, *eglFence);
- }
-
- // Create a fence for the outstanding accesses in the current
- // OpenGL ES context.
- *eglFence = eglCreateSyncKHR(mEglDisplay, EGL_SYNC_FENCE_KHR, nullptr);
- if (*eglFence == EGL_NO_SYNC_KHR) {
- ALOGE("EglManager::createReleaseFence: error creating fence: %#x", eglGetError());
- return UNKNOWN_ERROR;
- }
- glFlush();
- }
- return OK;
-}
-
} /* namespace renderthread */
} /* namespace uirenderer */
} /* namespace android */
diff --git a/libs/hwui/renderthread/EglManager.h b/libs/hwui/renderthread/EglManager.h
index 507673a..8e8bb8b 100644
--- a/libs/hwui/renderthread/EglManager.h
+++ b/libs/hwui/renderthread/EglManager.h
@@ -17,10 +17,8 @@
#define EGLMANAGER_H
#include <EGL/egl.h>
-#include <EGL/eglext.h>
#include <SkRect.h>
#include <cutils/compiler.h>
-#include <ui/Fence.h>
#include <ui/GraphicBuffer.h>
#include <utils/StrongPointer.h>
@@ -68,14 +66,6 @@
EGLDisplay eglDisplay() const { return mEglDisplay; }
- // Inserts a wait on fence command into the OpenGL ES command stream. If EGL extension
- // support is missing, block the CPU on the fence.
- status_t fenceWait(sp<Fence>& fence);
-
- // Creates a fence that is signaled, when all the pending GL commands are flushed.
- // Depending on installed extensions, the result is either Android native fence or EGL fence.
- status_t createReleaseFence(bool useFenceSync, EGLSyncKHR* eglFence, sp<Fence>& nativeFence);
-
private:
void initExtensions();
diff --git a/libs/hwui/renderthread/RenderThread.cpp b/libs/hwui/renderthread/RenderThread.cpp
index 65f95ad..36ffaee 100644
--- a/libs/hwui/renderthread/RenderThread.cpp
+++ b/libs/hwui/renderthread/RenderThread.cpp
@@ -178,7 +178,7 @@
return;
}
mEglManager->initialize();
- renderState().onContextCreated();
+ renderState().onGLContextCreated();
#ifdef HWUI_GLES_WRAP_ENABLED
debug::GlesDriver* driver = debug::GlesDriver::get();
@@ -191,7 +191,9 @@
GrContextOptions options;
options.fPreferExternalImagesOverES3 = true;
options.fDisableDistanceFieldPaths = true;
- cacheManager().configureContext(&options);
+ auto glesVersion = reinterpret_cast<const char*>(glGetString(GL_VERSION));
+ auto size = glesVersion ? strlen(glesVersion) : -1;
+ cacheManager().configureContext(&options, glesVersion, size);
sk_sp<GrContext> grContext(GrContext::MakeGL(std::move(glInterface), options));
LOG_ALWAYS_FATAL_IF(!grContext.get());
setGrContext(grContext);
@@ -200,7 +202,7 @@
void RenderThread::destroyGlContext() {
if (mEglManager->hasEglContext()) {
setGrContext(nullptr);
- renderState().onContextDestroyed();
+ renderState().onGLContextDestroyed();
mEglManager->destroy();
}
}
diff --git a/libs/hwui/renderthread/VulkanManager.cpp b/libs/hwui/renderthread/VulkanManager.cpp
index 0c49dc0..cc4b87a 100644
--- a/libs/hwui/renderthread/VulkanManager.cpp
+++ b/libs/hwui/renderthread/VulkanManager.cpp
@@ -40,7 +40,7 @@
VulkanManager::VulkanManager(RenderThread& thread) : mRenderThread(thread) {}
void VulkanManager::destroy() {
- mRenderThread.renderState().onContextDestroyed();
+ mRenderThread.renderState().onVkContextDestroyed();
mRenderThread.setGrContext(nullptr);
if (VK_NULL_HANDLE != mCommandPool) {
@@ -391,7 +391,8 @@
GrContextOptions options;
options.fDisableDistanceFieldPaths = true;
- mRenderThread.cacheManager().configureContext(&options);
+ // TODO: get a string describing the SPIR-V compiler version and use it here
+ mRenderThread.cacheManager().configureContext(&options, nullptr, 0);
sk_sp<GrContext> grContext(GrContext::MakeVulkan(backendContext, options));
LOG_ALWAYS_FATAL_IF(!grContext.get());
mRenderThread.setGrContext(grContext);
@@ -404,7 +405,7 @@
mSwapBehavior = SwapBehavior::BufferAge;
}
- mRenderThread.renderState().onContextCreated();
+ mRenderThread.renderState().onVkContextCreated();
}
// Returns the next BackbufferInfo to use for the next draw. The function will make sure all
@@ -981,22 +982,6 @@
return surface->mCurrentTime - lastUsed;
}
-status_t VulkanManager::fenceWait(sp<Fence>& fence) {
- //TODO: Insert a wait on fence command into the Vulkan command buffer.
- // Block CPU on the fence.
- status_t err = fence->waitForever("VulkanManager::fenceWait");
- if (err != NO_ERROR) {
- ALOGE("VulkanManager::fenceWait: error waiting for fence: %d", err);
- return err;
- }
- return OK;
-}
-
-status_t VulkanManager::createReleaseFence(sp<Fence>& nativeFence) {
- //TODO: Create a fence that is signaled, when all the pending Vulkan commands are flushed.
- return OK;
-}
-
} /* namespace renderthread */
} /* namespace uirenderer */
} /* namespace android */
diff --git a/libs/hwui/renderthread/VulkanManager.h b/libs/hwui/renderthread/VulkanManager.h
index ebc11a5..5524c39 100644
--- a/libs/hwui/renderthread/VulkanManager.h
+++ b/libs/hwui/renderthread/VulkanManager.h
@@ -23,8 +23,6 @@
#include <vulkan/vulkan.h>
#include <SkSurface.h>
-#include <ui/Fence.h>
-#include <utils/StrongPointer.h>
#include <vk/GrVkBackendContext.h>
class GrVkExtensions;
@@ -112,12 +110,6 @@
// Presents the current VkImage.
void swapBuffers(VulkanSurface* surface);
- // Inserts a wait on fence command into the Vulkan command buffer.
- status_t fenceWait(sp<Fence>& fence);
-
- // Creates a fence that is signaled, when all the pending Vulkan commands are flushed.
- status_t createReleaseFence(sp<Fence>& nativeFence);
-
private:
friend class RenderThread;
diff --git a/libs/hwui/surfacetexture/EGLConsumer.cpp b/libs/hwui/surfacetexture/EGLConsumer.cpp
deleted file mode 100644
index c8220c6..0000000
--- a/libs/hwui/surfacetexture/EGLConsumer.cpp
+++ /dev/null
@@ -1,675 +0,0 @@
-/*
- * Copyright (C) 2018 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.
- */
-
-#include <inttypes.h>
-
-#include <EGL/egl.h>
-#include <EGL/eglext.h>
-#include <GLES2/gl2.h>
-#include <GLES2/gl2ext.h>
-#include <cutils/compiler.h>
-#include <gui/BufferItem.h>
-#include <gui/BufferQueue.h>
-#include <private/gui/SyncFeatures.h>
-#include "EGLConsumer.h"
-#include "SurfaceTexture.h"
-
-#include <utils/Log.h>
-#include <utils/String8.h>
-#include <utils/Trace.h>
-
-#define PROT_CONTENT_EXT_STR "EGL_EXT_protected_content"
-#define EGL_PROTECTED_CONTENT_EXT 0x32C0
-
-namespace android {
-
-// Macros for including the SurfaceTexture name in log messages
-#define EGC_LOGV(x, ...) ALOGV("[%s] " x, st.mName.string(), ##__VA_ARGS__)
-#define EGC_LOGD(x, ...) ALOGD("[%s] " x, st.mName.string(), ##__VA_ARGS__)
-#define EGC_LOGW(x, ...) ALOGW("[%s] " x, st.mName.string(), ##__VA_ARGS__)
-#define EGC_LOGE(x, ...) ALOGE("[%s] " x, st.mName.string(), ##__VA_ARGS__)
-
-static const struct {
- uint32_t width, height;
- char const* bits;
-} kDebugData = {15, 12,
- "_______________"
- "_______________"
- "_____XX_XX_____"
- "__X_X_____X_X__"
- "__X_XXXXXXX_X__"
- "__XXXXXXXXXXX__"
- "___XX_XXX_XX___"
- "____XXXXXXX____"
- "_____X___X_____"
- "____X_____X____"
- "_______________"
- "_______________"};
-
-Mutex EGLConsumer::sStaticInitLock;
-sp<GraphicBuffer> EGLConsumer::sReleasedTexImageBuffer;
-
-static bool hasEglProtectedContentImpl() {
- EGLDisplay dpy = eglGetDisplay(EGL_DEFAULT_DISPLAY);
- const char* exts = eglQueryString(dpy, EGL_EXTENSIONS);
- size_t cropExtLen = strlen(PROT_CONTENT_EXT_STR);
- size_t extsLen = strlen(exts);
- bool equal = !strcmp(PROT_CONTENT_EXT_STR, exts);
- bool atStart = !strncmp(PROT_CONTENT_EXT_STR " ", exts, cropExtLen + 1);
- bool atEnd = (cropExtLen + 1) < extsLen &&
- !strcmp(" " PROT_CONTENT_EXT_STR, exts + extsLen - (cropExtLen + 1));
- bool inMiddle = strstr(exts, " " PROT_CONTENT_EXT_STR " ");
- return equal || atStart || atEnd || inMiddle;
-}
-
-static bool hasEglProtectedContent() {
- // Only compute whether the extension is present once the first time this
- // function is called.
- static bool hasIt = hasEglProtectedContentImpl();
- return hasIt;
-}
-
-EGLConsumer::EGLConsumer() : mEglDisplay(EGL_NO_DISPLAY), mEglContext(EGL_NO_CONTEXT) {}
-
-status_t EGLConsumer::updateTexImage(SurfaceTexture& st) {
- // Make sure the EGL state is the same as in previous calls.
- status_t err = checkAndUpdateEglStateLocked(st);
- if (err != NO_ERROR) {
- return err;
- }
-
- BufferItem item;
-
- // Acquire the next buffer.
- // In asynchronous mode the list is guaranteed to be one buffer
- // deep, while in synchronous mode we use the oldest buffer.
- err = st.acquireBufferLocked(&item, 0);
- if (err != NO_ERROR) {
- if (err == BufferQueue::NO_BUFFER_AVAILABLE) {
- // We always bind the texture even if we don't update its contents.
- EGC_LOGV("updateTexImage: no buffers were available");
- glBindTexture(st.mTexTarget, st.mTexName);
- err = NO_ERROR;
- } else {
- EGC_LOGE("updateTexImage: acquire failed: %s (%d)", strerror(-err), err);
- }
- return err;
- }
-
- // Release the previous buffer.
- err = updateAndReleaseLocked(item, nullptr, st);
- if (err != NO_ERROR) {
- // We always bind the texture.
- glBindTexture(st.mTexTarget, st.mTexName);
- return err;
- }
-
- // Bind the new buffer to the GL texture, and wait until it's ready.
- return bindTextureImageLocked(st);
-}
-
-status_t EGLConsumer::releaseTexImage(SurfaceTexture& st) {
- // Make sure the EGL state is the same as in previous calls.
- status_t err = NO_ERROR;
-
- // if we're detached, no need to validate EGL's state -- we won't use it.
- if (st.mOpMode == SurfaceTexture::OpMode::attachedToGL) {
- err = checkAndUpdateEglStateLocked(st, true);
- if (err != NO_ERROR) {
- return err;
- }
- }
-
- // Update the EGLConsumer state.
- int buf = st.mCurrentTexture;
- if (buf != BufferQueue::INVALID_BUFFER_SLOT) {
- EGC_LOGV("releaseTexImage: (slot=%d, mOpMode=%d)", buf, (int)st.mOpMode);
-
- // if we're detached, we just use the fence that was created in detachFromContext()
- // so... basically, nothing more to do here.
- if (st.mOpMode == SurfaceTexture::OpMode::attachedToGL) {
- // Do whatever sync ops we need to do before releasing the slot.
- err = syncForReleaseLocked(mEglDisplay, st);
- if (err != NO_ERROR) {
- EGC_LOGE("syncForReleaseLocked failed (slot=%d), err=%d", buf, err);
- return err;
- }
- }
-
- err = st.releaseBufferLocked(buf, st.mSlots[buf].mGraphicBuffer, mEglDisplay,
- EGL_NO_SYNC_KHR);
- if (err < NO_ERROR) {
- EGC_LOGE("releaseTexImage: failed to release buffer: %s (%d)", strerror(-err), err);
- return err;
- }
-
- if (mReleasedTexImage == nullptr) {
- mReleasedTexImage = new EglImage(getDebugTexImageBuffer());
- }
-
- st.mCurrentTexture = BufferQueue::INVALID_BUFFER_SLOT;
- mCurrentTextureImage = mReleasedTexImage;
- st.mCurrentCrop.makeInvalid();
- st.mCurrentTransform = 0;
- st.mCurrentTimestamp = 0;
- st.mCurrentDataSpace = HAL_DATASPACE_UNKNOWN;
- st.mCurrentFence = Fence::NO_FENCE;
- st.mCurrentFenceTime = FenceTime::NO_FENCE;
-
- // detached, don't touch the texture (and we may not even have an
- // EGLDisplay here.
- if (st.mOpMode == SurfaceTexture::OpMode::attachedToGL) {
- // This binds a dummy buffer (mReleasedTexImage).
- status_t result = bindTextureImageLocked(st);
- if (result != NO_ERROR) {
- return result;
- }
- }
- }
-
- return NO_ERROR;
-}
-
-sp<GraphicBuffer> EGLConsumer::getDebugTexImageBuffer() {
- Mutex::Autolock _l(sStaticInitLock);
- if (CC_UNLIKELY(sReleasedTexImageBuffer == nullptr)) {
- // The first time, create the debug texture in case the application
- // continues to use it.
- sp<GraphicBuffer> buffer = new GraphicBuffer(
- kDebugData.width, kDebugData.height, PIXEL_FORMAT_RGBA_8888,
- GraphicBuffer::USAGE_SW_WRITE_RARELY, "[EGLConsumer debug texture]");
- uint32_t* bits;
- buffer->lock(GraphicBuffer::USAGE_SW_WRITE_RARELY, reinterpret_cast<void**>(&bits));
- uint32_t stride = buffer->getStride();
- uint32_t height = buffer->getHeight();
- memset(bits, 0, stride * height * 4);
- for (uint32_t y = 0; y < kDebugData.height; y++) {
- for (uint32_t x = 0; x < kDebugData.width; x++) {
- bits[x] = (kDebugData.bits[y + kDebugData.width + x] == 'X') ? 0xFF000000
- : 0xFFFFFFFF;
- }
- bits += stride;
- }
- buffer->unlock();
- sReleasedTexImageBuffer = buffer;
- }
- return sReleasedTexImageBuffer;
-}
-
-void EGLConsumer::onAcquireBufferLocked(BufferItem* item, SurfaceTexture& st) {
- // If item->mGraphicBuffer is not null, this buffer has not been acquired
- // before, so any prior EglImage created is using a stale buffer. This
- // replaces any old EglImage with a new one (using the new buffer).
- int slot = item->mSlot;
- if (item->mGraphicBuffer != nullptr || mEglSlots[slot].mEglImage.get() == nullptr) {
- mEglSlots[slot].mEglImage = new EglImage(st.mSlots[slot].mGraphicBuffer);
- }
-}
-
-void EGLConsumer::onReleaseBufferLocked(int buf) {
- mEglSlots[buf].mEglFence = EGL_NO_SYNC_KHR;
-}
-
-status_t EGLConsumer::updateAndReleaseLocked(const BufferItem& item, PendingRelease* pendingRelease,
- SurfaceTexture& st) {
- status_t err = NO_ERROR;
-
- int slot = item.mSlot;
-
- if (st.mOpMode != SurfaceTexture::OpMode::attachedToGL) {
- EGC_LOGE(
- "updateAndRelease: EGLConsumer is not attached to an OpenGL "
- "ES context");
- st.releaseBufferLocked(slot, st.mSlots[slot].mGraphicBuffer, mEglDisplay, EGL_NO_SYNC_KHR);
- return INVALID_OPERATION;
- }
-
- // Confirm state.
- err = checkAndUpdateEglStateLocked(st);
- if (err != NO_ERROR) {
- st.releaseBufferLocked(slot, st.mSlots[slot].mGraphicBuffer, mEglDisplay, EGL_NO_SYNC_KHR);
- return err;
- }
-
- // Ensure we have a valid EglImageKHR for the slot, creating an EglImage
- // if nessessary, for the gralloc buffer currently in the slot in
- // ConsumerBase.
- // We may have to do this even when item.mGraphicBuffer == NULL (which
- // means the buffer was previously acquired).
- err = mEglSlots[slot].mEglImage->createIfNeeded(mEglDisplay);
- if (err != NO_ERROR) {
- EGC_LOGW("updateAndRelease: unable to createImage on display=%p slot=%d", mEglDisplay,
- slot);
- st.releaseBufferLocked(slot, st.mSlots[slot].mGraphicBuffer, mEglDisplay, EGL_NO_SYNC_KHR);
- return UNKNOWN_ERROR;
- }
-
- // Do whatever sync ops we need to do before releasing the old slot.
- if (slot != st.mCurrentTexture) {
- err = syncForReleaseLocked(mEglDisplay, st);
- if (err != NO_ERROR) {
- // Release the buffer we just acquired. It's not safe to
- // release the old buffer, so instead we just drop the new frame.
- // As we are still under lock since acquireBuffer, it is safe to
- // release by slot.
- st.releaseBufferLocked(slot, st.mSlots[slot].mGraphicBuffer, mEglDisplay,
- EGL_NO_SYNC_KHR);
- return err;
- }
- }
-
- EGC_LOGV(
- "updateAndRelease: (slot=%d buf=%p) -> (slot=%d buf=%p)", st.mCurrentTexture,
- mCurrentTextureImage != nullptr ? mCurrentTextureImage->graphicBufferHandle() : nullptr,
- slot, st.mSlots[slot].mGraphicBuffer->handle);
-
- // Hang onto the pointer so that it isn't freed in the call to
- // releaseBufferLocked() if we're in shared buffer mode and both buffers are
- // the same.
- sp<EglImage> nextTextureImage = mEglSlots[slot].mEglImage;
-
- // release old buffer
- if (st.mCurrentTexture != BufferQueue::INVALID_BUFFER_SLOT) {
- if (pendingRelease == nullptr) {
- status_t status = st.releaseBufferLocked(
- st.mCurrentTexture, mCurrentTextureImage->graphicBuffer(), mEglDisplay,
- mEglSlots[st.mCurrentTexture].mEglFence);
- if (status < NO_ERROR) {
- EGC_LOGE("updateAndRelease: failed to release buffer: %s (%d)", strerror(-status),
- status);
- err = status;
- // keep going, with error raised [?]
- }
- } else {
- pendingRelease->currentTexture = st.mCurrentTexture;
- pendingRelease->graphicBuffer = mCurrentTextureImage->graphicBuffer();
- pendingRelease->display = mEglDisplay;
- pendingRelease->fence = mEglSlots[st.mCurrentTexture].mEglFence;
- pendingRelease->isPending = true;
- }
- }
-
- // Update the EGLConsumer state.
- st.mCurrentTexture = slot;
- mCurrentTextureImage = nextTextureImage;
- st.mCurrentCrop = item.mCrop;
- st.mCurrentTransform = item.mTransform;
- st.mCurrentScalingMode = item.mScalingMode;
- st.mCurrentTimestamp = item.mTimestamp;
- st.mCurrentDataSpace = item.mDataSpace;
- st.mCurrentFence = item.mFence;
- st.mCurrentFenceTime = item.mFenceTime;
- st.mCurrentFrameNumber = item.mFrameNumber;
-
- st.computeCurrentTransformMatrixLocked();
-
- return err;
-}
-
-status_t EGLConsumer::bindTextureImageLocked(SurfaceTexture& st) {
- if (mEglDisplay == EGL_NO_DISPLAY) {
- ALOGE("bindTextureImage: invalid display");
- return INVALID_OPERATION;
- }
-
- GLenum error;
- while ((error = glGetError()) != GL_NO_ERROR) {
- EGC_LOGW("bindTextureImage: clearing GL error: %#04x", error);
- }
-
- glBindTexture(st.mTexTarget, st.mTexName);
- if (st.mCurrentTexture == BufferQueue::INVALID_BUFFER_SLOT && mCurrentTextureImage == nullptr) {
- EGC_LOGE("bindTextureImage: no currently-bound texture");
- return NO_INIT;
- }
-
- status_t err = mCurrentTextureImage->createIfNeeded(mEglDisplay);
- if (err != NO_ERROR) {
- EGC_LOGW("bindTextureImage: can't create image on display=%p slot=%d", mEglDisplay,
- st.mCurrentTexture);
- return UNKNOWN_ERROR;
- }
- mCurrentTextureImage->bindToTextureTarget(st.mTexTarget);
-
- // In the rare case that the display is terminated and then initialized
- // again, we can't detect that the display changed (it didn't), but the
- // image is invalid. In this case, repeat the exact same steps while
- // forcing the creation of a new image.
- if ((error = glGetError()) != GL_NO_ERROR) {
- glBindTexture(st.mTexTarget, st.mTexName);
- status_t result = mCurrentTextureImage->createIfNeeded(mEglDisplay, true);
- if (result != NO_ERROR) {
- EGC_LOGW("bindTextureImage: can't create image on display=%p slot=%d", mEglDisplay,
- st.mCurrentTexture);
- return UNKNOWN_ERROR;
- }
- mCurrentTextureImage->bindToTextureTarget(st.mTexTarget);
- if ((error = glGetError()) != GL_NO_ERROR) {
- EGC_LOGE("bindTextureImage: error binding external image: %#04x", error);
- return UNKNOWN_ERROR;
- }
- }
-
- // Wait for the new buffer to be ready.
- return doGLFenceWaitLocked(st);
-}
-
-status_t EGLConsumer::checkAndUpdateEglStateLocked(SurfaceTexture& st, bool contextCheck) {
- EGLDisplay dpy = eglGetCurrentDisplay();
- EGLContext ctx = eglGetCurrentContext();
-
- if (!contextCheck) {
- // if this is the first time we're called, mEglDisplay/mEglContext have
- // never been set, so don't error out (below).
- if (mEglDisplay == EGL_NO_DISPLAY) {
- mEglDisplay = dpy;
- }
- if (mEglContext == EGL_NO_CONTEXT) {
- mEglContext = ctx;
- }
- }
-
- if (mEglDisplay != dpy || dpy == EGL_NO_DISPLAY) {
- EGC_LOGE("checkAndUpdateEglState: invalid current EGLDisplay");
- return INVALID_OPERATION;
- }
-
- if (mEglContext != ctx || ctx == EGL_NO_CONTEXT) {
- EGC_LOGE("checkAndUpdateEglState: invalid current EGLContext");
- return INVALID_OPERATION;
- }
-
- mEglDisplay = dpy;
- mEglContext = ctx;
- return NO_ERROR;
-}
-
-status_t EGLConsumer::detachFromContext(SurfaceTexture& st) {
- EGLDisplay dpy = eglGetCurrentDisplay();
- EGLContext ctx = eglGetCurrentContext();
-
- if (mEglDisplay != dpy && mEglDisplay != EGL_NO_DISPLAY) {
- EGC_LOGE("detachFromContext: invalid current EGLDisplay");
- return INVALID_OPERATION;
- }
-
- if (mEglContext != ctx && mEglContext != EGL_NO_CONTEXT) {
- EGC_LOGE("detachFromContext: invalid current EGLContext");
- return INVALID_OPERATION;
- }
-
- if (dpy != EGL_NO_DISPLAY && ctx != EGL_NO_CONTEXT) {
- status_t err = syncForReleaseLocked(dpy, st);
- if (err != OK) {
- return err;
- }
-
- glDeleteTextures(1, &st.mTexName);
- }
-
- mEglDisplay = EGL_NO_DISPLAY;
- mEglContext = EGL_NO_CONTEXT;
-
- return OK;
-}
-
-status_t EGLConsumer::attachToContext(uint32_t tex, SurfaceTexture& st) {
- // Initialize mCurrentTextureImage if there is a current buffer from past attached state.
- int slot = st.mCurrentTexture;
- if (slot != BufferItem::INVALID_BUFFER_SLOT) {
- if (!mEglSlots[slot].mEglImage.get()) {
- mEglSlots[slot].mEglImage = new EglImage(st.mSlots[slot].mGraphicBuffer);
- }
- mCurrentTextureImage = mEglSlots[slot].mEglImage;
- }
-
- EGLDisplay dpy = eglGetCurrentDisplay();
- EGLContext ctx = eglGetCurrentContext();
-
- if (dpy == EGL_NO_DISPLAY) {
- EGC_LOGE("attachToContext: invalid current EGLDisplay");
- return INVALID_OPERATION;
- }
-
- if (ctx == EGL_NO_CONTEXT) {
- EGC_LOGE("attachToContext: invalid current EGLContext");
- return INVALID_OPERATION;
- }
-
- // We need to bind the texture regardless of whether there's a current
- // buffer.
- glBindTexture(st.mTexTarget, GLuint(tex));
-
- mEglDisplay = dpy;
- mEglContext = ctx;
- st.mTexName = tex;
- st.mOpMode = SurfaceTexture::OpMode::attachedToGL;
-
- if (mCurrentTextureImage != nullptr) {
- // This may wait for a buffer a second time. This is likely required if
- // this is a different context, since otherwise the wait could be skipped
- // by bouncing through another context. For the same context the extra
- // wait is redundant.
- status_t err = bindTextureImageLocked(st);
- if (err != NO_ERROR) {
- return err;
- }
- }
-
- return OK;
-}
-
-status_t EGLConsumer::syncForReleaseLocked(EGLDisplay dpy, SurfaceTexture& st) {
- EGC_LOGV("syncForReleaseLocked");
-
- if (st.mCurrentTexture != BufferQueue::INVALID_BUFFER_SLOT) {
- if (SyncFeatures::getInstance().useNativeFenceSync()) {
- EGLSyncKHR sync = eglCreateSyncKHR(dpy, EGL_SYNC_NATIVE_FENCE_ANDROID, nullptr);
- if (sync == EGL_NO_SYNC_KHR) {
- EGC_LOGE("syncForReleaseLocked: error creating EGL fence: %#x", eglGetError());
- return UNKNOWN_ERROR;
- }
- glFlush();
- int fenceFd = eglDupNativeFenceFDANDROID(dpy, sync);
- eglDestroySyncKHR(dpy, sync);
- if (fenceFd == EGL_NO_NATIVE_FENCE_FD_ANDROID) {
- EGC_LOGE(
- "syncForReleaseLocked: error dup'ing native fence "
- "fd: %#x",
- eglGetError());
- return UNKNOWN_ERROR;
- }
- sp<Fence> fence(new Fence(fenceFd));
- status_t err = st.addReleaseFenceLocked(st.mCurrentTexture,
- mCurrentTextureImage->graphicBuffer(), fence);
- if (err != OK) {
- EGC_LOGE(
- "syncForReleaseLocked: error adding release fence: "
- "%s (%d)",
- strerror(-err), err);
- return err;
- }
- } else if (st.mUseFenceSync && SyncFeatures::getInstance().useFenceSync()) {
- EGLSyncKHR fence = mEglSlots[st.mCurrentTexture].mEglFence;
- if (fence != EGL_NO_SYNC_KHR) {
- // There is already a fence for the current slot. We need to
- // wait on that before replacing it with another fence to
- // ensure that all outstanding buffer accesses have completed
- // before the producer accesses it.
- EGLint result = eglClientWaitSyncKHR(dpy, fence, 0, 1000000000);
- if (result == EGL_FALSE) {
- EGC_LOGE(
- "syncForReleaseLocked: error waiting for previous "
- "fence: %#x",
- eglGetError());
- return UNKNOWN_ERROR;
- } else if (result == EGL_TIMEOUT_EXPIRED_KHR) {
- EGC_LOGE(
- "syncForReleaseLocked: timeout waiting for previous "
- "fence");
- return TIMED_OUT;
- }
- eglDestroySyncKHR(dpy, fence);
- }
-
- // Create a fence for the outstanding accesses in the current
- // OpenGL ES context.
- fence = eglCreateSyncKHR(dpy, EGL_SYNC_FENCE_KHR, nullptr);
- if (fence == EGL_NO_SYNC_KHR) {
- EGC_LOGE("syncForReleaseLocked: error creating fence: %#x", eglGetError());
- return UNKNOWN_ERROR;
- }
- glFlush();
- mEglSlots[st.mCurrentTexture].mEglFence = fence;
- }
- }
-
- return OK;
-}
-
-status_t EGLConsumer::doGLFenceWaitLocked(SurfaceTexture& st) const {
- EGLDisplay dpy = eglGetCurrentDisplay();
- EGLContext ctx = eglGetCurrentContext();
-
- if (mEglDisplay != dpy || mEglDisplay == EGL_NO_DISPLAY) {
- EGC_LOGE("doGLFenceWait: invalid current EGLDisplay");
- return INVALID_OPERATION;
- }
-
- if (mEglContext != ctx || mEglContext == EGL_NO_CONTEXT) {
- EGC_LOGE("doGLFenceWait: invalid current EGLContext");
- return INVALID_OPERATION;
- }
-
- if (st.mCurrentFence->isValid()) {
- if (SyncFeatures::getInstance().useWaitSync() &&
- SyncFeatures::getInstance().useNativeFenceSync()) {
- // Create an EGLSyncKHR from the current fence.
- int fenceFd = st.mCurrentFence->dup();
- if (fenceFd == -1) {
- EGC_LOGE("doGLFenceWait: error dup'ing fence fd: %d", errno);
- return -errno;
- }
- EGLint attribs[] = {EGL_SYNC_NATIVE_FENCE_FD_ANDROID, fenceFd, EGL_NONE};
- EGLSyncKHR sync = eglCreateSyncKHR(dpy, EGL_SYNC_NATIVE_FENCE_ANDROID, attribs);
- if (sync == EGL_NO_SYNC_KHR) {
- close(fenceFd);
- EGC_LOGE("doGLFenceWait: error creating EGL fence: %#x", eglGetError());
- return UNKNOWN_ERROR;
- }
-
- // XXX: The spec draft is inconsistent as to whether this should
- // return an EGLint or void. Ignore the return value for now, as
- // it's not strictly needed.
- eglWaitSyncKHR(dpy, sync, 0);
- EGLint eglErr = eglGetError();
- eglDestroySyncKHR(dpy, sync);
- if (eglErr != EGL_SUCCESS) {
- EGC_LOGE("doGLFenceWait: error waiting for EGL fence: %#x", eglErr);
- return UNKNOWN_ERROR;
- }
- } else {
- status_t err = st.mCurrentFence->waitForever("EGLConsumer::doGLFenceWaitLocked");
- if (err != NO_ERROR) {
- EGC_LOGE("doGLFenceWait: error waiting for fence: %d", err);
- return err;
- }
- }
- }
-
- return NO_ERROR;
-}
-
-void EGLConsumer::onFreeBufferLocked(int slotIndex) {
- mEglSlots[slotIndex].mEglImage.clear();
-}
-
-void EGLConsumer::onAbandonLocked() {
- mCurrentTextureImage.clear();
-}
-
-EGLConsumer::EglImage::EglImage(sp<GraphicBuffer> graphicBuffer)
- : mGraphicBuffer(graphicBuffer), mEglImage(EGL_NO_IMAGE_KHR), mEglDisplay(EGL_NO_DISPLAY) {}
-
-EGLConsumer::EglImage::~EglImage() {
- if (mEglImage != EGL_NO_IMAGE_KHR) {
- if (!eglDestroyImageKHR(mEglDisplay, mEglImage)) {
- ALOGE("~EglImage: eglDestroyImageKHR failed");
- }
- eglTerminate(mEglDisplay);
- }
-}
-
-status_t EGLConsumer::EglImage::createIfNeeded(EGLDisplay eglDisplay, bool forceCreation) {
- // If there's an image and it's no longer valid, destroy it.
- bool haveImage = mEglImage != EGL_NO_IMAGE_KHR;
- bool displayInvalid = mEglDisplay != eglDisplay;
- if (haveImage && (displayInvalid || forceCreation)) {
- if (!eglDestroyImageKHR(mEglDisplay, mEglImage)) {
- ALOGE("createIfNeeded: eglDestroyImageKHR failed");
- }
- eglTerminate(mEglDisplay);
- mEglImage = EGL_NO_IMAGE_KHR;
- mEglDisplay = EGL_NO_DISPLAY;
- }
-
- // If there's no image, create one.
- if (mEglImage == EGL_NO_IMAGE_KHR) {
- mEglDisplay = eglDisplay;
- mEglImage = createImage(mEglDisplay, mGraphicBuffer);
- }
-
- // Fail if we can't create a valid image.
- if (mEglImage == EGL_NO_IMAGE_KHR) {
- mEglDisplay = EGL_NO_DISPLAY;
- const sp<GraphicBuffer>& buffer = mGraphicBuffer;
- ALOGE("Failed to create image. size=%ux%u st=%u usage=%#" PRIx64 " fmt=%d",
- buffer->getWidth(), buffer->getHeight(), buffer->getStride(), buffer->getUsage(),
- buffer->getPixelFormat());
- return UNKNOWN_ERROR;
- }
-
- return OK;
-}
-
-void EGLConsumer::EglImage::bindToTextureTarget(uint32_t texTarget) {
- glEGLImageTargetTexture2DOES(texTarget, static_cast<GLeglImageOES>(mEglImage));
-}
-
-EGLImageKHR EGLConsumer::EglImage::createImage(EGLDisplay dpy,
- const sp<GraphicBuffer>& graphicBuffer) {
- EGLClientBuffer cbuf = static_cast<EGLClientBuffer>(graphicBuffer->getNativeBuffer());
- const bool createProtectedImage =
- (graphicBuffer->getUsage() & GRALLOC_USAGE_PROTECTED) && hasEglProtectedContent();
- EGLint attrs[] = {
- EGL_IMAGE_PRESERVED_KHR,
- EGL_TRUE,
- createProtectedImage ? EGL_PROTECTED_CONTENT_EXT : EGL_NONE,
- createProtectedImage ? EGL_TRUE : EGL_NONE,
- EGL_NONE,
- };
- eglInitialize(dpy, nullptr, nullptr);
- EGLImageKHR image =
- eglCreateImageKHR(dpy, EGL_NO_CONTEXT, EGL_NATIVE_BUFFER_ANDROID, cbuf, attrs);
- if (image == EGL_NO_IMAGE_KHR) {
- EGLint error = eglGetError();
- ALOGE("error creating EGLImage: %#x", error);
- eglTerminate(dpy);
- }
- return image;
-}
-
-}; // namespace android
diff --git a/libs/hwui/surfacetexture/EGLConsumer.h b/libs/hwui/surfacetexture/EGLConsumer.h
deleted file mode 100644
index eccb082..0000000
--- a/libs/hwui/surfacetexture/EGLConsumer.h
+++ /dev/null
@@ -1,311 +0,0 @@
-/*
- * Copyright (C) 2018 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.
- */
-
-#pragma once
-
-#include <EGL/egl.h>
-#include <EGL/eglext.h>
-
-#include <gui/BufferQueueDefs.h>
-
-#include <ui/FenceTime.h>
-#include <ui/GraphicBuffer.h>
-#include <utils/Mutex.h>
-
-namespace android {
-
-class SurfaceTexture;
-
-/*
- * EGLConsumer implements the parts of SurfaceTexture that deal with
- * textures attached to an GL context.
- */
-class EGLConsumer {
-public:
- EGLConsumer();
-
- /**
- * updateTexImage acquires the most recently queued buffer, and sets the
- * image contents of the target texture to it.
- *
- * This call may only be made while the OpenGL ES context to which the
- * target texture belongs is bound to the calling thread.
- *
- * This calls doGLFenceWait to ensure proper synchronization.
- */
- status_t updateTexImage(SurfaceTexture& st);
-
- /*
- * releaseTexImage releases the texture acquired in updateTexImage().
- * This is intended to be used in single buffer mode.
- *
- * This call may only be made while the OpenGL ES context to which the
- * target texture belongs is bound to the calling thread.
- */
- status_t releaseTexImage(SurfaceTexture& st);
-
- /**
- * detachFromContext detaches the EGLConsumer from the calling thread's
- * current OpenGL ES context. This context must be the same as the context
- * that was current for previous calls to updateTexImage.
- *
- * Detaching a EGLConsumer from an OpenGL ES context will result in the
- * deletion of the OpenGL ES texture object into which the images were being
- * streamed. After a EGLConsumer has been detached from the OpenGL ES
- * context calls to updateTexImage will fail returning INVALID_OPERATION
- * until the EGLConsumer is attached to a new OpenGL ES context using the
- * attachToContext method.
- */
- status_t detachFromContext(SurfaceTexture& st);
-
- /**
- * attachToContext attaches a EGLConsumer that is currently in the
- * 'detached' state to the current OpenGL ES context. A EGLConsumer is
- * in the 'detached' state iff detachFromContext has successfully been
- * called and no calls to attachToContext have succeeded since the last
- * detachFromContext call. Calls to attachToContext made on a
- * EGLConsumer that is not in the 'detached' state will result in an
- * INVALID_OPERATION error.
- *
- * The tex argument specifies the OpenGL ES texture object name in the
- * new context into which the image contents will be streamed. A successful
- * call to attachToContext will result in this texture object being bound to
- * the texture target and populated with the image contents that were
- * current at the time of the last call to detachFromContext.
- */
- status_t attachToContext(uint32_t tex, SurfaceTexture& st);
-
- /**
- * onAcquireBufferLocked amends the ConsumerBase method to update the
- * mEglSlots array in addition to the ConsumerBase behavior.
- */
- void onAcquireBufferLocked(BufferItem* item, SurfaceTexture& st);
-
- /**
- * onReleaseBufferLocked amends the ConsumerBase method to update the
- * mEglSlots array in addition to the ConsumerBase.
- */
- void onReleaseBufferLocked(int slot);
-
- /**
- * onFreeBufferLocked frees up the given buffer slot. If the slot has been
- * initialized this will release the reference to the GraphicBuffer in that
- * slot and destroy the EGLImage in that slot. Otherwise it has no effect.
- */
- void onFreeBufferLocked(int slotIndex);
-
- /**
- * onAbandonLocked amends the ConsumerBase method to clear
- * mCurrentTextureImage in addition to the ConsumerBase behavior.
- */
- void onAbandonLocked();
-
-protected:
- struct PendingRelease {
- PendingRelease()
- : isPending(false)
- , currentTexture(-1)
- , graphicBuffer()
- , display(nullptr)
- , fence(nullptr) {}
-
- bool isPending;
- int currentTexture;
- sp<GraphicBuffer> graphicBuffer;
- EGLDisplay display;
- EGLSyncKHR fence;
- };
-
- /**
- * This releases the buffer in the slot referenced by mCurrentTexture,
- * then updates state to refer to the BufferItem, which must be a
- * newly-acquired buffer. If pendingRelease is not null, the parameters
- * which would have been passed to releaseBufferLocked upon the successful
- * completion of the method will instead be returned to the caller, so that
- * it may call releaseBufferLocked itself later.
- */
- status_t updateAndReleaseLocked(const BufferItem& item, PendingRelease* pendingRelease,
- SurfaceTexture& st);
-
- /**
- * Binds mTexName and the current buffer to mTexTarget. Uses
- * mCurrentTexture if it's set, mCurrentTextureImage if not. If the
- * bind succeeds, this calls doGLFenceWait.
- */
- status_t bindTextureImageLocked(SurfaceTexture& st);
-
- /**
- * Gets the current EGLDisplay and EGLContext values, and compares them
- * to mEglDisplay and mEglContext. If the fields have been previously
- * set, the values must match; if not, the fields are set to the current
- * values.
- * The contextCheck argument is used to ensure that a GL context is
- * properly set; when set to false, the check is not performed.
- */
- status_t checkAndUpdateEglStateLocked(SurfaceTexture& st, bool contextCheck = false);
-
- /**
- * EglImage is a utility class for tracking and creating EGLImageKHRs. There
- * is primarily just one image per slot, but there is also special cases:
- * - For releaseTexImage, we use a debug image (mReleasedTexImage)
- * - After freeBuffer, we must still keep the current image/buffer
- * Reference counting EGLImages lets us handle all these cases easily while
- * also only creating new EGLImages from buffers when required.
- */
- class EglImage : public LightRefBase<EglImage> {
- public:
- EglImage(sp<GraphicBuffer> graphicBuffer);
-
- /**
- * createIfNeeded creates an EGLImage if required (we haven't created
- * one yet, or the EGLDisplay or crop-rect has changed).
- */
- status_t createIfNeeded(EGLDisplay display, bool forceCreate = false);
-
- /**
- * This calls glEGLImageTargetTexture2DOES to bind the image to the
- * texture in the specified texture target.
- */
- void bindToTextureTarget(uint32_t texTarget);
-
- const sp<GraphicBuffer>& graphicBuffer() { return mGraphicBuffer; }
- const native_handle* graphicBufferHandle() {
- return mGraphicBuffer == nullptr ? nullptr : mGraphicBuffer->handle;
- }
-
- private:
- // Only allow instantiation using ref counting.
- friend class LightRefBase<EglImage>;
- virtual ~EglImage();
-
- // createImage creates a new EGLImage from a GraphicBuffer.
- EGLImageKHR createImage(EGLDisplay dpy, const sp<GraphicBuffer>& graphicBuffer);
-
- // Disallow copying
- EglImage(const EglImage& rhs);
- void operator=(const EglImage& rhs);
-
- // mGraphicBuffer is the buffer that was used to create this image.
- sp<GraphicBuffer> mGraphicBuffer;
-
- // mEglImage is the EGLImage created from mGraphicBuffer.
- EGLImageKHR mEglImage;
-
- // mEGLDisplay is the EGLDisplay that was used to create mEglImage.
- EGLDisplay mEglDisplay;
-
- // mCropRect is the crop rectangle passed to EGL when mEglImage
- // was created.
- Rect mCropRect;
- };
-
- /**
- * doGLFenceWaitLocked inserts a wait command into the OpenGL ES command
- * stream to ensure that it is safe for future OpenGL ES commands to
- * access the current texture buffer.
- */
- status_t doGLFenceWaitLocked(SurfaceTexture& st) const;
-
- /**
- * syncForReleaseLocked performs the synchronization needed to release the
- * current slot from an OpenGL ES context. If needed it will set the
- * current slot's fence to guard against a producer accessing the buffer
- * before the outstanding accesses have completed.
- */
- status_t syncForReleaseLocked(EGLDisplay dpy, SurfaceTexture& st);
-
- /**
- * returns a graphic buffer used when the texture image has been released
- */
- static sp<GraphicBuffer> getDebugTexImageBuffer();
-
- /**
- * The default consumer usage flags that EGLConsumer always sets on its
- * BufferQueue instance; these will be OR:d with any additional flags passed
- * from the EGLConsumer user. In particular, EGLConsumer will always
- * consume buffers as hardware textures.
- */
- static const uint64_t DEFAULT_USAGE_FLAGS = GraphicBuffer::USAGE_HW_TEXTURE;
-
- /**
- * mCurrentTextureImage is the EglImage/buffer of the current texture. It's
- * possible that this buffer is not associated with any buffer slot, so we
- * must track it separately in order to support the getCurrentBuffer method.
- */
- sp<EglImage> mCurrentTextureImage;
-
- /**
- * EGLSlot contains the information and object references that
- * EGLConsumer maintains about a BufferQueue buffer slot.
- */
- struct EglSlot {
- EglSlot() : mEglFence(EGL_NO_SYNC_KHR) {}
-
- /**
- * mEglImage is the EGLImage created from mGraphicBuffer.
- */
- sp<EglImage> mEglImage;
-
- /**
- * mFence is the EGL sync object that must signal before the buffer
- * associated with this buffer slot may be dequeued. It is initialized
- * to EGL_NO_SYNC_KHR when the buffer is created and (optionally, based
- * on a compile-time option) set to a new sync object in updateTexImage.
- */
- EGLSyncKHR mEglFence;
- };
-
- /**
- * mEglDisplay is the EGLDisplay with which this EGLConsumer is currently
- * associated. It is intialized to EGL_NO_DISPLAY and gets set to the
- * current display when updateTexImage is called for the first time and when
- * attachToContext is called.
- */
- EGLDisplay mEglDisplay;
-
- /**
- * mEglContext is the OpenGL ES context with which this EGLConsumer is
- * currently associated. It is initialized to EGL_NO_CONTEXT and gets set
- * to the current GL context when updateTexImage is called for the first
- * time and when attachToContext is called.
- */
- EGLContext mEglContext;
-
- /**
- * mEGLSlots stores the buffers that have been allocated by the BufferQueue
- * for each buffer slot. It is initialized to null pointers, and gets
- * filled in with the result of BufferQueue::acquire when the
- * client dequeues a buffer from a
- * slot that has not yet been used. The buffer allocated to a slot will also
- * be replaced if the requested buffer usage or geometry differs from that
- * of the buffer allocated to a slot.
- */
- EglSlot mEglSlots[BufferQueueDefs::NUM_BUFFER_SLOTS];
-
- /**
- * protects static initialization
- */
- static Mutex sStaticInitLock;
-
- /**
- * mReleasedTexImageBuffer is a dummy buffer used when in single buffer
- * mode and releaseTexImage() has been called
- */
- static sp<GraphicBuffer> sReleasedTexImageBuffer;
- sp<EglImage> mReleasedTexImage;
-};
-
-}; // namespace android
diff --git a/libs/hwui/surfacetexture/ImageConsumer.cpp b/libs/hwui/surfacetexture/ImageConsumer.cpp
deleted file mode 100644
index c86cd96..0000000
--- a/libs/hwui/surfacetexture/ImageConsumer.cpp
+++ /dev/null
@@ -1,152 +0,0 @@
-/*
- * Copyright (C) 2018 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.
- */
-
-#include "ImageConsumer.h"
-#include <gui/BufferQueue.h>
-#include "Properties.h"
-#include "SurfaceTexture.h"
-#include "renderstate/RenderState.h"
-#include "renderthread/EglManager.h"
-#include "renderthread/RenderThread.h"
-#include "renderthread/VulkanManager.h"
-
-// Macro for including the SurfaceTexture name in log messages
-#define IMG_LOGE(x, ...) ALOGE("[%s] " x, st.mName.string(), ##__VA_ARGS__)
-
-namespace android {
-
-void ImageConsumer::onFreeBufferLocked(int slotIndex) {
- mImageSlots[slotIndex].mImage.reset();
-}
-
-void ImageConsumer::onAcquireBufferLocked(BufferItem* item) {
- // If item->mGraphicBuffer is not null, this buffer has not been acquired
- // before, so any prior SkImage is created with a stale buffer. This resets the stale SkImage.
- if (item->mGraphicBuffer != nullptr) {
- mImageSlots[item->mSlot].mImage.reset();
- }
-}
-
-void ImageConsumer::onReleaseBufferLocked(int buf) {
- mImageSlots[buf].mEglFence = EGL_NO_SYNC_KHR;
-}
-
-void ImageConsumer::ImageSlot::createIfNeeded(sp<GraphicBuffer> graphicBuffer) {
- if (!mImage.get()) {
- mImage = graphicBuffer.get()
- ? SkImage::MakeFromAHardwareBuffer(
- reinterpret_cast<AHardwareBuffer*>(graphicBuffer.get()),
- kPremul_SkAlphaType, SkColorSpace::MakeSRGB())
- : nullptr;
- }
-}
-
-sk_sp<SkImage> ImageConsumer::dequeueImage(bool* queueEmpty, SurfaceTexture& st,
- uirenderer::RenderState& renderState) {
- BufferItem item;
- status_t err;
- err = st.acquireBufferLocked(&item, 0);
- if (err != OK) {
- if (err != BufferQueue::NO_BUFFER_AVAILABLE) {
- IMG_LOGE("Error acquiring buffer: %s (%d)", strerror(err), err);
- } else {
- int slot = st.mCurrentTexture;
- if (slot != BufferItem::INVALID_BUFFER_SLOT) {
- *queueEmpty = true;
- mImageSlots[slot].createIfNeeded(st.mSlots[slot].mGraphicBuffer);
- return mImageSlots[slot].mImage;
- }
- }
- return nullptr;
- }
-
- int slot = item.mSlot;
- if (item.mFence->isValid()) {
- // Wait on the producer fence for the buffer to be ready.
- if (uirenderer::Properties::getRenderPipelineType() ==
- uirenderer::RenderPipelineType::SkiaGL) {
- err = renderState.getRenderThread().eglManager().fenceWait(item.mFence);
- } else {
- err = renderState.getRenderThread().vulkanManager().fenceWait(item.mFence);
- }
- if (err != OK) {
- st.releaseBufferLocked(slot, st.mSlots[slot].mGraphicBuffer, EGL_NO_DISPLAY,
- EGL_NO_SYNC_KHR);
- return nullptr;
- }
- }
-
- // Release old buffer.
- if (st.mCurrentTexture != BufferItem::INVALID_BUFFER_SLOT) {
- // If needed, set the released slot's fence to guard against a producer accessing the
- // buffer before the outstanding accesses have completed.
- sp<Fence> releaseFence;
- EGLDisplay display = EGL_NO_DISPLAY;
- if (uirenderer::Properties::getRenderPipelineType() ==
- uirenderer::RenderPipelineType::SkiaGL) {
- auto& eglManager = renderState.getRenderThread().eglManager();
- display = eglManager.eglDisplay();
- err = eglManager.createReleaseFence(st.mUseFenceSync, &mImageSlots[slot].mEglFence,
- releaseFence);
- } else {
- err = renderState.getRenderThread().vulkanManager().createReleaseFence(releaseFence);
- }
- if (OK != err) {
- st.releaseBufferLocked(slot, st.mSlots[slot].mGraphicBuffer, EGL_NO_DISPLAY,
- EGL_NO_SYNC_KHR);
- return nullptr;
- }
-
- if (releaseFence.get()) {
- status_t err = st.addReleaseFenceLocked(
- st.mCurrentTexture, st.mSlots[st.mCurrentTexture].mGraphicBuffer, releaseFence);
- if (err != OK) {
- IMG_LOGE("dequeueImage: error adding release fence: %s (%d)", strerror(-err), err);
- st.releaseBufferLocked(slot, st.mSlots[slot].mGraphicBuffer, EGL_NO_DISPLAY,
- EGL_NO_SYNC_KHR);
- return nullptr;
- }
- }
-
- // Finally release the old buffer.
- status_t status = st.releaseBufferLocked(
- st.mCurrentTexture, st.mSlots[st.mCurrentTexture].mGraphicBuffer, display,
- mImageSlots[st.mCurrentTexture].mEglFence);
- if (status < NO_ERROR) {
- IMG_LOGE("dequeueImage: failed to release buffer: %s (%d)", strerror(-status), status);
- err = status;
- // Keep going, with error raised.
- }
- }
-
- // Update the state.
- st.mCurrentTexture = slot;
- st.mCurrentCrop = item.mCrop;
- st.mCurrentTransform = item.mTransform;
- st.mCurrentScalingMode = item.mScalingMode;
- st.mCurrentTimestamp = item.mTimestamp;
- st.mCurrentDataSpace = item.mDataSpace;
- st.mCurrentFence = item.mFence;
- st.mCurrentFenceTime = item.mFenceTime;
- st.mCurrentFrameNumber = item.mFrameNumber;
- st.computeCurrentTransformMatrixLocked();
-
- *queueEmpty = false;
- mImageSlots[slot].createIfNeeded(st.mSlots[slot].mGraphicBuffer);
- return mImageSlots[slot].mImage;
-}
-
-} /* namespace android */
diff --git a/libs/hwui/surfacetexture/ImageConsumer.h b/libs/hwui/surfacetexture/ImageConsumer.h
deleted file mode 100644
index 31ee8db..0000000
--- a/libs/hwui/surfacetexture/ImageConsumer.h
+++ /dev/null
@@ -1,97 +0,0 @@
-/*
- * Copyright (C) 2018 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.
- */
-
-#pragma once
-
-#include <EGL/egl.h>
-#include <EGL/eglext.h>
-
-#include <gui/BufferQueueDefs.h>
-
-#include <SkImage.h>
-#include <cutils/compiler.h>
-#include <gui/BufferItem.h>
-#include <system/graphics.h>
-
-namespace android {
-
-namespace uirenderer {
-class RenderState;
-}
-
-class SurfaceTexture;
-
-/*
- * ImageConsumer implements the parts of SurfaceTexture that deal with
- * images consumed by HWUI view system.
- */
-class ImageConsumer {
-public:
- sk_sp<SkImage> dequeueImage(bool* queueEmpty, SurfaceTexture& cb,
- uirenderer::RenderState& renderState);
-
- /**
- * onAcquireBufferLocked amends the ConsumerBase method to update the
- * mImageSlots array in addition to the ConsumerBase behavior.
- */
- void onAcquireBufferLocked(BufferItem* item);
-
- /**
- * onReleaseBufferLocked amends the ConsumerBase method to update the
- * mImageSlots array in addition to the ConsumerBase.
- */
- void onReleaseBufferLocked(int slot);
-
- /**
- * onFreeBufferLocked frees up the given buffer slot. If the slot has been
- * initialized this will release the reference to the GraphicBuffer in that
- * slot and destroy the SkImage in that slot. Otherwise it has no effect.
- */
- void onFreeBufferLocked(int slotIndex);
-
-private:
- /**
- * ImageSlot contains the information and object references that
- * ImageConsumer maintains about a BufferQueue buffer slot.
- */
- struct ImageSlot {
- ImageSlot() : mEglFence(EGL_NO_SYNC_KHR) {}
-
- // mImage is the SkImage created from mGraphicBuffer.
- sk_sp<SkImage> mImage;
-
- /**
- * mEglFence is the EGL sync object that must signal before the buffer
- * associated with this buffer slot may be dequeued.
- */
- EGLSyncKHR mEglFence;
-
- void createIfNeeded(sp<GraphicBuffer> graphicBuffer);
- };
-
- /**
- * ImageConsumer stores the SkImages that have been allocated by the BufferQueue
- * for each buffer slot. It is initialized to null pointers, and gets
- * filled in with the result of BufferQueue::acquire when the
- * client dequeues a buffer from a
- * slot that has not yet been used. The buffer allocated to a slot will also
- * be replaced if the requested buffer usage or geometry differs from that
- * of the buffer allocated to a slot.
- */
- ImageSlot mImageSlots[BufferQueueDefs::NUM_BUFFER_SLOTS];
-};
-
-}; /* namespace android */
diff --git a/libs/hwui/surfacetexture/SurfaceTexture.cpp b/libs/hwui/surfacetexture/SurfaceTexture.cpp
deleted file mode 100644
index 4bff715..0000000
--- a/libs/hwui/surfacetexture/SurfaceTexture.cpp
+++ /dev/null
@@ -1,496 +0,0 @@
-/*
- * Copyright (C) 2018 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.
- */
-
-#include <cutils/compiler.h>
-#include <gui/BufferQueue.h>
-#include <math/mat4.h>
-#include <system/window.h>
-
-#include <utils/Trace.h>
-
-#include "Matrix.h"
-#include "SurfaceTexture.h"
-
-namespace android {
-
-// Macros for including the SurfaceTexture name in log messages
-#define SFT_LOGV(x, ...) ALOGV("[%s] " x, mName.string(), ##__VA_ARGS__)
-#define SFT_LOGD(x, ...) ALOGD("[%s] " x, mName.string(), ##__VA_ARGS__)
-#define SFT_LOGW(x, ...) ALOGW("[%s] " x, mName.string(), ##__VA_ARGS__)
-#define SFT_LOGE(x, ...) ALOGE("[%s] " x, mName.string(), ##__VA_ARGS__)
-
-static const mat4 mtxIdentity;
-
-SurfaceTexture::SurfaceTexture(const sp<IGraphicBufferConsumer>& bq, uint32_t tex,
- uint32_t texTarget, bool useFenceSync, bool isControlledByApp)
- : ConsumerBase(bq, isControlledByApp)
- , mCurrentCrop(Rect::EMPTY_RECT)
- , mCurrentTransform(0)
- , mCurrentScalingMode(NATIVE_WINDOW_SCALING_MODE_FREEZE)
- , mCurrentFence(Fence::NO_FENCE)
- , mCurrentTimestamp(0)
- , mCurrentDataSpace(HAL_DATASPACE_UNKNOWN)
- , mCurrentFrameNumber(0)
- , mDefaultWidth(1)
- , mDefaultHeight(1)
- , mFilteringEnabled(true)
- , mTexName(tex)
- , mUseFenceSync(useFenceSync)
- , mTexTarget(texTarget)
- , mCurrentTexture(BufferQueue::INVALID_BUFFER_SLOT)
- , mOpMode(OpMode::attachedToGL) {
- SFT_LOGV("SurfaceTexture");
-
- memcpy(mCurrentTransformMatrix, mtxIdentity.asArray(), sizeof(mCurrentTransformMatrix));
-
- mConsumer->setConsumerUsageBits(DEFAULT_USAGE_FLAGS);
-}
-
-SurfaceTexture::SurfaceTexture(const sp<IGraphicBufferConsumer>& bq, uint32_t texTarget,
- bool useFenceSync, bool isControlledByApp)
- : ConsumerBase(bq, isControlledByApp)
- , mCurrentCrop(Rect::EMPTY_RECT)
- , mCurrentTransform(0)
- , mCurrentScalingMode(NATIVE_WINDOW_SCALING_MODE_FREEZE)
- , mCurrentFence(Fence::NO_FENCE)
- , mCurrentTimestamp(0)
- , mCurrentDataSpace(HAL_DATASPACE_UNKNOWN)
- , mCurrentFrameNumber(0)
- , mDefaultWidth(1)
- , mDefaultHeight(1)
- , mFilteringEnabled(true)
- , mTexName(0)
- , mUseFenceSync(useFenceSync)
- , mTexTarget(texTarget)
- , mCurrentTexture(BufferQueue::INVALID_BUFFER_SLOT)
- , mOpMode(OpMode::detached) {
- SFT_LOGV("SurfaceTexture");
-
- memcpy(mCurrentTransformMatrix, mtxIdentity.asArray(), sizeof(mCurrentTransformMatrix));
-
- mConsumer->setConsumerUsageBits(DEFAULT_USAGE_FLAGS);
-}
-
-status_t SurfaceTexture::setDefaultBufferSize(uint32_t w, uint32_t h) {
- Mutex::Autolock lock(mMutex);
- if (mAbandoned) {
- SFT_LOGE("setDefaultBufferSize: SurfaceTexture is abandoned!");
- return NO_INIT;
- }
- mDefaultWidth = w;
- mDefaultHeight = h;
- return mConsumer->setDefaultBufferSize(w, h);
-}
-
-status_t SurfaceTexture::updateTexImage() {
- ATRACE_CALL();
- SFT_LOGV("updateTexImage");
- Mutex::Autolock lock(mMutex);
-
- if (mAbandoned) {
- SFT_LOGE("updateTexImage: SurfaceTexture is abandoned!");
- return NO_INIT;
- }
-
- return mEGLConsumer.updateTexImage(*this);
-}
-
-status_t SurfaceTexture::releaseTexImage() {
- // releaseTexImage can be invoked even when not attached to a GL context.
- ATRACE_CALL();
- SFT_LOGV("releaseTexImage");
- Mutex::Autolock lock(mMutex);
-
- if (mAbandoned) {
- SFT_LOGE("releaseTexImage: SurfaceTexture is abandoned!");
- return NO_INIT;
- }
-
- return mEGLConsumer.releaseTexImage(*this);
-}
-
-status_t SurfaceTexture::acquireBufferLocked(BufferItem* item, nsecs_t presentWhen,
- uint64_t maxFrameNumber) {
- status_t err = ConsumerBase::acquireBufferLocked(item, presentWhen, maxFrameNumber);
- if (err != NO_ERROR) {
- return err;
- }
-
- switch (mOpMode) {
- case OpMode::attachedToView:
- mImageConsumer.onAcquireBufferLocked(item);
- break;
- case OpMode::attachedToGL:
- mEGLConsumer.onAcquireBufferLocked(item, *this);
- break;
- case OpMode::detached:
- break;
- }
-
- return NO_ERROR;
-}
-
-status_t SurfaceTexture::releaseBufferLocked(int buf, sp<GraphicBuffer> graphicBuffer,
- EGLDisplay display, EGLSyncKHR eglFence) {
- // release the buffer if it hasn't already been discarded by the
- // BufferQueue. This can happen, for example, when the producer of this
- // buffer has reallocated the original buffer slot after this buffer
- // was acquired.
- status_t err = ConsumerBase::releaseBufferLocked(buf, graphicBuffer, display, eglFence);
- // We could be releasing an EGL buffer, even if not currently attached to a GL context.
- mImageConsumer.onReleaseBufferLocked(buf);
- mEGLConsumer.onReleaseBufferLocked(buf);
- return err;
-}
-
-status_t SurfaceTexture::detachFromContext() {
- ATRACE_CALL();
- SFT_LOGV("detachFromContext");
- Mutex::Autolock lock(mMutex);
-
- if (mAbandoned) {
- SFT_LOGE("detachFromContext: abandoned SurfaceTexture");
- return NO_INIT;
- }
-
- if (mOpMode != OpMode::attachedToGL) {
- SFT_LOGE("detachFromContext: SurfaceTexture is not attached to a GL context");
- return INVALID_OPERATION;
- }
-
- status_t err = mEGLConsumer.detachFromContext(*this);
- if (err == OK) {
- mOpMode = OpMode::detached;
- }
-
- return err;
-}
-
-status_t SurfaceTexture::attachToContext(uint32_t tex) {
- ATRACE_CALL();
- SFT_LOGV("attachToContext");
- Mutex::Autolock lock(mMutex);
-
- if (mAbandoned) {
- SFT_LOGE("attachToContext: abandoned SurfaceTexture");
- return NO_INIT;
- }
-
- if (mOpMode != OpMode::detached) {
- SFT_LOGE(
- "attachToContext: SurfaceTexture is already attached to a "
- "context");
- return INVALID_OPERATION;
- }
-
- if (mCurrentTexture != BufferQueue::INVALID_BUFFER_SLOT) {
- // release possible ImageConsumer cache
- mImageConsumer.onFreeBufferLocked(mCurrentTexture);
- }
-
- return mEGLConsumer.attachToContext(tex, *this);
-}
-
-void SurfaceTexture::attachToView() {
- ATRACE_CALL();
- Mutex::Autolock _l(mMutex);
- if (mAbandoned) {
- SFT_LOGE("attachToView: abandoned SurfaceTexture");
- return;
- }
- if (mOpMode == OpMode::detached) {
- mOpMode = OpMode::attachedToView;
-
- if (mCurrentTexture != BufferQueue::INVALID_BUFFER_SLOT) {
- // release possible EGLConsumer texture cache
- mEGLConsumer.onFreeBufferLocked(mCurrentTexture);
- mEGLConsumer.onAbandonLocked();
- }
- } else {
- SFT_LOGE("attachToView: already attached");
- }
-}
-
-void SurfaceTexture::detachFromView() {
- ATRACE_CALL();
- Mutex::Autolock _l(mMutex);
-
- if (mAbandoned) {
- SFT_LOGE("detachFromView: abandoned SurfaceTexture");
- return;
- }
-
- if (mOpMode == OpMode::attachedToView) {
- mOpMode = OpMode::detached;
- } else {
- SFT_LOGE("detachFromView: not attached to View");
- }
-}
-
-uint32_t SurfaceTexture::getCurrentTextureTarget() const {
- return mTexTarget;
-}
-
-void SurfaceTexture::getTransformMatrix(float mtx[16]) {
- Mutex::Autolock lock(mMutex);
- memcpy(mtx, mCurrentTransformMatrix, sizeof(mCurrentTransformMatrix));
-}
-
-void SurfaceTexture::setFilteringEnabled(bool enabled) {
- Mutex::Autolock lock(mMutex);
- if (mAbandoned) {
- SFT_LOGE("setFilteringEnabled: SurfaceTexture is abandoned!");
- return;
- }
- bool needsRecompute = mFilteringEnabled != enabled;
- mFilteringEnabled = enabled;
-
- if (needsRecompute && mCurrentTexture == BufferQueue::INVALID_BUFFER_SLOT) {
- SFT_LOGD("setFilteringEnabled called with no current item");
- }
-
- if (needsRecompute && mCurrentTexture != BufferQueue::INVALID_BUFFER_SLOT) {
- computeCurrentTransformMatrixLocked();
- }
-}
-
-void SurfaceTexture::computeCurrentTransformMatrixLocked() {
- SFT_LOGV("computeCurrentTransformMatrixLocked");
- sp<GraphicBuffer> buf = (mCurrentTexture == BufferQueue::INVALID_BUFFER_SLOT)
- ? nullptr
- : mSlots[mCurrentTexture].mGraphicBuffer;
- if (buf == nullptr) {
- SFT_LOGD("computeCurrentTransformMatrixLocked: no current item");
- }
- computeTransformMatrix(mCurrentTransformMatrix, buf, mCurrentCrop, mCurrentTransform,
- mFilteringEnabled);
-}
-
-void SurfaceTexture::computeTransformMatrix(float outTransform[16], const sp<GraphicBuffer>& buf,
- const Rect& cropRect, uint32_t transform,
- bool filtering) {
- // Transform matrices
- static const mat4 mtxFlipH(-1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1);
- static const mat4 mtxFlipV(1, 0, 0, 0, 0, -1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1);
- static const mat4 mtxRot90(0, 1, 0, 0, -1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1);
-
- mat4 xform;
- if (transform & NATIVE_WINDOW_TRANSFORM_FLIP_H) {
- xform *= mtxFlipH;
- }
- if (transform & NATIVE_WINDOW_TRANSFORM_FLIP_V) {
- xform *= mtxFlipV;
- }
- if (transform & NATIVE_WINDOW_TRANSFORM_ROT_90) {
- xform *= mtxRot90;
- }
-
- if (!cropRect.isEmpty() && buf.get()) {
- float tx = 0.0f, ty = 0.0f, sx = 1.0f, sy = 1.0f;
- float bufferWidth = buf->getWidth();
- float bufferHeight = buf->getHeight();
- float shrinkAmount = 0.0f;
- if (filtering) {
- // In order to prevent bilinear sampling beyond the edge of the
- // crop rectangle we may need to shrink it by 2 texels in each
- // dimension. Normally this would just need to take 1/2 a texel
- // off each end, but because the chroma channels of YUV420 images
- // are subsampled we may need to shrink the crop region by a whole
- // texel on each side.
- switch (buf->getPixelFormat()) {
- case PIXEL_FORMAT_RGBA_8888:
- case PIXEL_FORMAT_RGBX_8888:
- case PIXEL_FORMAT_RGBA_FP16:
- case PIXEL_FORMAT_RGBA_1010102:
- case PIXEL_FORMAT_RGB_888:
- case PIXEL_FORMAT_RGB_565:
- case PIXEL_FORMAT_BGRA_8888:
- // We know there's no subsampling of any channels, so we
- // only need to shrink by a half a pixel.
- shrinkAmount = 0.5;
- break;
-
- default:
- // If we don't recognize the format, we must assume the
- // worst case (that we care about), which is YUV420.
- shrinkAmount = 1.0;
- break;
- }
- }
-
- // Only shrink the dimensions that are not the size of the buffer.
- if (cropRect.width() < bufferWidth) {
- tx = (float(cropRect.left) + shrinkAmount) / bufferWidth;
- sx = (float(cropRect.width()) - (2.0f * shrinkAmount)) / bufferWidth;
- }
- if (cropRect.height() < bufferHeight) {
- ty = (float(bufferHeight - cropRect.bottom) + shrinkAmount) / bufferHeight;
- sy = (float(cropRect.height()) - (2.0f * shrinkAmount)) / bufferHeight;
- }
-
- mat4 crop(sx, 0, 0, 0, 0, sy, 0, 0, 0, 0, 1, 0, tx, ty, 0, 1);
- xform = crop * xform;
- }
-
- // SurfaceFlinger expects the top of its window textures to be at a Y
- // coordinate of 0, so SurfaceTexture must behave the same way. We don't
- // want to expose this to applications, however, so we must add an
- // additional vertical flip to the transform after all the other transforms.
- xform = mtxFlipV * xform;
-
- memcpy(outTransform, xform.asArray(), sizeof(xform));
-}
-
-Rect SurfaceTexture::scaleDownCrop(const Rect& crop, uint32_t bufferWidth, uint32_t bufferHeight) {
- Rect outCrop = crop;
-
- uint32_t newWidth = static_cast<uint32_t>(crop.width());
- uint32_t newHeight = static_cast<uint32_t>(crop.height());
-
- if (newWidth * bufferHeight > newHeight * bufferWidth) {
- newWidth = newHeight * bufferWidth / bufferHeight;
- ALOGV("too wide: newWidth = %d", newWidth);
- } else if (newWidth * bufferHeight < newHeight * bufferWidth) {
- newHeight = newWidth * bufferHeight / bufferWidth;
- ALOGV("too tall: newHeight = %d", newHeight);
- }
-
- uint32_t currentWidth = static_cast<uint32_t>(crop.width());
- uint32_t currentHeight = static_cast<uint32_t>(crop.height());
-
- // The crop is too wide
- if (newWidth < currentWidth) {
- uint32_t dw = currentWidth - newWidth;
- auto halfdw = dw / 2;
- outCrop.left += halfdw;
- // Not halfdw because it would subtract 1 too few when dw is odd
- outCrop.right -= (dw - halfdw);
- // The crop is too tall
- } else if (newHeight < currentHeight) {
- uint32_t dh = currentHeight - newHeight;
- auto halfdh = dh / 2;
- outCrop.top += halfdh;
- // Not halfdh because it would subtract 1 too few when dh is odd
- outCrop.bottom -= (dh - halfdh);
- }
-
- ALOGV("getCurrentCrop final crop [%d,%d,%d,%d]", outCrop.left, outCrop.top, outCrop.right,
- outCrop.bottom);
-
- return outCrop;
-}
-
-nsecs_t SurfaceTexture::getTimestamp() {
- SFT_LOGV("getTimestamp");
- Mutex::Autolock lock(mMutex);
- return mCurrentTimestamp;
-}
-
-android_dataspace SurfaceTexture::getCurrentDataSpace() {
- SFT_LOGV("getCurrentDataSpace");
- Mutex::Autolock lock(mMutex);
- return mCurrentDataSpace;
-}
-
-uint64_t SurfaceTexture::getFrameNumber() {
- SFT_LOGV("getFrameNumber");
- Mutex::Autolock lock(mMutex);
- return mCurrentFrameNumber;
-}
-
-Rect SurfaceTexture::getCurrentCrop() const {
- Mutex::Autolock lock(mMutex);
- return (mCurrentScalingMode == NATIVE_WINDOW_SCALING_MODE_SCALE_CROP)
- ? scaleDownCrop(mCurrentCrop, mDefaultWidth, mDefaultHeight)
- : mCurrentCrop;
-}
-
-uint32_t SurfaceTexture::getCurrentTransform() const {
- Mutex::Autolock lock(mMutex);
- return mCurrentTransform;
-}
-
-uint32_t SurfaceTexture::getCurrentScalingMode() const {
- Mutex::Autolock lock(mMutex);
- return mCurrentScalingMode;
-}
-
-sp<Fence> SurfaceTexture::getCurrentFence() const {
- Mutex::Autolock lock(mMutex);
- return mCurrentFence;
-}
-
-std::shared_ptr<FenceTime> SurfaceTexture::getCurrentFenceTime() const {
- Mutex::Autolock lock(mMutex);
- return mCurrentFenceTime;
-}
-
-void SurfaceTexture::freeBufferLocked(int slotIndex) {
- SFT_LOGV("freeBufferLocked: slotIndex=%d", slotIndex);
- if (slotIndex == mCurrentTexture) {
- mCurrentTexture = BufferQueue::INVALID_BUFFER_SLOT;
- }
- // The slotIndex buffer could have EGL or SkImage cache, but there is no way to tell for sure.
- // Buffers can be freed after SurfaceTexture has detached from GL context or View.
- mImageConsumer.onFreeBufferLocked(slotIndex);
- mEGLConsumer.onFreeBufferLocked(slotIndex);
- ConsumerBase::freeBufferLocked(slotIndex);
-}
-
-void SurfaceTexture::abandonLocked() {
- SFT_LOGV("abandonLocked");
- mEGLConsumer.onAbandonLocked();
- ConsumerBase::abandonLocked();
-}
-
-status_t SurfaceTexture::setConsumerUsageBits(uint64_t usage) {
- return ConsumerBase::setConsumerUsageBits(usage | DEFAULT_USAGE_FLAGS);
-}
-
-void SurfaceTexture::dumpLocked(String8& result, const char* prefix) const {
- result.appendFormat(
- "%smTexName=%d mCurrentTexture=%d\n"
- "%smCurrentCrop=[%d,%d,%d,%d] mCurrentTransform=%#x\n",
- prefix, mTexName, mCurrentTexture, prefix, mCurrentCrop.left, mCurrentCrop.top,
- mCurrentCrop.right, mCurrentCrop.bottom, mCurrentTransform);
-
- ConsumerBase::dumpLocked(result, prefix);
-}
-
-sk_sp<SkImage> SurfaceTexture::dequeueImage(SkMatrix& transformMatrix, android_dataspace& dataSpace,
- bool* queueEmpty,
- uirenderer::RenderState& renderState) {
- Mutex::Autolock _l(mMutex);
-
- if (mAbandoned) {
- SFT_LOGE("dequeueImage: SurfaceTexture is abandoned!");
- return nullptr;
- }
-
- if (mOpMode != OpMode::attachedToView) {
- SFT_LOGE("dequeueImage: SurfaceTexture is not attached to a View");
- return nullptr;
- }
-
- auto image = mImageConsumer.dequeueImage(queueEmpty, *this, renderState);
- if (image.get()) {
- uirenderer::mat4(mCurrentTransformMatrix).copyTo(transformMatrix);
- dataSpace = mCurrentDataSpace;
- }
- return image;
-}
-
-}; // namespace android
diff --git a/libs/hwui/surfacetexture/SurfaceTexture.h b/libs/hwui/surfacetexture/SurfaceTexture.h
deleted file mode 100644
index db392a9..0000000
--- a/libs/hwui/surfacetexture/SurfaceTexture.h
+++ /dev/null
@@ -1,452 +0,0 @@
-/*
- * Copyright (C) 2018 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.
- */
-
-#pragma once
-
-#include <gui/BufferQueueDefs.h>
-#include <gui/ConsumerBase.h>
-
-#include <ui/FenceTime.h>
-#include <ui/GraphicBuffer.h>
-
-#include <utils/Mutex.h>
-#include <utils/String8.h>
-
-#include "EGLConsumer.h"
-#include "ImageConsumer.h"
-
-namespace android {
-
-namespace uirenderer {
-class RenderState;
-}
-
-/*
- * SurfaceTexture consumes buffers of graphics data from a BufferQueue,
- * and makes them available to HWUI render thread as a SkImage and to
- * an application GL render thread as an OpenGL texture.
- *
- * When attached to an application GL render thread, a typical usage
- * pattern is to set up the SurfaceTexture with the
- * desired options, and call updateTexImage() when a new frame is desired.
- * If a new frame is available, the texture will be updated. If not,
- * the previous contents are retained.
- *
- * When attached to a HWUI render thread, the TextureView implementation
- * calls dequeueImage, which either pulls a new SkImage or returns the
- * last cached SkImage if BufferQueue is empty.
- * When attached to HWUI render thread, SurfaceTexture is compatible to
- * both Vulkan and GL drawing pipelines.
- */
-class ANDROID_API SurfaceTexture : public ConsumerBase {
-public:
- enum { TEXTURE_EXTERNAL = 0x8D65 }; // GL_TEXTURE_EXTERNAL_OES
- typedef ConsumerBase::FrameAvailableListener FrameAvailableListener;
-
- /**
- * SurfaceTexture constructs a new SurfaceTexture object. If the constructor with
- * the tex parameter is used, tex indicates the name of the OpenGL ES
- * texture to which images are to be streamed. texTarget specifies the
- * OpenGL ES texture target to which the texture will be bound in
- * updateTexImage. useFenceSync specifies whether fences should be used to
- * synchronize access to buffers if that behavior is enabled at
- * compile-time.
- *
- * A SurfaceTexture may be detached from one OpenGL ES context and then
- * attached to a different context using the detachFromContext and
- * attachToContext methods, respectively. The intention of these methods is
- * purely to allow a SurfaceTexture to be transferred from one consumer
- * context to another. If such a transfer is not needed there is no
- * requirement that either of these methods be called.
- *
- * If the constructor with the tex parameter is used, the SurfaceTexture is
- * created in a state where it is considered attached to an OpenGL ES
- * context for the purposes of the attachToContext and detachFromContext
- * methods. However, despite being considered "attached" to a context, the
- * specific OpenGL ES context doesn't get latched until the first call to
- * updateTexImage. After that point, all calls to updateTexImage must be
- * made with the same OpenGL ES context current.
- *
- * If the constructor without the tex parameter is used, the SurfaceTexture is
- * created in a detached state, and attachToContext must be called before
- * calls to updateTexImage.
- */
- SurfaceTexture(const sp<IGraphicBufferConsumer>& bq, uint32_t tex, uint32_t texureTarget,
- bool useFenceSync, bool isControlledByApp);
-
- SurfaceTexture(const sp<IGraphicBufferConsumer>& bq, uint32_t texureTarget, bool useFenceSync,
- bool isControlledByApp);
-
- /**
- * updateTexImage acquires the most recently queued buffer, and sets the
- * image contents of the target texture to it.
- *
- * This call may only be made while the OpenGL ES context to which the
- * target texture belongs is bound to the calling thread.
- *
- * This calls doGLFenceWait to ensure proper synchronization.
- */
- status_t updateTexImage();
-
- /**
- * releaseTexImage releases the texture acquired in updateTexImage().
- * This is intended to be used in single buffer mode.
- *
- * This call may only be made while the OpenGL ES context to which the
- * target texture belongs is bound to the calling thread.
- */
- status_t releaseTexImage();
-
- /**
- * getTransformMatrix retrieves the 4x4 texture coordinate transform matrix
- * associated with the texture image set by the most recent call to
- * updateTexImage.
- *
- * This transform matrix maps 2D homogeneous texture coordinates of the form
- * (s, t, 0, 1) with s and t in the inclusive range [0, 1] to the texture
- * coordinate that should be used to sample that location from the texture.
- * Sampling the texture outside of the range of this transform is undefined.
- *
- * This transform is necessary to compensate for transforms that the stream
- * content producer may implicitly apply to the content. By forcing users of
- * a SurfaceTexture to apply this transform we avoid performing an extra
- * copy of the data that would be needed to hide the transform from the
- * user.
- *
- * The matrix is stored in column-major order so that it may be passed
- * directly to OpenGL ES via the glLoadMatrixf or glUniformMatrix4fv
- * functions.
- */
- void getTransformMatrix(float mtx[16]);
-
- /**
- * Computes the transform matrix documented by getTransformMatrix
- * from the BufferItem sub parts.
- */
- static void computeTransformMatrix(float outTransform[16], const sp<GraphicBuffer>& buf,
- const Rect& cropRect, uint32_t transform, bool filtering);
-
- /**
- * Scale the crop down horizontally or vertically such that it has the
- * same aspect ratio as the buffer does.
- */
- static Rect scaleDownCrop(const Rect& crop, uint32_t bufferWidth, uint32_t bufferHeight);
-
- /**
- * getTimestamp retrieves the timestamp associated with the texture image
- * set by the most recent call to updateTexImage.
- *
- * The timestamp is in nanoseconds, and is monotonically increasing. Its
- * other semantics (zero point, etc) are source-dependent and should be
- * documented by the source.
- */
- int64_t getTimestamp();
-
- /**
- * getDataSpace retrieves the DataSpace associated with the texture image
- * set by the most recent call to updateTexImage.
- */
- android_dataspace getCurrentDataSpace();
-
- /**
- * getFrameNumber retrieves the frame number associated with the texture
- * image set by the most recent call to updateTexImage.
- *
- * The frame number is an incrementing counter set to 0 at the creation of
- * the BufferQueue associated with this consumer.
- */
- uint64_t getFrameNumber();
-
- /**
- * setDefaultBufferSize is used to set the size of buffers returned by
- * requestBuffers when a with and height of zero is requested.
- * A call to setDefaultBufferSize() may trigger requestBuffers() to
- * be called from the client.
- * The width and height parameters must be no greater than the minimum of
- * GL_MAX_VIEWPORT_DIMS and GL_MAX_TEXTURE_SIZE (see: glGetIntegerv).
- * An error due to invalid dimensions might not be reported until
- * updateTexImage() is called.
- */
- status_t setDefaultBufferSize(uint32_t width, uint32_t height);
-
- /**
- * setFilteringEnabled sets whether the transform matrix should be computed
- * for use with bilinear filtering.
- */
- void setFilteringEnabled(bool enabled);
-
- /**
- * getCurrentTextureTarget returns the texture target of the current
- * texture as returned by updateTexImage().
- */
- uint32_t getCurrentTextureTarget() const;
-
- /**
- * getCurrentCrop returns the cropping rectangle of the current buffer.
- */
- Rect getCurrentCrop() const;
-
- /**
- * getCurrentTransform returns the transform of the current buffer.
- */
- uint32_t getCurrentTransform() const;
-
- /**
- * getCurrentScalingMode returns the scaling mode of the current buffer.
- */
- uint32_t getCurrentScalingMode() const;
-
- /**
- * getCurrentFence returns the fence indicating when the current buffer is
- * ready to be read from.
- */
- sp<Fence> getCurrentFence() const;
-
- /**
- * getCurrentFence returns the FenceTime indicating when the current
- * buffer is ready to be read from.
- */
- std::shared_ptr<FenceTime> getCurrentFenceTime() const;
-
- /**
- * setConsumerUsageBits overrides the ConsumerBase method to OR
- * DEFAULT_USAGE_FLAGS to usage.
- */
- status_t setConsumerUsageBits(uint64_t usage);
-
- /**
- * detachFromContext detaches the SurfaceTexture from the calling thread's
- * current OpenGL ES context. This context must be the same as the context
- * that was current for previous calls to updateTexImage.
- *
- * Detaching a SurfaceTexture from an OpenGL ES context will result in the
- * deletion of the OpenGL ES texture object into which the images were being
- * streamed. After a SurfaceTexture has been detached from the OpenGL ES
- * context calls to updateTexImage will fail returning INVALID_OPERATION
- * until the SurfaceTexture is attached to a new OpenGL ES context using the
- * attachToContext method.
- */
- status_t detachFromContext();
-
- /**
- * attachToContext attaches a SurfaceTexture that is currently in the
- * 'detached' state to the current OpenGL ES context. A SurfaceTexture is
- * in the 'detached' state iff detachFromContext has successfully been
- * called and no calls to attachToContext have succeeded since the last
- * detachFromContext call. Calls to attachToContext made on a
- * SurfaceTexture that is not in the 'detached' state will result in an
- * INVALID_OPERATION error.
- *
- * The tex argument specifies the OpenGL ES texture object name in the
- * new context into which the image contents will be streamed. A successful
- * call to attachToContext will result in this texture object being bound to
- * the texture target and populated with the image contents that were
- * current at the time of the last call to detachFromContext.
- */
- status_t attachToContext(uint32_t tex);
-
- sk_sp<SkImage> dequeueImage(SkMatrix& transformMatrix, android_dataspace& dataSpace,
- bool* queueEmpty, uirenderer::RenderState& renderState);
-
- /**
- * attachToView attaches a SurfaceTexture that is currently in the
- * 'detached' state to HWUI View system.
- */
- void attachToView();
-
- /**
- * detachFromView detaches a SurfaceTexture from HWUI View system.
- */
- void detachFromView();
-
-protected:
- /**
- * abandonLocked overrides the ConsumerBase method to clear
- * mCurrentTextureImage in addition to the ConsumerBase behavior.
- */
- virtual void abandonLocked();
-
- /**
- * dumpLocked overrides the ConsumerBase method to dump SurfaceTexture-
- * specific info in addition to the ConsumerBase behavior.
- */
- virtual void dumpLocked(String8& result, const char* prefix) const override;
-
- /**
- * acquireBufferLocked overrides the ConsumerBase method to update the
- * mEglSlots array in addition to the ConsumerBase behavior.
- */
- virtual status_t acquireBufferLocked(BufferItem* item, nsecs_t presentWhen,
- uint64_t maxFrameNumber = 0) override;
-
- /**
- * releaseBufferLocked overrides the ConsumerBase method to update the
- * mEglSlots array in addition to the ConsumerBase.
- */
- virtual status_t releaseBufferLocked(int slot, const sp<GraphicBuffer> graphicBuffer,
- EGLDisplay display, EGLSyncKHR eglFence) override;
-
- /**
- * freeBufferLocked frees up the given buffer slot. If the slot has been
- * initialized this will release the reference to the GraphicBuffer in that
- * slot and destroy the EGLImage in that slot. Otherwise it has no effect.
- *
- * This method must be called with mMutex locked.
- */
- virtual void freeBufferLocked(int slotIndex);
-
- /**
- * computeCurrentTransformMatrixLocked computes the transform matrix for the
- * current texture. It uses mCurrentTransform and the current GraphicBuffer
- * to compute this matrix and stores it in mCurrentTransformMatrix.
- * mCurrentTextureImage must not be NULL.
- */
- void computeCurrentTransformMatrixLocked();
-
- /**
- * The default consumer usage flags that SurfaceTexture always sets on its
- * BufferQueue instance; these will be OR:d with any additional flags passed
- * from the SurfaceTexture user. In particular, SurfaceTexture will always
- * consume buffers as hardware textures.
- */
- static const uint64_t DEFAULT_USAGE_FLAGS = GraphicBuffer::USAGE_HW_TEXTURE;
-
- /**
- * mCurrentCrop is the crop rectangle that applies to the current texture.
- * It gets set each time updateTexImage is called.
- */
- Rect mCurrentCrop;
-
- /**
- * mCurrentTransform is the transform identifier for the current texture. It
- * gets set each time updateTexImage is called.
- */
- uint32_t mCurrentTransform;
-
- /**
- * mCurrentScalingMode is the scaling mode for the current texture. It gets
- * set each time updateTexImage is called.
- */
- uint32_t mCurrentScalingMode;
-
- /**
- * mCurrentFence is the fence received from BufferQueue in updateTexImage.
- */
- sp<Fence> mCurrentFence;
-
- /**
- * The FenceTime wrapper around mCurrentFence.
- */
- std::shared_ptr<FenceTime> mCurrentFenceTime{FenceTime::NO_FENCE};
-
- /**
- * mCurrentTransformMatrix is the transform matrix for the current texture.
- * It gets computed by computeTransformMatrix each time updateTexImage is
- * called.
- */
- float mCurrentTransformMatrix[16];
-
- /**
- * mCurrentTimestamp is the timestamp for the current texture. It
- * gets set each time updateTexImage is called.
- */
- int64_t mCurrentTimestamp;
-
- /**
- * mCurrentDataSpace is the dataspace for the current texture. It
- * gets set each time updateTexImage is called.
- */
- android_dataspace mCurrentDataSpace;
-
- /**
- * mCurrentFrameNumber is the frame counter for the current texture.
- * It gets set each time updateTexImage is called.
- */
- uint64_t mCurrentFrameNumber;
-
- uint32_t mDefaultWidth, mDefaultHeight;
-
- /**
- * mFilteringEnabled indicates whether the transform matrix is computed for
- * use with bilinear filtering. It defaults to true and is changed by
- * setFilteringEnabled().
- */
- bool mFilteringEnabled;
-
- /**
- * mTexName is the name of the OpenGL texture to which streamed images will
- * be bound when updateTexImage is called. It is set at construction time
- * and can be changed with a call to attachToContext.
- */
- uint32_t mTexName;
-
- /**
- * mUseFenceSync indicates whether creation of the EGL_KHR_fence_sync
- * extension should be used to prevent buffers from being dequeued before
- * it's safe for them to be written. It gets set at construction time and
- * never changes.
- */
- const bool mUseFenceSync;
-
- /**
- * mTexTarget is the GL texture target with which the GL texture object is
- * associated. It is set in the constructor and never changed. It is
- * almost always GL_TEXTURE_EXTERNAL_OES except for one use case in Android
- * Browser. In that case it is set to GL_TEXTURE_2D to allow
- * glCopyTexSubImage to read from the texture. This is a hack to work
- * around a GL driver limitation on the number of FBO attachments, which the
- * browser's tile cache exceeds.
- */
- const uint32_t mTexTarget;
-
- /**
- * mCurrentTexture is the buffer slot index of the buffer that is currently
- * bound to the OpenGL texture. It is initialized to INVALID_BUFFER_SLOT,
- * indicating that no buffer slot is currently bound to the texture. Note,
- * however, that a value of INVALID_BUFFER_SLOT does not necessarily mean
- * that no buffer is bound to the texture. A call to setBufferCount will
- * reset mCurrentTexture to INVALID_BUFFER_SLOT.
- */
- int mCurrentTexture;
-
- enum class OpMode { detached, attachedToView, attachedToGL };
- /**
- * mOpMode indicates whether the SurfaceTexture is currently attached to
- * an OpenGL ES context or the HWUI view system. For legacy reasons, this is initialized to,
- * "attachedToGL" indicating that the SurfaceTexture is considered to be attached to
- * whatever GL context is current at the time of the first updateTexImage call.
- * It is set to "detached" by detachFromContext, and then set to "attachedToGL" again by
- * attachToContext.
- * attachToView/detachFromView are used to attach/detach from HWUI view system.
- */
- OpMode mOpMode;
-
- /**
- * mEGLConsumer has SurfaceTexture logic used when attached to GL context.
- */
- EGLConsumer mEGLConsumer;
-
- /**
- * mImageConsumer has SurfaceTexture logic used when attached to HWUI view system.
- */
- ImageConsumer mImageConsumer;
-
- friend class ImageConsumer;
- friend class EGLConsumer;
-};
-
-// ----------------------------------------------------------------------------
-}; // namespace android
diff --git a/libs/hwui/tests/common/LeakChecker.cpp b/libs/hwui/tests/common/LeakChecker.cpp
index d2d37dc..5b36154 100644
--- a/libs/hwui/tests/common/LeakChecker.cpp
+++ b/libs/hwui/tests/common/LeakChecker.cpp
@@ -16,6 +16,7 @@
#include "LeakChecker.h"
+#include "Caches.h"
#include "TestUtils.h"
#include <memunreachable/memunreachable.h>
@@ -70,6 +71,9 @@
// thread-local caches so some leaks will not be properly tagged as leaks
UnreachableMemoryInfo rtMemInfo;
TestUtils::runOnRenderThread([&rtMemInfo](renderthread::RenderThread& thread) {
+ if (Caches::hasInstance()) {
+ Caches::getInstance().tasks.stop();
+ }
// Check for leaks
if (!GetUnreachableMemory(rtMemInfo)) {
cerr << "Failed to get unreachable memory!" << endl;
diff --git a/libs/hwui/tests/common/TestUtils.cpp b/libs/hwui/tests/common/TestUtils.cpp
index 66b9b85..6958634 100644
--- a/libs/hwui/tests/common/TestUtils.cpp
+++ b/libs/hwui/tests/common/TestUtils.cpp
@@ -67,14 +67,16 @@
renderthread::RenderThread& renderThread, uint32_t width, uint32_t height,
const SkMatrix& transform) {
sp<DeferredLayerUpdater> layerUpdater = createTextureLayerUpdater(renderThread);
- layerUpdater->backingLayer()->getTransform() = transform;
+ layerUpdater->backingLayer()->getTransform().load(transform);
layerUpdater->setSize(width, height);
layerUpdater->setTransform(&transform);
// updateLayer so it's ready to draw
- SkMatrix identity;
- identity.setIdentity();
- layerUpdater->updateLayer(true, identity, HAL_DATASPACE_UNKNOWN, nullptr);
+ layerUpdater->updateLayer(true, Matrix4::identity().data, HAL_DATASPACE_UNKNOWN);
+ if (layerUpdater->backingLayer()->getApi() == Layer::Api::OpenGL) {
+ static_cast<GlLayer*>(layerUpdater->backingLayer())
+ ->setRenderTarget(GL_TEXTURE_EXTERNAL_OES);
+ }
return layerUpdater;
}
@@ -115,6 +117,7 @@
if (Properties::getRenderPipelineType() == RenderPipelineType::SkiaVulkan) {
renderThread.vulkanManager().destroy();
} else {
+ renderThread.renderState().flush(Caches::FlushMode::Full);
renderThread.destroyGlContext();
}
}
diff --git a/libs/hwui/tests/common/TestUtils.h b/libs/hwui/tests/common/TestUtils.h
index 0e6582c..743f809 100644
--- a/libs/hwui/tests/common/TestUtils.h
+++ b/libs/hwui/tests/common/TestUtils.h
@@ -18,6 +18,7 @@
#include <DeviceInfo.h>
#include <DisplayList.h>
+#include <GlLayer.h>
#include <Matrix.h>
#include <Properties.h>
#include <Rect.h>
diff --git a/libs/hwui/tests/unit/DeferredLayerUpdaterTests.cpp b/libs/hwui/tests/unit/DeferredLayerUpdaterTests.cpp
index 6c8775b..f29830f 100644
--- a/libs/hwui/tests/unit/DeferredLayerUpdaterTests.cpp
+++ b/libs/hwui/tests/unit/DeferredLayerUpdaterTests.cpp
@@ -15,13 +15,12 @@
*/
#include "DeferredLayerUpdater.h"
+#include "GlLayer.h"
#include "Properties.h"
#include "tests/common/TestUtils.h"
#include <gtest/gtest.h>
-#include <SkBitmap.h>
-#include <SkImage.h>
using namespace android;
using namespace android::uirenderer;
@@ -32,6 +31,10 @@
layerUpdater->setBlend(true);
// updates are deferred so the backing layer should still be in its default state
+ if (layerUpdater->backingLayer()->getApi() == Layer::Api::OpenGL) {
+ GlLayer* glLayer = static_cast<GlLayer*>(layerUpdater->backingLayer());
+ EXPECT_EQ((uint32_t)GL_NONE, glLayer->getRenderTarget());
+ }
EXPECT_EQ(0u, layerUpdater->backingLayer()->getWidth());
EXPECT_EQ(0u, layerUpdater->backingLayer()->getHeight());
EXPECT_FALSE(layerUpdater->backingLayer()->getForceFilter());
@@ -39,13 +42,19 @@
EXPECT_EQ(Matrix4::identity(), layerUpdater->backingLayer()->getTexTransform());
// push the deferred updates to the layer
- SkMatrix scaledMatrix = SkMatrix::MakeScale(0.5, 0.5);
- SkBitmap bitmap;
- bitmap.allocN32Pixels(16, 16);
- sk_sp<SkImage> layerImage = SkImage::MakeFromBitmap(bitmap);
- layerUpdater->updateLayer(true, scaledMatrix, HAL_DATASPACE_UNKNOWN, layerImage);
+ Matrix4 scaledMatrix;
+ scaledMatrix.loadScale(0.5, 0.5, 0.0);
+ layerUpdater->updateLayer(true, scaledMatrix.data, HAL_DATASPACE_UNKNOWN);
+ if (layerUpdater->backingLayer()->getApi() == Layer::Api::OpenGL) {
+ GlLayer* glLayer = static_cast<GlLayer*>(layerUpdater->backingLayer());
+ glLayer->setRenderTarget(GL_TEXTURE_EXTERNAL_OES);
+ }
// the backing layer should now have all the properties applied.
+ if (layerUpdater->backingLayer()->getApi() == Layer::Api::OpenGL) {
+ GlLayer* glLayer = static_cast<GlLayer*>(layerUpdater->backingLayer());
+ EXPECT_EQ((uint32_t)GL_TEXTURE_EXTERNAL_OES, glLayer->getRenderTarget());
+ }
EXPECT_EQ(100u, layerUpdater->backingLayer()->getWidth());
EXPECT_EQ(100u, layerUpdater->backingLayer()->getHeight());
EXPECT_TRUE(layerUpdater->backingLayer()->getForceFilter());
diff --git a/libs/hwui/tests/unit/ShaderCacheTests.cpp b/libs/hwui/tests/unit/ShaderCacheTests.cpp
index 43080a9..1433aa0 100644
--- a/libs/hwui/tests/unit/ShaderCacheTests.cpp
+++ b/libs/hwui/tests/unit/ShaderCacheTests.cpp
@@ -48,11 +48,18 @@
*/
static void terminate(ShaderCache& cache, bool saveContent) {
std::lock_guard<std::mutex> lock(cache.mMutex);
- if (cache.mInitialized && cache.mBlobCache && saveContent) {
- cache.mBlobCache->writeToFile();
- }
+ cache.mSavePending = saveContent;
+ cache.saveToDiskLocked();
cache.mBlobCache = NULL;
}
+
+ /**
+ *
+ */
+ template <typename T>
+ static bool validateCache(ShaderCache& cache, std::vector<T> hash) {
+ return cache.validateCache(hash.data(), hash.size() * sizeof(T));
+ }
};
} /* namespace skiapipeline */
@@ -75,26 +82,39 @@
return false;
}
-bool checkShader(const sk_sp<SkData>& shader, const char* program) {
- sk_sp<SkData> shader2 = SkData::MakeWithCString(program);
- return shader->size() == shader2->size()
- && 0 == memcmp(shader->data(), shader2->data(), shader->size());
+inline bool
+checkShader(const sk_sp<SkData>& shader1, const sk_sp<SkData>& shader2) {
+ return nullptr != shader1 && nullptr != shader2 && shader1->size() == shader2->size()
+ && 0 == memcmp(shader1->data(), shader2->data(), shader1->size());
}
-bool checkShader(const sk_sp<SkData>& shader, std::vector<char>& program) {
- sk_sp<SkData> shader2 = SkData::MakeWithCopy(program.data(), program.size());
- return shader->size() == shader2->size()
- && 0 == memcmp(shader->data(), shader2->data(), shader->size());
+inline bool
+checkShader(const sk_sp<SkData>& shader, const char* program) {
+ sk_sp<SkData> shader2 = SkData::MakeWithCString(program);
+ return checkShader(shader, shader2);
+}
+
+template <typename T>
+bool checkShader(const sk_sp<SkData>& shader, std::vector<T>& program) {
+ sk_sp<SkData> shader2 = SkData::MakeWithCopy(program.data(), program.size() * sizeof(T));
+ return checkShader(shader, shader2);
}
void setShader(sk_sp<SkData>& shader, const char* program) {
shader = SkData::MakeWithCString(program);
}
-void setShader(sk_sp<SkData>& shader, std::vector<char>& program) {
- shader = SkData::MakeWithCopy(program.data(), program.size());
+template <typename T>
+void setShader(sk_sp<SkData>& shader, std::vector<T>& buffer) {
+ shader = SkData::MakeWithCopy(buffer.data(), buffer.size() * sizeof(T));
}
+template <typename T>
+void genRandomData(std::vector<T>& buffer) {
+ for (auto& data : buffer) {
+ data = T(std::rand());
+ }
+}
#define GrProgramDescTest(a) (*SkData::MakeWithCString(#a).get())
@@ -110,6 +130,7 @@
//remove any test files from previous test run
int deleteFile = remove(cacheFile1.c_str());
ASSERT_TRUE(0 == deleteFile || ENOENT == errno);
+ std::srand(0);
//read the cache from a file that does not exist
ShaderCache::get().setFilename(cacheFile1.c_str());
@@ -158,10 +179,8 @@
//write and read big data chunk (50K)
size_t dataSize = 50*1024;
- std::vector<char> dataBuffer(dataSize);
- for (size_t i = 0; i < dataSize; i++) {
- dataBuffer[0] = dataSize % 256;
- }
+ std::vector<uint8_t> dataBuffer(dataSize);
+ genRandomData(dataBuffer);
setShader(inVS, dataBuffer);
ShaderCache::get().store(GrProgramDescTest(432), *inVS.get());
ShaderCacheTestUtils::terminate(ShaderCache::get(), true);
@@ -173,4 +192,96 @@
remove(cacheFile1.c_str());
}
+TEST(ShaderCacheTest, testCacheValidation) {
+ if (!folderExist(getExternalStorageFolder())) {
+ //don't run the test if external storage folder is not available
+ return;
+ }
+ std::string cacheFile1 = getExternalStorageFolder() + "/shaderCacheTest1";
+ std::string cacheFile2 = getExternalStorageFolder() + "/shaderCacheTest2";
+
+ //remove any test files from previous test run
+ int deleteFile = remove(cacheFile1.c_str());
+ ASSERT_TRUE(0 == deleteFile || ENOENT == errno);
+ std::srand(0);
+
+ //generate identity and read the cache from a file that does not exist
+ ShaderCache::get().setFilename(cacheFile1.c_str());
+ ShaderCacheTestUtils::setSaveDelay(ShaderCache::get(), 0); //disable deferred save
+ std::vector<uint8_t> identity(1024);
+ genRandomData(identity);
+ ShaderCache::get().initShaderDiskCache(identity.data(), identity.size() *
+ sizeof(decltype(identity)::value_type));
+
+ // generate random content in cache and store to disk
+ constexpr size_t numBlob(10);
+ constexpr size_t keySize(1024);
+ constexpr size_t dataSize(50 * 1024);
+
+ std::vector< std::pair<sk_sp<SkData>, sk_sp<SkData>> > blobVec(numBlob);
+ for (auto& blob : blobVec) {
+ std::vector<uint8_t> keyBuffer(keySize);
+ std::vector<uint8_t> dataBuffer(dataSize);
+ genRandomData(keyBuffer);
+ genRandomData(dataBuffer);
+
+ sk_sp<SkData> key, data;
+ setShader(key, keyBuffer);
+ setShader(data, dataBuffer);
+
+ blob = std::make_pair(key, data);
+ ShaderCache::get().store(*key.get(), *data.get());
+ }
+ ShaderCacheTestUtils::terminate(ShaderCache::get(), true);
+
+ // change to a file that does not exist and verify validation fails
+ ShaderCache::get().setFilename(cacheFile2.c_str());
+ ShaderCache::get().initShaderDiskCache();
+ ASSERT_FALSE( ShaderCacheTestUtils::validateCache(ShaderCache::get(), identity) );
+ ShaderCacheTestUtils::terminate(ShaderCache::get(), false);
+
+ // restore the original file and verify validation succeeds
+ ShaderCache::get().setFilename(cacheFile1.c_str());
+ ShaderCache::get().initShaderDiskCache(identity.data(), identity.size() *
+ sizeof(decltype(identity)::value_type));
+ ASSERT_TRUE( ShaderCacheTestUtils::validateCache(ShaderCache::get(), identity) );
+ for (const auto& blob : blobVec) {
+ auto outVS = ShaderCache::get().load(*blob.first.get());
+ ASSERT_TRUE( checkShader(outVS, blob.second) );
+ }
+
+ // generate error identity and verify load fails
+ ShaderCache::get().initShaderDiskCache(identity.data(), -1);
+ for (const auto& blob : blobVec) {
+ ASSERT_EQ( ShaderCache::get().load(*blob.first.get()), sk_sp<SkData>() );
+ }
+ ShaderCache::get().initShaderDiskCache(nullptr, identity.size() *
+ sizeof(decltype(identity)::value_type));
+ for (const auto& blob : blobVec) {
+ ASSERT_EQ( ShaderCache::get().load(*blob.first.get()), sk_sp<SkData>() );
+ }
+
+ // verify the cache validation again after load fails
+ ShaderCache::get().initShaderDiskCache(identity.data(), identity.size() *
+ sizeof(decltype(identity)::value_type));
+ ASSERT_TRUE( ShaderCacheTestUtils::validateCache(ShaderCache::get(), identity) );
+ for (const auto& blob : blobVec) {
+ auto outVS = ShaderCache::get().load(*blob.first.get());
+ ASSERT_TRUE( checkShader(outVS, blob.second) );
+ }
+
+ // generate another identity and verify load fails
+ for (auto& data : identity) {
+ data += std::rand();
+ }
+ ShaderCache::get().initShaderDiskCache(identity.data(), identity.size() *
+ sizeof(decltype(identity)::value_type));
+ for (const auto& blob : blobVec) {
+ ASSERT_EQ( ShaderCache::get().load(*blob.first.get()), sk_sp<SkData>() );
+ }
+
+ ShaderCacheTestUtils::terminate(ShaderCache::get(), false);
+ remove(cacheFile1.c_str());
+}
+
} // namespace
diff --git a/libs/hwui/tests/unit/main.cpp b/libs/hwui/tests/unit/main.cpp
index aecceb3..9e6d9a8 100644
--- a/libs/hwui/tests/unit/main.cpp
+++ b/libs/hwui/tests/unit/main.cpp
@@ -17,13 +17,12 @@
#include "gmock/gmock.h"
#include "gtest/gtest.h"
+#include "Caches.h"
#include "debug/GlesDriver.h"
#include "debug/NullGlesDriver.h"
#include "hwui/Typeface.h"
#include "Properties.h"
#include "tests/common/LeakChecker.h"
-#include "thread/TaskProcessor.h"
-#include "thread/Task.h"
#include "thread/TaskManager.h"
#include <signal.h>
diff --git a/libs/hwui/utils/PaintUtils.h b/libs/hwui/utils/PaintUtils.h
index ebf2343..f8e8a0a 100644
--- a/libs/hwui/utils/PaintUtils.h
+++ b/libs/hwui/utils/PaintUtils.h
@@ -16,7 +16,6 @@
#ifndef PAINT_UTILS_H
#define PAINT_UTILS_H
-#include <GLES2/gl2.h>
#include <utils/Blur.h>
#include <SkColorFilter.h>
diff --git a/native/android/Android.bp b/native/android/Android.bp
index 43847cc..4fb5e74 100644
--- a/native/android/Android.bp
+++ b/native/android/Android.bp
@@ -64,7 +64,6 @@
"libsensor",
"libandroid_runtime",
"libnetd_client",
- "libhwui",
],
static_libs: [
diff --git a/native/android/surface_texture.cpp b/native/android/surface_texture.cpp
index ced279277..b266881 100644
--- a/native/android/surface_texture.cpp
+++ b/native/android/surface_texture.cpp
@@ -21,16 +21,15 @@
#include <utils/Log.h>
+#include <gui/GLConsumer.h>
#include <gui/Surface.h>
#include <android_runtime/android_graphics_SurfaceTexture.h>
-#include "surfacetexture/SurfaceTexture.h"
-
using namespace android;
struct ASurfaceTexture {
- sp<SurfaceTexture> consumer;
+ sp<GLConsumer> consumer;
sp<IGraphicBufferProducer> producer;
};
diff --git a/packages/PackageInstaller/AndroidManifest.xml b/packages/PackageInstaller/AndroidManifest.xml
index 2be9311..7c81399 100644
--- a/packages/PackageInstaller/AndroidManifest.xml
+++ b/packages/PackageInstaller/AndroidManifest.xml
@@ -106,6 +106,14 @@
</intent-filter>
</receiver>
+ <receiver android:name=".PackageInstalledReceiver"
+ android:exported="true">
+ <intent-filter android:priority="1">
+ <action android:name="android.intent.action.PACKAGE_ADDED" />
+ <data android:scheme="package" />
+ </intent-filter>
+ </receiver>
+
<activity android:name=".UninstallUninstalling"
android:excludeFromRecents="true"
android:exported="false" />
diff --git a/packages/PackageInstaller/src/com/android/packageinstaller/PackageInstalledReceiver.java b/packages/PackageInstaller/src/com/android/packageinstaller/PackageInstalledReceiver.java
new file mode 100644
index 0000000..67ac99f
--- /dev/null
+++ b/packages/PackageInstaller/src/com/android/packageinstaller/PackageInstalledReceiver.java
@@ -0,0 +1,34 @@
+/*
+ * Copyright 2018 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 com.android.packageinstaller;
+
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+
+/**
+ * Receive new app installed broadcast and notify user new app installed.
+ */
+public class PackageInstalledReceiver extends BroadcastReceiver {
+
+ private static final String TAG = "PackageInstalledReceiver";
+
+ @Override
+ public void onReceive(Context context, Intent intent) {
+ // TODO: Add logic to handle new app installed.
+ }
+}
diff --git a/packages/SystemUI/src/com/android/systemui/qs/QSFragment.java b/packages/SystemUI/src/com/android/systemui/qs/QSFragment.java
index 7cb22a3..03febda 100644
--- a/packages/SystemUI/src/com/android/systemui/qs/QSFragment.java
+++ b/packages/SystemUI/src/com/android/systemui/qs/QSFragment.java
@@ -101,12 +101,7 @@
if (savedInstanceState != null) {
setExpanded(savedInstanceState.getBoolean(EXTRA_EXPANDED));
setListening(savedInstanceState.getBoolean(EXTRA_LISTENING));
- int[] loc = new int[2];
- View edit = view.findViewById(android.R.id.edit);
- edit.getLocationInWindow(loc);
- int x = loc[0] + edit.getWidth() / 2;
- int y = loc[1] + edit.getHeight() / 2;
- mQSCustomizer.setEditLocation(x, y);
+ setEditLocation(view);
mQSCustomizer.restoreInstanceState(savedInstanceState);
}
SysUiServiceProvider.getComponent(getContext(), CommandQueue.class).addCallbacks(this);
@@ -161,15 +156,24 @@
@Override
public void onConfigurationChanged(Configuration newConfig) {
super.onConfigurationChanged(newConfig);
+ setEditLocation(getView());
if (newConfig.getLayoutDirection() != mLayoutDirection) {
mLayoutDirection = newConfig.getLayoutDirection();
-
if (mQSAnimator != null) {
mQSAnimator.onRtlChanged();
}
}
}
+ private void setEditLocation(View view) {
+ Log.w(TAG, "I'm changing the location of the button!!!");
+ View edit = view.findViewById(android.R.id.edit);
+ int[] loc = edit.getLocationOnScreen();
+ int x = loc[0] + edit.getWidth() / 2;
+ int y = loc[1] + edit.getHeight() / 2;
+ mQSCustomizer.setEditLocation(x, y);
+ }
+
@Override
public void setContainer(ViewGroup container) {
if (container instanceof NotificationsQuickSettingsContainer) {
diff --git a/packages/SystemUI/src/com/android/systemui/qs/QSPanel.java b/packages/SystemUI/src/com/android/systemui/qs/QSPanel.java
index 6c330b0..762fd75 100644
--- a/packages/SystemUI/src/com/android/systemui/qs/QSPanel.java
+++ b/packages/SystemUI/src/com/android/systemui/qs/QSPanel.java
@@ -29,6 +29,7 @@
import android.os.Message;
import android.service.quicksettings.Tile;
import android.util.AttributeSet;
+import android.util.Log;
import android.view.LayoutInflater;
import android.view.View;
import android.widget.LinearLayout;
@@ -60,6 +61,8 @@
public static final String QS_SHOW_BRIGHTNESS = "qs_show_brightness";
public static final String QS_SHOW_HEADER = "qs_show_header";
+ private static final String TAG = "QSPanel";
+
protected final Context mContext;
protected final ArrayList<TileRecord> mRecords = new ArrayList<>();
protected final View mBrightnessView;
@@ -313,7 +316,7 @@
public void onCollapse() {
if (mCustomizePanel != null && mCustomizePanel.isShown()) {
- mCustomizePanel.hide(mCustomizePanel.getWidth() / 2, mCustomizePanel.getHeight() / 2);
+ mCustomizePanel.hide();
}
}
@@ -480,8 +483,7 @@
public void run() {
if (mCustomizePanel != null) {
if (!mCustomizePanel.isCustomizing()) {
- int[] loc = new int[2];
- v.getLocationInWindow(loc);
+ int[] loc = v.getLocationOnScreen();
int x = loc[0] + v.getWidth() / 2;
int y = loc[1] + v.getHeight() / 2;
mCustomizePanel.show(x, y);
@@ -495,7 +497,7 @@
public void closeDetail() {
if (mCustomizePanel != null && mCustomizePanel.isShown()) {
// Treat this as a detail panel for now, to make things easy.
- mCustomizePanel.hide(mCustomizePanel.getWidth() / 2, mCustomizePanel.getHeight() / 2);
+ mCustomizePanel.hide();
return;
}
showDetail(false, mDetailRecord);
diff --git a/packages/SystemUI/src/com/android/systemui/qs/customize/QSCustomizer.java b/packages/SystemUI/src/com/android/systemui/qs/customize/QSCustomizer.java
index 2ea15bd..3f7eeb8 100644
--- a/packages/SystemUI/src/com/android/systemui/qs/customize/QSCustomizer.java
+++ b/packages/SystemUI/src/com/android/systemui/qs/customize/QSCustomizer.java
@@ -26,6 +26,7 @@
import androidx.recyclerview.widget.GridLayoutManager;
import androidx.recyclerview.widget.RecyclerView;
import android.util.AttributeSet;
+import android.util.Log;
import android.util.TypedValue;
import android.view.ContextThemeWrapper;
import android.view.LayoutInflater;
@@ -63,6 +64,7 @@
private static final int MENU_RESET = Menu.FIRST;
private static final String EXTRA_QS_CUSTOMIZING = "qs_customizing";
+ private static final String TAG = "QSCustomizer";
private final QSDetailClipper mClipper;
private final LightBarController mLightBarController;
@@ -94,7 +96,7 @@
mToolbar.setNavigationOnClickListener(new OnClickListener() {
@Override
public void onClick(View v) {
- hide((int) v.getX() + v.getWidth() / 2, (int) v.getY() + v.getHeight() / 2);
+ hide();
}
});
mToolbar.setOnMenuItemClickListener(this);
@@ -154,16 +156,20 @@
mQs = qs;
}
+ /** Animate and show QSCustomizer panel.
+ * @param x,y Location on screen of {@code edit} button to determine center of animation.
+ */
public void show(int x, int y) {
if (!isShown) {
- mX = x;
- mY = y;
+ int containerLocation[] = findViewById(R.id.customize_container).getLocationOnScreen();
+ mX = x - containerLocation[0];
+ mY = y - containerLocation[1];
MetricsLogger.visible(getContext(), MetricsProto.MetricsEvent.QS_EDIT);
isShown = true;
mOpening = true;
setTileSpecs();
setVisibility(View.VISIBLE);
- mClipper.animateCircularClip(x, y, true, mExpandAnimationListener);
+ mClipper.animateCircularClip(mX, mY, true, mExpandAnimationListener);
queryTiles();
mNotifQsContainer.setCustomizerAnimating(true);
mNotifQsContainer.setCustomizerShowing(true);
@@ -192,7 +198,7 @@
mTileQueryHelper.queryTiles(mHost);
}
- public void hide(int x, int y) {
+ public void hide() {
if (isShown) {
MetricsLogger.hidden(getContext(), MetricsProto.MetricsEvent.QS_EDIT);
isShown = false;
@@ -278,16 +284,18 @@
});
}
}
-
+ /** @param x,y Location on screen of animation center.
+ */
public void setEditLocation(int x, int y) {
- mX = x;
- mY = y;
+ int containerLocation[] = findViewById(R.id.customize_container).getLocationOnScreen();
+ mX = x - containerLocation[0];
+ mY = y - containerLocation[1];
}
private final Callback mKeyguardCallback = () -> {
if (!isAttachedToWindow()) return;
if (Dependency.get(KeyguardMonitor.class).isShowing() && !mOpening) {
- hide(0, 0);
+ hide();
}
};
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/AlertingNotificationManager.java b/packages/SystemUI/src/com/android/systemui/statusbar/AlertingNotificationManager.java
index c017104..35e9d55 100644
--- a/packages/SystemUI/src/com/android/systemui/statusbar/AlertingNotificationManager.java
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/AlertingNotificationManager.java
@@ -36,10 +36,20 @@
* remove notifications that appear on screen for a period of time and dismiss themselves at the
* appropriate time. These include heads up notifications and ambient pulses.
*/
-public abstract class AlertingNotificationManager {
+public abstract class AlertingNotificationManager implements NotificationLifetimeExtender {
private static final String TAG = "AlertNotifManager";
protected final Clock mClock = new Clock();
protected final ArrayMap<String, AlertEntry> mAlertEntries = new ArrayMap<>();
+
+ /**
+ * This is the list of entries that have already been removed from the
+ * NotificationManagerService side, but we keep it to prevent the UI from looking weird and
+ * will remove when possible. See {@link NotificationLifetimeExtender}
+ */
+ protected final ArraySet<NotificationData.Entry> mExtendedLifetimeAlertEntries =
+ new ArraySet<>();
+
+ protected NotificationSafeToRemoveCallback mNotificationLifetimeFinishedCallback;
protected int mMinimumDisplayTime;
protected int mAutoDismissNotificationDecay;
@VisibleForTesting
@@ -74,7 +84,7 @@
if (alertEntry == null) {
return true;
}
- if (releaseImmediately || alertEntry.wasShownLongEnough()) {
+ if (releaseImmediately || canRemoveImmediately(key)) {
removeAlertEntry(key);
} else {
alertEntry.removeAsSoonAsPossible();
@@ -191,6 +201,12 @@
onAlertEntryRemoved(alertEntry);
entry.row.sendAccessibilityEvent(AccessibilityEvent.TYPE_WINDOW_CONTENT_CHANGED);
alertEntry.reset();
+ if (mExtendedLifetimeAlertEntries.contains(entry)) {
+ if (mNotificationLifetimeFinishedCallback != null) {
+ mNotificationLifetimeFinishedCallback.onSafeToRemove(key);
+ }
+ mExtendedLifetimeAlertEntries.remove(entry);
+ }
}
/**
@@ -207,6 +223,40 @@
return new AlertEntry();
}
+ /**
+ * Whether or not the alert can be removed currently. If it hasn't been on screen long enough
+ * it should not be removed unless forced
+ * @param key the key to check if removable
+ * @return true if the alert entry can be removed
+ */
+ protected boolean canRemoveImmediately(String key) {
+ AlertEntry alertEntry = mAlertEntries.get(key);
+ return alertEntry == null || alertEntry.wasShownLongEnough();
+ }
+
+ ///////////////////////////////////////////////////////////////////////////////////////////////
+ // NotificationLifetimeExtender Methods
+
+ @Override
+ public void setCallback(NotificationSafeToRemoveCallback callback) {
+ mNotificationLifetimeFinishedCallback = callback;
+ }
+
+ @Override
+ public boolean shouldExtendLifetime(NotificationData.Entry entry) {
+ return !canRemoveImmediately(entry.key);
+ }
+
+ @Override
+ public void setShouldExtendLifetime(NotificationData.Entry entry, boolean shouldExtend) {
+ if (shouldExtend) {
+ mExtendedLifetimeAlertEntries.add(entry);
+ } else {
+ mExtendedLifetimeAlertEntries.remove(entry);
+ }
+ }
+ ///////////////////////////////////////////////////////////////////////////////////////////////
+
protected class AlertEntry implements Comparable<AlertEntry> {
@Nullable public NotificationData.Entry mEntry;
public long mPostTime;
@@ -214,11 +264,11 @@
@Nullable protected Runnable mRemoveAlertRunnable;
- public void setEntry(@Nullable final NotificationData.Entry entry) {
+ public void setEntry(@NonNull final NotificationData.Entry entry) {
setEntry(entry, () -> removeAlertEntry(entry.key));
}
- public void setEntry(@Nullable final NotificationData.Entry entry,
+ public void setEntry(@NonNull final NotificationData.Entry entry,
@Nullable Runnable removeAlertRunnable) {
mEntry = entry;
mRemoveAlertRunnable = removeAlertRunnable;
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/NotificationLifetimeExtender.java b/packages/SystemUI/src/com/android/systemui/statusbar/NotificationLifetimeExtender.java
new file mode 100644
index 0000000..42e380f
--- /dev/null
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/NotificationLifetimeExtender.java
@@ -0,0 +1,53 @@
+package com.android.systemui.statusbar;
+
+import com.android.systemui.statusbar.notification.NotificationData;
+
+import androidx.annotation.NonNull;
+
+/**
+ * Interface for anything that may need to keep notifications managed even after
+ * {@link NotificationListener} removes it. The lifetime extender is in charge of performing the
+ * callback when the notification is then safe to remove.
+ */
+public interface NotificationLifetimeExtender {
+
+ /**
+ * Set the handler to callback to when the notification is safe to remove.
+ *
+ * @param callback the handler to callback
+ */
+ void setCallback(@NonNull NotificationSafeToRemoveCallback callback);
+
+ /**
+ * Determines whether or not the extender needs the notification kept after removal.
+ *
+ * @param entry the entry containing the notification to check
+ * @return true if the notification lifetime should be extended
+ */
+ boolean shouldExtendLifetime(@NonNull NotificationData.Entry entry);
+
+ /**
+ * Sets whether or not the lifetime should be extended. In practice, if shouldExtend is
+ * true, this is where the extender starts managing the entry internally and is now
+ * responsible for calling {@link NotificationSafeToRemoveCallback#onSafeToRemove(String)} when
+ * the entry is safe to remove. If shouldExtend is false, the extender no longer needs to
+ * worry about it (either because we will be removing it anyway or the entry is no longer
+ * removed due to an update).
+ *
+ * @param entry the entry to mark as having an extended lifetime
+ * @param shouldExtend true if the extender should manage the entry now, false otherwise
+ */
+ void setShouldExtendLifetime(@NonNull NotificationData.Entry entry, boolean shouldExtend);
+
+ /**
+ * The callback for when the notification is now safe to remove (i.e. its lifetime has ended).
+ */
+ interface NotificationSafeToRemoveCallback {
+ /**
+ * Called when the lifetime extender determines it's safe to remove.
+ *
+ * @param key key of the entry that is now safe to remove
+ */
+ void onSafeToRemove(String key);
+ }
+}
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/NotificationListener.java b/packages/SystemUI/src/com/android/systemui/statusbar/NotificationListener.java
index 9b375df..cfa09bc 100644
--- a/packages/SystemUI/src/com/android/systemui/statusbar/NotificationListener.java
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/NotificationListener.java
@@ -76,7 +76,6 @@
mPresenter.getHandler().post(() -> {
processForRemoteInput(sbn.getNotification(), mContext);
String key = sbn.getKey();
- mEntryManager.removeKeyKeptForRemoteInput(key);
boolean isUpdate =
mEntryManager.getNotificationData().get(key) != null;
// In case we don't allow child notifications, we ignore children of
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/NotificationRemoteInputManager.java b/packages/SystemUI/src/com/android/systemui/statusbar/NotificationRemoteInputManager.java
index 929713c..1a3e812 100644
--- a/packages/SystemUI/src/com/android/systemui/statusbar/NotificationRemoteInputManager.java
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/NotificationRemoteInputManager.java
@@ -17,8 +17,10 @@
import static android.app.WindowConfiguration.WINDOWING_MODE_FULLSCREEN_OR_SPLIT_SCREEN_SECONDARY;
+import android.annotation.NonNull;
import android.app.ActivityManager;
import android.app.ActivityOptions;
+import android.app.Notification;
import android.app.PendingIntent;
import android.app.RemoteInput;
import android.content.Context;
@@ -29,6 +31,7 @@
import android.os.SystemProperties;
import android.os.UserManager;
import android.service.notification.StatusBarNotification;
+import android.text.TextUtils;
import android.util.ArraySet;
import android.util.Log;
import android.view.MotionEvent;
@@ -50,6 +53,7 @@
import java.io.FileDescriptor;
import java.io.PrintWriter;
+import java.util.ArrayList;
import java.util.Set;
/**
@@ -61,10 +65,10 @@
public class NotificationRemoteInputManager implements Dumpable {
public static final boolean ENABLE_REMOTE_INPUT =
SystemProperties.getBoolean("debug.enable_remote_input", true);
- public static final boolean FORCE_REMOTE_INPUT_HISTORY =
+ public static boolean FORCE_REMOTE_INPUT_HISTORY =
SystemProperties.getBoolean("debug.force_remoteinput_history", true);
private static final boolean DEBUG = false;
- private static final String TAG = "NotificationRemoteInputManager";
+ private static final String TAG = "NotifRemoteInputManager";
/**
* How long to wait before auto-dismissing a notification that was kept for remote input, and
@@ -74,12 +78,25 @@
*/
private static final int REMOTE_INPUT_KEPT_ENTRY_AUTO_CANCEL_DELAY = 200;
- protected final ArraySet<NotificationData.Entry> mRemoteInputEntriesToRemoveOnCollapse =
+ /**
+ * Notifications that are already removed but are kept around because we want to show the
+ * remote input history. See {@link RemoteInputHistoryExtender} and
+ * {@link SmartReplyHistoryExtender}.
+ */
+ protected final ArraySet<String> mKeysKeptForRemoteInputHistory = new ArraySet<>();
+
+ /**
+ * Notifications that are already removed but are kept around because the remote input is
+ * actively being used (i.e. user is typing in it). See {@link RemoteInputActiveExtender}.
+ */
+ protected final ArraySet<NotificationData.Entry> mEntriesKeptForRemoteInputActive =
new ArraySet<>();
// Dependencies:
protected final NotificationLockscreenUserManager mLockscreenUserManager =
Dependency.get(NotificationLockscreenUserManager.class);
+ protected final SmartReplyController mSmartReplyController =
+ Dependency.get(SmartReplyController.class);
protected final Context mContext;
private final UserManager mUserManager;
@@ -87,8 +104,11 @@
protected RemoteInputController mRemoteInputController;
protected NotificationPresenter mPresenter;
protected NotificationEntryManager mEntryManager;
+ protected NotificationLifetimeExtender.NotificationSafeToRemoveCallback
+ mNotificationLifetimeFinishedCallback;
protected IStatusBarService mBarService;
protected Callback mCallback;
+ protected final ArrayList<NotificationLifetimeExtender> mLifetimeExtenders = new ArrayList<>();
private final RemoteViews.OnClickHandler mOnClickHandler = new RemoteViews.OnClickHandler() {
@@ -276,6 +296,7 @@
mBarService = IStatusBarService.Stub.asInterface(
ServiceManager.getService(Context.STATUS_BAR_SERVICE));
mUserManager = (UserManager) mContext.getSystemService(Context.USER_SERVICE);
+ addLifetimeExtenders();
}
public void setUpWithPresenter(NotificationPresenter presenter,
@@ -290,16 +311,16 @@
@Override
public void onRemoteInputSent(NotificationData.Entry entry) {
if (FORCE_REMOTE_INPUT_HISTORY
- && mEntryManager.isNotificationKeptForRemoteInput(entry.key)) {
- mEntryManager.removeNotification(entry.key, null);
- } else if (mRemoteInputEntriesToRemoveOnCollapse.contains(entry)) {
+ && isNotificationKeptForRemoteInputHistory(entry.key)) {
+ mNotificationLifetimeFinishedCallback.onSafeToRemove(entry.key);
+ } else if (mEntriesKeptForRemoteInputActive.contains(entry)) {
// We're currently holding onto this notification, but from the apps point of
// view it is already canceled, so we'll need to cancel it on the apps behalf
// after sending - unless the app posts an update in the mean time, so wait a
// bit.
mPresenter.getHandler().postDelayed(() -> {
- if (mRemoteInputEntriesToRemoveOnCollapse.remove(entry)) {
- mEntryManager.removeNotification(entry.key, null);
+ if (mEntriesKeptForRemoteInputActive.remove(entry)) {
+ mNotificationLifetimeFinishedCallback.onSafeToRemove(entry.key);
}
}, REMOTE_INPUT_KEPT_ENTRY_AUTO_CANCEL_DELAY);
}
@@ -310,45 +331,74 @@
}
}
});
+ mSmartReplyController.setCallback((entry, reply) -> {
+ StatusBarNotification newSbn =
+ rebuildNotificationWithRemoteInput(entry, reply, true /* showSpinner */);
+ mEntryManager.updateNotification(newSbn, null /* ranking */);
+ });
+ }
+ /**
+ * Adds all the notification lifetime extenders. Each extender represents a reason for the
+ * NotificationRemoteInputManager to keep a notification lifetime extended.
+ */
+ protected void addLifetimeExtenders() {
+ mLifetimeExtenders.add(new RemoteInputHistoryExtender());
+ mLifetimeExtenders.add(new SmartReplyHistoryExtender());
+ mLifetimeExtenders.add(new RemoteInputActiveExtender());
+ }
+
+ public ArrayList<NotificationLifetimeExtender> getLifetimeExtenders() {
+ return mLifetimeExtenders;
}
public RemoteInputController getController() {
return mRemoteInputController;
}
- public void onUpdateNotification(NotificationData.Entry entry) {
- mRemoteInputEntriesToRemoveOnCollapse.remove(entry);
- }
-
- /**
- * Returns true if NotificationRemoteInputManager wants to keep this notification around.
- *
- * @param entry notification being removed
- */
- public boolean onRemoveNotification(NotificationData.Entry entry) {
- if (entry != null && mRemoteInputController.isRemoteInputActive(entry)
- && (entry.row != null && !entry.row.isDismissed())) {
- mRemoteInputEntriesToRemoveOnCollapse.add(entry);
- return true;
- }
- return false;
- }
-
public void onPerformRemoveNotification(StatusBarNotification n,
NotificationData.Entry entry) {
+ if (mKeysKeptForRemoteInputHistory.contains(n.getKey())) {
+ mKeysKeptForRemoteInputHistory.remove(n.getKey());
+ }
if (mRemoteInputController.isRemoteInputActive(entry)) {
mRemoteInputController.removeRemoteInput(entry, null);
}
}
- public void removeRemoteInputEntriesKeptUntilCollapsed() {
- for (int i = 0; i < mRemoteInputEntriesToRemoveOnCollapse.size(); i++) {
- NotificationData.Entry entry = mRemoteInputEntriesToRemoveOnCollapse.valueAt(i);
+ public void onPanelCollapsed() {
+ for (int i = 0; i < mEntriesKeptForRemoteInputActive.size(); i++) {
+ NotificationData.Entry entry = mEntriesKeptForRemoteInputActive.valueAt(i);
mRemoteInputController.removeRemoteInput(entry, null);
- mEntryManager.removeNotification(entry.key, mEntryManager.getLatestRankingMap());
+ if (mNotificationLifetimeFinishedCallback != null) {
+ mNotificationLifetimeFinishedCallback.onSafeToRemove(entry.key);
+ }
}
- mRemoteInputEntriesToRemoveOnCollapse.clear();
+ mEntriesKeptForRemoteInputActive.clear();
+ }
+
+ public boolean isNotificationKeptForRemoteInputHistory(String key) {
+ return mKeysKeptForRemoteInputHistory.contains(key);
+ }
+
+ public boolean shouldKeepForRemoteInputHistory(NotificationData.Entry entry) {
+ if (entry.row == null || entry.row.isDismissed()) {
+ return false;
+ }
+ if (!FORCE_REMOTE_INPUT_HISTORY) {
+ return false;
+ }
+ return (mRemoteInputController.isSpinning(entry.key) || entry.hasJustSentRemoteInput());
+ }
+
+ public boolean shouldKeepForSmartReplyHistory(NotificationData.Entry entry) {
+ if (entry.row == null || entry.row.isDismissed()) {
+ return false;
+ }
+ if (!FORCE_REMOTE_INPUT_HISTORY) {
+ return false;
+ }
+ return mSmartReplyController.isSendingSmartReply(entry.key);
}
public void checkRemoteInputOutside(MotionEvent event) {
@@ -359,11 +409,63 @@
}
}
+ @VisibleForTesting
+ StatusBarNotification rebuildNotificationForCanceledSmartReplies(
+ NotificationData.Entry entry) {
+ return rebuildNotificationWithRemoteInput(entry, null /* remoteInputTest */,
+ false /* showSpinner */);
+ }
+
+ @VisibleForTesting
+ StatusBarNotification rebuildNotificationWithRemoteInput(NotificationData.Entry entry,
+ CharSequence remoteInputText, boolean showSpinner) {
+ StatusBarNotification sbn = entry.notification;
+
+ Notification.Builder b = Notification.Builder
+ .recoverBuilder(mContext, sbn.getNotification().clone());
+ if (remoteInputText != null) {
+ CharSequence[] oldHistory = sbn.getNotification().extras
+ .getCharSequenceArray(Notification.EXTRA_REMOTE_INPUT_HISTORY);
+ CharSequence[] newHistory;
+ if (oldHistory == null) {
+ newHistory = new CharSequence[1];
+ } else {
+ newHistory = new CharSequence[oldHistory.length + 1];
+ System.arraycopy(oldHistory, 0, newHistory, 1, oldHistory.length);
+ }
+ newHistory[0] = String.valueOf(remoteInputText);
+ b.setRemoteInputHistory(newHistory);
+ }
+ b.setShowRemoteInputSpinner(showSpinner);
+ b.setHideSmartReplies(true);
+
+ Notification newNotification = b.build();
+
+ // Undo any compatibility view inflation
+ newNotification.contentView = sbn.getNotification().contentView;
+ newNotification.bigContentView = sbn.getNotification().bigContentView;
+ newNotification.headsUpContentView = sbn.getNotification().headsUpContentView;
+
+ return new StatusBarNotification(
+ sbn.getPackageName(),
+ sbn.getOpPkg(),
+ sbn.getId(),
+ sbn.getTag(),
+ sbn.getUid(),
+ sbn.getInitialPid(),
+ newNotification,
+ sbn.getUser(),
+ sbn.getOverrideGroupKey(),
+ sbn.getPostTime());
+ }
+
@Override
public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
pw.println("NotificationRemoteInputManager state:");
- pw.print(" mRemoteInputEntriesToRemoveOnCollapse: ");
- pw.println(mRemoteInputEntriesToRemoveOnCollapse);
+ pw.print(" mKeysKeptForRemoteInputHistory: ");
+ pw.println(mKeysKeptForRemoteInputHistory);
+ pw.print(" mEntriesKeptForRemoteInputActive: ");
+ pw.println(mEntriesKeptForRemoteInputActive);
}
public void bindRow(ExpandableNotificationRow row) {
@@ -372,8 +474,133 @@
}
@VisibleForTesting
- public Set<NotificationData.Entry> getRemoteInputEntriesToRemoveOnCollapse() {
- return mRemoteInputEntriesToRemoveOnCollapse;
+ public Set<NotificationData.Entry> getEntriesKeptForRemoteInputActive() {
+ return mEntriesKeptForRemoteInputActive;
+ }
+
+ /**
+ * NotificationRemoteInputManager has multiple reasons to keep notification lifetime extended
+ * so we implement multiple NotificationLifetimeExtenders
+ */
+ protected abstract class RemoteInputExtender implements NotificationLifetimeExtender {
+ @Override
+ public void setCallback(NotificationSafeToRemoveCallback callback) {
+ if (mNotificationLifetimeFinishedCallback == null) {
+ mNotificationLifetimeFinishedCallback = callback;
+ }
+ }
+ }
+
+ /**
+ * Notification is kept alive as it was cancelled in response to a remote input interaction.
+ * This allows us to show what you replied and allows you to continue typing into it.
+ */
+ protected class RemoteInputHistoryExtender extends RemoteInputExtender {
+ @Override
+ public boolean shouldExtendLifetime(@NonNull NotificationData.Entry entry) {
+ return shouldKeepForRemoteInputHistory(entry);
+ }
+
+ @Override
+ public void setShouldExtendLifetime(NotificationData.Entry entry,
+ boolean shouldExtend) {
+ if (shouldExtend) {
+ CharSequence remoteInputText = entry.remoteInputText;
+ if (TextUtils.isEmpty(remoteInputText)) {
+ remoteInputText = entry.remoteInputTextWhenReset;
+ }
+ StatusBarNotification newSbn = rebuildNotificationWithRemoteInput(entry,
+ remoteInputText, false /* showSpinner */);
+ entry.onRemoteInputInserted();
+
+ if (newSbn == null) {
+ return;
+ }
+
+ mEntryManager.updateNotification(newSbn, null);
+
+ // Ensure the entry hasn't already been removed. This can happen if there is an
+ // inflation exception while updating the remote history
+ if (entry.row == null || entry.row.isRemoved()) {
+ return;
+ }
+
+ if (Log.isLoggable(TAG, Log.DEBUG)) {
+ Log.d(TAG, "Keeping notification around after sending remote input "
+ + entry.key);
+ }
+
+ mKeysKeptForRemoteInputHistory.add(entry.key);
+ } else {
+ mKeysKeptForRemoteInputHistory.remove(entry.key);
+ }
+ }
+ }
+
+ /**
+ * Notification is kept alive for smart reply history. Similar to REMOTE_INPUT_HISTORY but with
+ * {@link SmartReplyController} specific logic
+ */
+ protected class SmartReplyHistoryExtender extends RemoteInputExtender {
+ @Override
+ public boolean shouldExtendLifetime(@NonNull NotificationData.Entry entry) {
+ return shouldKeepForSmartReplyHistory(entry);
+ }
+
+ @Override
+ public void setShouldExtendLifetime(NotificationData.Entry entry,
+ boolean shouldExtend) {
+ if (shouldExtend) {
+ StatusBarNotification newSbn = rebuildNotificationForCanceledSmartReplies(entry);
+
+ if (newSbn == null) {
+ return;
+ }
+
+ mEntryManager.updateNotification(newSbn, null);
+
+ if (entry.row == null || entry.row.isRemoved()) {
+ return;
+ }
+
+ if (Log.isLoggable(TAG, Log.DEBUG)) {
+ Log.d(TAG, "Keeping notification around after sending smart reply "
+ + entry.key);
+ }
+
+ mKeysKeptForRemoteInputHistory.add(entry.key);
+ } else {
+ mKeysKeptForRemoteInputHistory.remove(entry.key);
+ mSmartReplyController.stopSending(entry);
+ }
+ }
+ }
+
+ /**
+ * Notification is kept alive because the user is still using the remote input
+ */
+ protected class RemoteInputActiveExtender extends RemoteInputExtender {
+ @Override
+ public boolean shouldExtendLifetime(@NonNull NotificationData.Entry entry) {
+ if (entry.row == null || entry.row.isDismissed()) {
+ return false;
+ }
+ return mRemoteInputController.isRemoteInputActive(entry);
+ }
+
+ @Override
+ public void setShouldExtendLifetime(NotificationData.Entry entry,
+ boolean shouldExtend) {
+ if (shouldExtend) {
+ if (Log.isLoggable(TAG, Log.DEBUG)) {
+ Log.d(TAG, "Keeping notification around while remote input active "
+ + entry.key);
+ }
+ mEntriesKeptForRemoteInputActive.add(entry);
+ } else {
+ mEntriesKeptForRemoteInputActive.remove(entry);
+ }
+ }
}
/**
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/SmartReplyController.java b/packages/SystemUI/src/com/android/systemui/statusbar/SmartReplyController.java
index e43c9e5..fb888dd 100644
--- a/packages/SystemUI/src/com/android/systemui/statusbar/SmartReplyController.java
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/SmartReplyController.java
@@ -33,20 +33,19 @@
public class SmartReplyController {
private IStatusBarService mBarService;
private Set<String> mSendingKeys = new ArraySet<>();
+ private Callback mCallback;
public SmartReplyController() {
mBarService = Dependency.get(IStatusBarService.class);
}
- public void smartReplySent(NotificationData.Entry entry, int replyIndex, CharSequence reply) {
- NotificationEntryManager notificationEntryManager
- = Dependency.get(NotificationEntryManager.class);
- StatusBarNotification newSbn =
- notificationEntryManager.rebuildNotificationWithRemoteInput(entry, reply,
- true /* showSpinner */);
- notificationEntryManager.updateNotification(newSbn, null /* ranking */);
- mSendingKeys.add(entry.key);
+ public void setCallback(Callback callback) {
+ mCallback = callback;
+ }
+ public void smartReplySent(NotificationData.Entry entry, int replyIndex, CharSequence reply) {
+ mCallback.onSmartReplySent(entry, reply);
+ mSendingKeys.add(entry.key);
try {
mBarService.onNotificationSmartReplySent(entry.notification.getKey(),
replyIndex);
@@ -77,4 +76,17 @@
mSendingKeys.remove(entry.notification.getKey());
}
}
+
+ /**
+ * Callback for any class that needs to do something in response to a smart reply being sent.
+ */
+ public interface Callback {
+ /**
+ * A smart reply has just been sent for a notification
+ *
+ * @param entry the entry for the notification
+ * @param reply the reply that was sent
+ */
+ void onSmartReplySent(NotificationData.Entry entry, CharSequence reply);
+ }
}
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/notification/NotificationEntryManager.java b/packages/SystemUI/src/com/android/systemui/statusbar/notification/NotificationEntryManager.java
index b655a6b..906bbb9 100644
--- a/packages/SystemUI/src/com/android/systemui/statusbar/notification/NotificationEntryManager.java
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/notification/NotificationEntryManager.java
@@ -37,7 +37,6 @@
import android.service.notification.NotificationListenerService;
import android.service.notification.NotificationStats;
import android.service.notification.StatusBarNotification;
-import android.text.TextUtils;
import android.util.ArrayMap;
import android.util.ArraySet;
import android.util.EventLog;
@@ -58,6 +57,7 @@
import com.android.systemui.R;
import com.android.systemui.UiOffloadThread;
import com.android.systemui.recents.misc.SystemServicesProxy;
+import com.android.systemui.statusbar.NotificationLifetimeExtender;
import com.android.systemui.statusbar.NotificationListener;
import com.android.systemui.statusbar.NotificationLockscreenUserManager;
import com.android.systemui.statusbar.NotificationMediaManager;
@@ -65,7 +65,6 @@
import com.android.systemui.statusbar.NotificationRemoteInputManager;
import com.android.systemui.statusbar.NotificationUiAdjustment;
import com.android.systemui.statusbar.NotificationUpdateHandler;
-import com.android.systemui.statusbar.SmartReplyController;
import com.android.systemui.statusbar.notification.row.NotificationInflater;
import com.android.systemui.statusbar.notification.row.RowInflaterTask;
import com.android.systemui.statusbar.notification.row.ExpandableNotificationRow;
@@ -100,8 +99,6 @@
protected final Context mContext;
protected final HashMap<String, NotificationData.Entry> mPendingNotifications = new HashMap<>();
protected final NotificationClicker mNotificationClicker = new NotificationClicker();
- protected final ArraySet<NotificationData.Entry> mHeadsUpEntriesToRemoveOnSwitch =
- new ArraySet<>();
// Dependencies:
protected final NotificationLockscreenUserManager mLockscreenUserManager =
@@ -124,8 +121,6 @@
Dependency.get(ForegroundServiceController.class);
protected final NotificationListener mNotificationListener =
Dependency.get(NotificationListener.class);
- private final SmartReplyController mSmartReplyController =
- Dependency.get(SmartReplyController.class);
protected IStatusBarService mBarService;
protected NotificationPresenter mPresenter;
@@ -139,13 +134,9 @@
protected boolean mUseHeadsUp = false;
protected boolean mDisableNotificationAlerts;
protected NotificationListContainer mListContainer;
+ protected final ArrayList<NotificationLifetimeExtender> mNotificationLifetimeExtenders
+ = new ArrayList<>();
private ExpandableNotificationRow.OnAppOpsClickListener mOnAppOpsClickListener;
- /**
- * Notifications with keys in this set are not actually around anymore. We kept them around
- * when they were canceled in response to a remote input interaction. This allows us to show
- * what you replied and allows you to continue typing into it.
- */
- private final ArraySet<String> mKeysKeptForRemoteInput = new ArraySet<>();
private final class NotificationClicker implements View.OnClickListener {
@@ -198,14 +189,6 @@
}
};
- public NotificationListenerService.RankingMap getLatestRankingMap() {
- return mLatestRankingMap;
- }
-
- public void setLatestRankingMap(NotificationListenerService.RankingMap latestRankingMap) {
- mLatestRankingMap = latestRankingMap;
- }
-
public void setDisableNotificationAlerts(boolean disableNotificationAlerts) {
mDisableNotificationAlerts = disableNotificationAlerts;
mHeadsUpObserver.onChange(true);
@@ -215,18 +198,6 @@
mDeviceProvisionedController.removeCallback(mDeviceProvisionedListener);
}
- public void onHeadsUpStateChanged(NotificationData.Entry entry, boolean isHeadsUp) {
- if (!isHeadsUp && mHeadsUpEntriesToRemoveOnSwitch.contains(entry)) {
- removeNotification(entry.key, getLatestRankingMap());
- mHeadsUpEntriesToRemoveOnSwitch.remove(entry);
- if (mHeadsUpEntriesToRemoveOnSwitch.isEmpty()) {
- setLatestRankingMap(null);
- }
- } else {
- updateNotificationRanking(null);
- }
- }
-
@Override
public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
pw.println("NotificationEntryManager state:");
@@ -240,8 +211,6 @@
}
pw.print(" mUseHeadsUp=");
pw.println(mUseHeadsUp);
- pw.print(" mKeysKeptForRemoteInput: ");
- pw.println(mKeysKeptForRemoteInput);
}
public NotificationEntryManager(Context context) {
@@ -294,6 +263,14 @@
mHeadsUpObserver);
}
+ mNotificationLifetimeExtenders.add(mHeadsUpManager);
+ mNotificationLifetimeExtenders.add(mGutsManager);
+ mNotificationLifetimeExtenders.addAll(mRemoteInputManager.getLifetimeExtenders());
+
+ for (NotificationLifetimeExtender extender : mNotificationLifetimeExtenders) {
+ extender.setCallback(key -> removeNotification(key, mLatestRankingMap));
+ }
+
mDeviceProvisionedController.addCallback(mDeviceProvisionedListener);
mHeadsUpObserver.onChange(true); // set up
@@ -397,11 +374,6 @@
true);
NotificationData.Entry entry = mNotificationData.get(n.getKey());
- if (FORCE_REMOTE_INPUT_HISTORY
- && mKeysKeptForRemoteInput.contains(n.getKey())) {
- mKeysKeptForRemoteInput.remove(n.getKey());
- }
-
mRemoteInputManager.onPerformRemoveNotification(n, entry);
final String pkg = n.getPackageName();
final String tag = n.getTag();
@@ -433,7 +405,7 @@
* WARNING: this will call back into us. Don't hold any locks.
*/
void handleNotificationError(StatusBarNotification n, String message) {
- removeNotification(n.getKey(), null);
+ removeNotificationInternal(n.getKey(), null, true /* forceRemove */);
try {
mBarService.onNotificationError(n.getPackageName(), n.getTag(), n.getId(), n.getUid(),
n.getInitialPid(), message, n.getUserId());
@@ -487,7 +459,11 @@
@Override
public void removeNotification(String key, NotificationListenerService.RankingMap ranking) {
- boolean deferRemoval = false;
+ removeNotificationInternal(key, ranking, false /* forceRemove */);
+ }
+
+ private void removeNotificationInternal(String key,
+ @Nullable NotificationListenerService.RankingMap ranking, boolean forceRemove) {
abortExistingInflation(key);
if (mHeadsUpManager.contains(key)) {
// A cancel() in response to a remote input shouldn't be delayed, as it makes the
@@ -497,154 +473,53 @@
boolean ignoreEarliestRemovalTime = mRemoteInputManager.getController().isSpinning(key)
&& !FORCE_REMOTE_INPUT_HISTORY
|| !mVisualStabilityManager.isReorderingAllowed();
- deferRemoval = !mHeadsUpManager.removeNotification(key, ignoreEarliestRemovalTime);
+
+ // Attempt to remove notification.
+ mHeadsUpManager.removeNotification(key, ignoreEarliestRemovalTime);
}
- mMediaManager.onNotificationRemoved(key);
NotificationData.Entry entry = mNotificationData.get(key);
- if (FORCE_REMOTE_INPUT_HISTORY
- && shouldKeepForRemoteInput(entry)
- && entry.row != null && !entry.row.isDismissed()) {
- CharSequence remoteInputText = entry.remoteInputText;
- if (TextUtils.isEmpty(remoteInputText)) {
- remoteInputText = entry.remoteInputTextWhenReset;
- }
- StatusBarNotification newSbn = rebuildNotificationWithRemoteInput(entry,
- remoteInputText, false /* showSpinner */);
- boolean updated = false;
- entry.onRemoteInputInserted();
- try {
- updateNotificationInternal(newSbn, null);
- updated = true;
- } catch (InflationException e) {
- deferRemoval = false;
- }
- if (updated) {
- Log.w(TAG, "Keeping notification around after sending remote input "+ entry.key);
- addKeyKeptForRemoteInput(entry.key);
- return;
- }
- }
- if (FORCE_REMOTE_INPUT_HISTORY
- && shouldKeepForSmartReply(entry)
- && entry.row != null && !entry.row.isDismissed()) {
- // Turn off the spinner and hide buttons when an app cancels the notification.
- StatusBarNotification newSbn = rebuildNotificationForCanceledSmartReplies(entry);
- boolean updated = false;
- try {
- updateNotificationInternal(newSbn, null);
- updated = true;
- } catch (InflationException e) {
- // Ignore just don't keep the notification around.
- }
- // Treat the reply as longer sending.
- mSmartReplyController.stopSending(entry);
- if (updated) {
- Log.w(TAG, "Keeping notification around after sending smart reply " + entry.key);
- addKeyKeptForRemoteInput(entry.key);
- return;
- }
- }
-
- // Actually removing notification so smart reply controller can forget about it.
- mSmartReplyController.stopSending(entry);
-
- if (deferRemoval) {
- mLatestRankingMap = ranking;
- mHeadsUpEntriesToRemoveOnSwitch.add(mHeadsUpManager.getEntry(key));
+ if (entry == null) {
+ mCallback.onNotificationRemoved(key, null /* old */);
return;
}
- if (mRemoteInputManager.onRemoveNotification(entry)) {
- mLatestRankingMap = ranking;
- return;
+ // If a manager needs to keep the notification around for whatever reason, we return early
+ // and keep the notification
+ if (!forceRemove) {
+ for (NotificationLifetimeExtender extender : mNotificationLifetimeExtenders) {
+ if (extender.shouldExtendLifetime(entry)) {
+ mLatestRankingMap = ranking;
+ extender.setShouldExtendLifetime(entry, true /* shouldExtend */);
+ return;
+ }
+ }
}
- if (entry != null && mGutsManager.getExposedGuts() != null
- && mGutsManager.getExposedGuts() == entry.row.getGuts()
- && entry.row.getGuts() != null && !entry.row.getGuts().isLeavebehind()) {
- Log.w(TAG, "Keeping notification because it's showing guts. " + key);
- mLatestRankingMap = ranking;
- mGutsManager.setKeyToRemoveOnGutsClosed(key);
- return;
+ // At this point, we are guaranteed the notification will be removed
+
+ // Ensure any managers keeping the lifetime extended stop managing the entry
+ for (NotificationLifetimeExtender extender: mNotificationLifetimeExtenders) {
+ extender.setShouldExtendLifetime(entry, false /* shouldExtend */);
}
- if (entry != null) {
- mForegroundServiceController.removeNotification(entry.notification);
- }
+ mMediaManager.onNotificationRemoved(key);
+ mForegroundServiceController.removeNotification(entry.notification);
- if (entry != null && entry.row != null) {
+ if (entry.row != null) {
entry.row.setRemoved();
mListContainer.cleanUpViewState(entry.row);
}
+
// Let's remove the children if this was a summary
handleGroupSummaryRemoved(key);
+
StatusBarNotification old = removeNotificationViews(key, ranking);
mCallback.onNotificationRemoved(key, old);
}
- public StatusBarNotification rebuildNotificationWithRemoteInput(NotificationData.Entry entry,
- CharSequence remoteInputText, boolean showSpinner) {
- StatusBarNotification sbn = entry.notification;
-
- Notification.Builder b = Notification.Builder
- .recoverBuilder(mContext, sbn.getNotification().clone());
- if (remoteInputText != null) {
- CharSequence[] oldHistory = sbn.getNotification().extras
- .getCharSequenceArray(Notification.EXTRA_REMOTE_INPUT_HISTORY);
- CharSequence[] newHistory;
- if (oldHistory == null) {
- newHistory = new CharSequence[1];
- } else {
- newHistory = new CharSequence[oldHistory.length + 1];
- System.arraycopy(oldHistory, 0, newHistory, 1, oldHistory.length);
- }
- newHistory[0] = String.valueOf(remoteInputText);
- b.setRemoteInputHistory(newHistory);
- }
- b.setShowRemoteInputSpinner(showSpinner);
- b.setHideSmartReplies(true);
-
- Notification newNotification = b.build();
-
- // Undo any compatibility view inflation
- newNotification.contentView = sbn.getNotification().contentView;
- newNotification.bigContentView = sbn.getNotification().bigContentView;
- newNotification.headsUpContentView = sbn.getNotification().headsUpContentView;
-
- StatusBarNotification newSbn = new StatusBarNotification(sbn.getPackageName(),
- sbn.getOpPkg(),
- sbn.getId(), sbn.getTag(), sbn.getUid(), sbn.getInitialPid(),
- newNotification, sbn.getUser(), sbn.getOverrideGroupKey(), sbn.getPostTime());
- return newSbn;
- }
-
- @VisibleForTesting
- StatusBarNotification rebuildNotificationForCanceledSmartReplies(
- NotificationData.Entry entry) {
- return rebuildNotificationWithRemoteInput(entry, null /* remoteInputTest */,
- false /* showSpinner */);
- }
-
- private boolean shouldKeepForSmartReply(NotificationData.Entry entry) {
- return entry != null && mSmartReplyController.isSendingSmartReply(entry.key);
- }
-
- private boolean shouldKeepForRemoteInput(NotificationData.Entry entry) {
- if (entry == null) {
- return false;
- }
- if (mRemoteInputManager.getController().isSpinning(entry.key)) {
- return true;
- }
- if (entry.hasJustSentRemoteInput()) {
- return true;
- }
- return false;
- }
-
private StatusBarNotification removeNotificationViews(String key,
NotificationListenerService.RankingMap ranking) {
NotificationData.Entry entry = mNotificationData.remove(key, ranking);
@@ -683,9 +558,9 @@
NotificationData.Entry childEntry = row.getEntry();
boolean isForeground = (row.getStatusBarNotification().getNotification().flags
& Notification.FLAG_FOREGROUND_SERVICE) != 0;
- boolean keepForReply = FORCE_REMOTE_INPUT_HISTORY
- && (shouldKeepForRemoteInput(childEntry)
- || shouldKeepForSmartReply(childEntry));
+ boolean keepForReply =
+ mRemoteInputManager.shouldKeepForRemoteInputHistory(childEntry)
+ || mRemoteInputManager.shouldKeepForSmartReplyHistory(childEntry);
if (isForeground || keepForReply) {
// the child is a foreground service notification which we can't remove or it's
// a child we're keeping around for reply!
@@ -868,13 +743,11 @@
if (entry == null) {
return;
}
- mHeadsUpEntriesToRemoveOnSwitch.remove(entry);
- mRemoteInputManager.onUpdateNotification(entry);
- mSmartReplyController.stopSending(entry);
- if (key.equals(mGutsManager.getKeyToRemoveOnGutsClosed())) {
- mGutsManager.setKeyToRemoveOnGutsClosed(null);
- Log.w(TAG, "Notification that was kept for guts was updated. " + key);
+ // Notification is updated so it is essentially re-added and thus alive again. Don't need
+ // to keep it's lifetime extended.
+ for (NotificationLifetimeExtender extender : mNotificationLifetimeExtenders) {
+ extender.setShouldExtendLifetime(entry, false /* shouldExtend */);
}
Notification n = notification.getNotification();
@@ -1080,20 +953,6 @@
return mHeadsUpManager.contains(key);
}
- public boolean isNotificationKeptForRemoteInput(String key) {
- return mKeysKeptForRemoteInput.contains(key);
- }
-
- public void removeKeyKeptForRemoteInput(String key) {
- mKeysKeptForRemoteInput.remove(key);
- }
-
- public void addKeyKeptForRemoteInput(String key) {
- if (FORCE_REMOTE_INPUT_HISTORY) {
- mKeysKeptForRemoteInput.add(key);
- }
- }
-
/**
* Callback for NotificationEntryManager.
*/
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/notification/row/NotificationGutsManager.java b/packages/SystemUI/src/com/android/systemui/statusbar/notification/row/NotificationGutsManager.java
index e635976..a096baa 100644
--- a/packages/SystemUI/src/com/android/systemui/statusbar/notification/row/NotificationGutsManager.java
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/notification/row/NotificationGutsManager.java
@@ -38,27 +38,27 @@
import android.view.View;
import android.view.accessibility.AccessibilityManager;
+import com.android.internal.annotations.VisibleForTesting;
import com.android.internal.logging.MetricsLogger;
import com.android.internal.logging.nano.MetricsProto;
import com.android.systemui.Dependency;
import com.android.systemui.Dumpable;
import com.android.systemui.plugins.statusbar.NotificationMenuRowPlugin;
+import com.android.systemui.statusbar.NotificationLifetimeExtender;
+import com.android.systemui.statusbar.notification.NotificationData;
import com.android.systemui.statusbar.NotificationLockscreenUserManager;
import com.android.systemui.statusbar.NotificationPresenter;
-import com.android.systemui.statusbar.notification.NotificationEntryManager;
import com.android.systemui.statusbar.notification.stack.NotificationListContainer;
import com.android.systemui.statusbar.phone.StatusBar;
import java.io.FileDescriptor;
import java.io.PrintWriter;
-import androidx.annotation.VisibleForTesting;
-
/**
* Handles various NotificationGuts related tasks, such as binding guts to a row, opening and
* closing guts, and keeping track of the currently exposed notification guts.
*/
-public class NotificationGutsManager implements Dumpable {
+public class NotificationGutsManager implements Dumpable, NotificationLifetimeExtender {
private static final String TAG = "NotificationGutsManager";
// Must match constant in Settings. Used to highlight preferences when linking to Settings.
@@ -75,12 +75,13 @@
// which notification is currently being longpress-examined by the user
private NotificationGuts mNotificationGutsExposed;
private NotificationMenuRowPlugin.MenuItem mGutsMenuItem;
- protected NotificationPresenter mPresenter;
- protected NotificationEntryManager mEntryManager;
+ private NotificationPresenter mPresenter;
+ private NotificationSafeToRemoveCallback mNotificationLifetimeFinishedCallback;
private NotificationListContainer mListContainer;
private NotificationInfo.CheckSaveListener mCheckSaveListener;
private OnSettingsClickListener mOnSettingsClickListener;
- private String mKeyToRemoveOnGutsClosed;
+ @VisibleForTesting
+ protected String mKeyToRemoveOnGutsClosed;
public NotificationGutsManager(Context context) {
mContext = context;
@@ -91,24 +92,15 @@
}
public void setUpWithPresenter(NotificationPresenter presenter,
- NotificationEntryManager entryManager, NotificationListContainer listContainer,
+ NotificationListContainer listContainer,
NotificationInfo.CheckSaveListener checkSaveListener,
OnSettingsClickListener onSettingsClickListener) {
mPresenter = presenter;
- mEntryManager = entryManager;
mListContainer = listContainer;
mCheckSaveListener = checkSaveListener;
mOnSettingsClickListener = onSettingsClickListener;
}
- public String getKeyToRemoveOnGutsClosed() {
- return mKeyToRemoveOnGutsClosed;
- }
-
- public void setKeyToRemoveOnGutsClosed(String keyToRemoveOnGutsClosed) {
- mKeyToRemoveOnGutsClosed = keyToRemoveOnGutsClosed;
- }
-
public void onDensityOrFontScaleChanged(ExpandableNotificationRow row) {
setExposedGuts(row.getGuts());
bindGuts(row);
@@ -171,7 +163,9 @@
String key = sbn.getKey();
if (key.equals(mKeyToRemoveOnGutsClosed)) {
mKeyToRemoveOnGutsClosed = null;
- mEntryManager.removeNotification(key, mEntryManager.getLatestRankingMap());
+ if (mNotificationLifetimeFinishedCallback != null) {
+ mNotificationLifetimeFinishedCallback.onSafeToRemove(key);
+ }
}
});
@@ -410,6 +404,37 @@
}
@Override
+ public void setCallback(NotificationSafeToRemoveCallback callback) {
+ mNotificationLifetimeFinishedCallback = callback;
+ }
+
+ @Override
+ public boolean shouldExtendLifetime(NotificationData.Entry entry) {
+ return entry != null
+ &&(mNotificationGutsExposed != null
+ && entry.row.getGuts() != null
+ && mNotificationGutsExposed == entry.row.getGuts()
+ && !mNotificationGutsExposed.isLeavebehind());
+ }
+
+ @Override
+ public void setShouldExtendLifetime(NotificationData.Entry entry, boolean shouldExtend) {
+ if (shouldExtend) {
+ mKeyToRemoveOnGutsClosed = entry.key;
+ if (Log.isLoggable(TAG, Log.DEBUG)) {
+ Log.d(TAG, "Keeping notification because it's showing guts. " + entry.key);
+ }
+ } else {
+ if (mKeyToRemoveOnGutsClosed != null && mKeyToRemoveOnGutsClosed.equals(entry.key)) {
+ mKeyToRemoveOnGutsClosed = null;
+ if (Log.isLoggable(TAG, Log.DEBUG)) {
+ Log.d(TAG, "Notification that was kept for guts was updated. " + entry.key);
+ }
+ }
+ }
+ }
+
+ @Override
public void dump(FileDescriptor fd, PrintWriter pw, String[] args) {
pw.println("NotificationGutsManager state:");
pw.print(" mKeyToRemoveOnGutsClosed: ");
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/phone/HeadsUpManagerPhone.java b/packages/SystemUI/src/com/android/systemui/statusbar/phone/HeadsUpManagerPhone.java
index 6150c2f..4a05989 100644
--- a/packages/SystemUI/src/com/android/systemui/statusbar/phone/HeadsUpManagerPhone.java
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/phone/HeadsUpManagerPhone.java
@@ -258,18 +258,6 @@
return mTrackingHeadsUp;
}
- /**
- * React to the removal of the notification in the heads up.
- *
- * @return true if the notification was removed and false if it still needs to be kept around
- * for a bit since it wasn't shown long enough
- */
- @Override
- public boolean removeNotification(@NonNull String key, boolean releaseImmediately) {
- return super.removeNotification(key, canRemoveImmediately(key)
- || releaseImmediately);
- }
-
@Override
public void snooze() {
super.snooze();
@@ -405,7 +393,8 @@
return (HeadsUpEntryPhone) getTopHeadsUpEntry();
}
- private boolean canRemoveImmediately(@NonNull String key) {
+ @Override
+ protected boolean canRemoveImmediately(@NonNull String key) {
if (mSwipedOutKeys.contains(key)) {
// We always instantly dismiss views being manually swiped out.
mSwipedOutKeys.remove(key);
@@ -414,7 +403,8 @@
HeadsUpEntryPhone headsUpEntry = getHeadsUpEntryPhone(key);
HeadsUpEntryPhone topEntry = getTopHeadsUpEntryPhone();
- return headsUpEntry != topEntry || headsUpEntry.wasShownLongEnough();
+
+ return headsUpEntry == null || headsUpEntry != topEntry || super.canRemoveImmediately(key);
}
/**
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/phone/PhoneStatusBarPolicy.java b/packages/SystemUI/src/com/android/systemui/statusbar/phone/PhoneStatusBarPolicy.java
index 57e01e7..a900c14 100644
--- a/packages/SystemUI/src/com/android/systemui/statusbar/phone/PhoneStatusBarPolicy.java
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/phone/PhoneStatusBarPolicy.java
@@ -596,9 +596,10 @@
mContext.getString(R.string.instant_apps));
mCurrentNotifs.add(new Pair<>(pkg, userId));
String message = mContext.getString(R.string.instant_apps_message);
- PendingIntent appInfoAction = PendingIntent.getActivity(mContext, 0,
+ UserHandle user = UserHandle.of(userId);
+ PendingIntent appInfoAction = PendingIntent.getActivityAsUser(mContext, 0,
new Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS)
- .setData(Uri.fromParts("package", pkg, null)), 0);
+ .setData(Uri.fromParts("package", pkg, null)), 0, null, user);
Action action = new Notification.Action.Builder(null, mContext.getString(R.string.app_info),
appInfoAction).build();
@@ -611,8 +612,8 @@
.addFlags(Intent.FLAG_IGNORE_EPHEMERAL)
.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
- PendingIntent pendingIntent = PendingIntent.getActivity(mContext,
- 0 /* requestCode */, browserIntent, 0 /* flags */);
+ PendingIntent pendingIntent = PendingIntent.getActivityAsUser(mContext,
+ 0 /* requestCode */, browserIntent, 0 /* flags */, null, user);
ComponentName aiaComponent = null;
try {
aiaComponent = AppGlobals.getPackageManager().getInstantAppInstallerComponent();
@@ -629,7 +630,8 @@
.putExtra(Intent.EXTRA_LONG_VERSION_CODE, appInfo.versionCode)
.putExtra(Intent.EXTRA_INSTANT_APP_FAILURE, pendingIntent);
- PendingIntent webPendingIntent = PendingIntent.getActivity(mContext, 0, goToWebIntent, 0);
+ PendingIntent webPendingIntent = PendingIntent.getActivityAsUser(mContext, 0,
+ goToWebIntent, 0, null, user);
Action webAction = new Notification.Action.Builder(null, mContext.getString(R.string.go_to_web),
webPendingIntent).build();
builder.addAction(webAction);
diff --git a/packages/SystemUI/src/com/android/systemui/statusbar/phone/StatusBar.java b/packages/SystemUI/src/com/android/systemui/statusbar/phone/StatusBar.java
index 22a727c..9beaa10 100644
--- a/packages/SystemUI/src/com/android/systemui/statusbar/phone/StatusBar.java
+++ b/packages/SystemUI/src/com/android/systemui/statusbar/phone/StatusBar.java
@@ -800,7 +800,7 @@
this,
mNotificationPanel,
notifListContainer);
- mGutsManager.setUpWithPresenter(this, mEntryManager, notifListContainer, mCheckSaveListener,
+ mGutsManager.setUpWithPresenter(this, notifListContainer, mCheckSaveListener,
key -> {
try {
mBarService.onNotificationSettingsViewed(key);
@@ -1811,7 +1811,7 @@
mStatusBarWindowController.setHeadsUpShowing(false);
mHeadsUpManager.setHeadsUpGoingAway(false);
}
- mRemoteInputManager.removeRemoteInputEntriesKeptUntilCollapsed();
+ mRemoteInputManager.onPanelCollapsed();
});
}
}
@@ -1828,7 +1828,7 @@
@Override
public void onHeadsUpStateChanged(Entry entry, boolean isHeadsUp) {
- mEntryManager.onHeadsUpStateChanged(entry, isHeadsUp);
+ mEntryManager.updateNotificationRanking(null /* rankingMap */);
if (isHeadsUp) {
mDozeServiceHost.fireNotificationHeadsUp();
@@ -1858,7 +1858,7 @@
}
if (!isExpanded) {
- mRemoteInputManager.removeRemoteInputEntriesKeptUntilCollapsed();
+ mRemoteInputManager.onPanelCollapsed();
}
}
@@ -3751,7 +3751,7 @@
clearNotificationEffects();
}
if (newState == StatusBarState.KEYGUARD) {
- mRemoteInputManager.removeRemoteInputEntriesKeptUntilCollapsed();
+ mRemoteInputManager.onPanelCollapsed();
maybeEscalateHeadsUp();
}
}
@@ -4862,7 +4862,8 @@
removeNotification(parentToCancelFinal);
}
if (shouldAutoCancel(sbn)
- || mEntryManager.isNotificationKeptForRemoteInput(notificationKey)) {
+ || mRemoteInputManager.isNotificationKeptForRemoteInputHistory(
+ notificationKey)) {
// Automatically remove all notifications that we may have kept around longer
removeNotification(sbn);
}
diff --git a/packages/SystemUI/tests/src/com/android/systemui/statusbar/AlertingNotificationManagerTest.java b/packages/SystemUI/tests/src/com/android/systemui/statusbar/AlertingNotificationManagerTest.java
index f04a115..32c972c 100644
--- a/packages/SystemUI/tests/src/com/android/systemui/statusbar/AlertingNotificationManagerTest.java
+++ b/packages/SystemUI/tests/src/com/android/systemui/statusbar/AlertingNotificationManagerTest.java
@@ -91,7 +91,7 @@
return new TestableAlertingNotificationManager();
}
- private StatusBarNotification createNewNotification(int id) {
+ protected StatusBarNotification createNewNotification(int id) {
Notification.Builder n = new Notification.Builder(mContext, "")
.setSmallIcon(R.drawable.ic_person)
.setContentTitle("Title")
@@ -154,7 +154,7 @@
public void testRemoveNotification_forceRemove() {
mAlertingNotificationManager.showNotification(mEntry);
- //Remove forcibly with releaseImmediately = true.
+ // Remove forcibly with releaseImmediately = true.
mAlertingNotificationManager.removeNotification(mEntry.key, true /* releaseImmediately */);
assertFalse(mAlertingNotificationManager.contains(mEntry.key));
@@ -173,4 +173,30 @@
assertEquals(0, mAlertingNotificationManager.getAllEntries().count());
}
+
+ @Test
+ public void testShouldExtendLifetime_notShownLongEnough() {
+ mAlertingNotificationManager.showNotification(mEntry);
+
+ // The entry has just been added so the lifetime should be extended
+ assertTrue(mAlertingNotificationManager.shouldExtendLifetime(mEntry));
+ }
+
+ @Test
+ public void testSetShouldExtendLifetime_setShouldExtend() {
+ mAlertingNotificationManager.showNotification(mEntry);
+
+ mAlertingNotificationManager.setShouldExtendLifetime(mEntry, true /* shouldExtend */);
+
+ assertTrue(mAlertingNotificationManager.mExtendedLifetimeAlertEntries.contains(mEntry));
+ }
+
+ @Test
+ public void testSetShouldExtendLifetime_setShouldNotExtend() {
+ mAlertingNotificationManager.mExtendedLifetimeAlertEntries.add(mEntry);
+
+ mAlertingNotificationManager.setShouldExtendLifetime(mEntry, false /* shouldExtend */);
+
+ assertFalse(mAlertingNotificationManager.mExtendedLifetimeAlertEntries.contains(mEntry));
+ }
}
diff --git a/packages/SystemUI/tests/src/com/android/systemui/statusbar/NonPhoneDependencyTest.java b/packages/SystemUI/tests/src/com/android/systemui/statusbar/NonPhoneDependencyTest.java
index 8129b01..09c1931 100644
--- a/packages/SystemUI/tests/src/com/android/systemui/statusbar/NonPhoneDependencyTest.java
+++ b/packages/SystemUI/tests/src/com/android/systemui/statusbar/NonPhoneDependencyTest.java
@@ -86,8 +86,8 @@
entryManager.setUpWithPresenter(mPresenter, mListContainer, mEntryManagerCallback,
mHeadsUpManager);
- gutsManager.setUpWithPresenter(mPresenter, entryManager, mListContainer,
- mCheckSaveListener, mOnClickListener);
+ gutsManager.setUpWithPresenter(mPresenter, mListContainer, mCheckSaveListener,
+ mOnClickListener);
notificationLogger.setUpWithEntryManager(entryManager, mListContainer);
mediaManager.setUpWithPresenter(mPresenter, entryManager);
remoteInputManager.setUpWithPresenter(mPresenter, entryManager, mRemoteInputManagerCallback,
diff --git a/packages/SystemUI/tests/src/com/android/systemui/statusbar/NotificationListenerTest.java b/packages/SystemUI/tests/src/com/android/systemui/statusbar/NotificationListenerTest.java
index 3cafaf4..7b0c0a0 100644
--- a/packages/SystemUI/tests/src/com/android/systemui/statusbar/NotificationListenerTest.java
+++ b/packages/SystemUI/tests/src/com/android/systemui/statusbar/NotificationListenerTest.java
@@ -85,13 +85,6 @@
}
@Test
- public void testPostNotificationRemovesKeyKeptForRemoteInput() {
- mListener.onNotificationPosted(mSbn, mRanking);
- TestableLooper.get(this).processAllMessages();
- verify(mEntryManager).removeKeyKeptForRemoteInput(mSbn.getKey());
- }
-
- @Test
public void testNotificationUpdateCallsUpdateNotification() {
when(mNotificationData.get(mSbn.getKey())).thenReturn(new NotificationData.Entry(mSbn));
mListener.onNotificationPosted(mSbn, mRanking);
diff --git a/packages/SystemUI/tests/src/com/android/systemui/statusbar/NotificationRemoteInputManagerTest.java b/packages/SystemUI/tests/src/com/android/systemui/statusbar/NotificationRemoteInputManagerTest.java
index afe2cf6..b2493b3 100644
--- a/packages/SystemUI/tests/src/com/android/systemui/statusbar/NotificationRemoteInputManagerTest.java
+++ b/packages/SystemUI/tests/src/com/android/systemui/statusbar/NotificationRemoteInputManagerTest.java
@@ -1,8 +1,10 @@
package com.android.systemui.statusbar;
-import static junit.framework.Assert.assertFalse;
+import static junit.framework.Assert.assertEquals;
import static junit.framework.Assert.assertTrue;
+import static junit.framework.Assert.assertFalse;
+import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
@@ -10,6 +12,7 @@
import android.content.Context;
import android.os.Handler;
import android.os.Looper;
+import android.os.SystemClock;
import android.os.UserHandle;
import android.service.notification.NotificationListenerService;
import android.service.notification.StatusBarNotification;
@@ -22,8 +25,14 @@
import com.android.systemui.statusbar.notification.NotificationData;
import com.android.systemui.statusbar.notification.NotificationEntryManager;
import com.android.systemui.statusbar.notification.row.ExpandableNotificationRow;
+import com.android.systemui.statusbar.NotificationRemoteInputManager.RemoteInputActiveExtender;
+import com.android.systemui.statusbar.NotificationRemoteInputManager.RemoteInputHistoryExtender;
+import com.android.systemui.statusbar.NotificationRemoteInputManager.SmartReplyHistoryExtender;
+
import com.google.android.collect.Sets;
+import junit.framework.Assert;
+
import org.junit.Before;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -41,6 +50,7 @@
@Mock private RemoteInputController.Delegate mDelegate;
@Mock private NotificationRemoteInputManager.Callback mCallback;
@Mock private RemoteInputController mController;
+ @Mock private SmartReplyController mSmartReplyController;
@Mock private NotificationListenerService.RankingMap mRanking;
@Mock private ExpandableNotificationRow mRow;
@@ -51,6 +61,9 @@
private TestableNotificationRemoteInputManager mRemoteInputManager;
private StatusBarNotification mSbn;
private NotificationData.Entry mEntry;
+ private RemoteInputHistoryExtender mRemoteInputHistoryExtender;
+ private SmartReplyHistoryExtender mSmartReplyHistoryExtender;
+ private RemoteInputActiveExtender mRemoteInputActiveExtender;
@Before
public void setUp() {
@@ -58,9 +71,9 @@
mDependency.injectTestDependency(NotificationEntryManager.class, mEntryManager);
mDependency.injectTestDependency(NotificationLockscreenUserManager.class,
mLockscreenUserManager);
+ mDependency.injectTestDependency(SmartReplyController.class, mSmartReplyController);
when(mPresenter.getHandler()).thenReturn(Handler.createAsync(Looper.myLooper()));
- when(mEntryManager.getLatestRankingMap()).thenReturn(mRanking);
mRemoteInputManager = new TestableNotificationRemoteInputManager(mContext);
mSbn = new StatusBarNotification(TEST_PACKAGE_NAME, TEST_PACKAGE_NAME, 0, null, TEST_UID,
@@ -70,20 +83,10 @@
mRemoteInputManager.setUpWithPresenterForTest(mPresenter, mEntryManager, mCallback,
mDelegate, mController);
- }
-
- @Test
- public void testOnRemoveNotificationNotKept() {
- assertFalse(mRemoteInputManager.onRemoveNotification(mEntry));
- assertTrue(mRemoteInputManager.getRemoteInputEntriesToRemoveOnCollapse().isEmpty());
- }
-
- @Test
- public void testOnRemoveNotificationKept() {
- when(mController.isRemoteInputActive(mEntry)).thenReturn(true);
- assertTrue(mRemoteInputManager.onRemoveNotification(mEntry));
- assertTrue(mRemoteInputManager.getRemoteInputEntriesToRemoveOnCollapse().equals(
- Sets.newArraySet(mEntry)));
+ for (NotificationLifetimeExtender extender : mRemoteInputManager.getLifetimeExtenders()) {
+ extender.setCallback(
+ mock(NotificationLifetimeExtender.NotificationSafeToRemoveCallback.class));
+ }
}
@Test
@@ -95,15 +98,104 @@
}
@Test
- public void testRemoveRemoteInputEntriesKeptUntilCollapsed() {
- mRemoteInputManager.getRemoteInputEntriesToRemoveOnCollapse().add(mEntry);
- mRemoteInputManager.removeRemoteInputEntriesKeptUntilCollapsed();
+ public void testShouldExtendLifetime_remoteInputActive() {
+ when(mController.isRemoteInputActive(mEntry)).thenReturn(true);
- assertTrue(mRemoteInputManager.getRemoteInputEntriesToRemoveOnCollapse().isEmpty());
- verify(mController).removeRemoteInput(mEntry, null);
- verify(mEntryManager).removeNotification(mEntry.key, mRanking);
+ assertTrue(mRemoteInputActiveExtender.shouldExtendLifetime(mEntry));
}
+ @Test
+ public void testShouldExtendLifetime_isSpinning() {
+ NotificationRemoteInputManager.FORCE_REMOTE_INPUT_HISTORY = true;
+ when(mController.isSpinning(mEntry.key)).thenReturn(true);
+
+ assertTrue(mRemoteInputHistoryExtender.shouldExtendLifetime(mEntry));
+ }
+
+ @Test
+ public void testShouldExtendLifetime_recentRemoteInput() {
+ NotificationRemoteInputManager.FORCE_REMOTE_INPUT_HISTORY = true;
+ mEntry.lastRemoteInputSent = SystemClock.elapsedRealtime();
+
+ assertTrue(mRemoteInputHistoryExtender.shouldExtendLifetime(mEntry));
+ }
+
+ @Test
+ public void testShouldExtendLifetime_smartReplySending() {
+ NotificationRemoteInputManager.FORCE_REMOTE_INPUT_HISTORY = true;
+ when(mSmartReplyController.isSendingSmartReply(mEntry.key)).thenReturn(true);
+
+ assertTrue(mSmartReplyHistoryExtender.shouldExtendLifetime(mEntry));
+ }
+
+ @Test
+ public void testNotificationWithRemoteInputActiveIsRemovedOnCollapse() {
+ mRemoteInputActiveExtender.setShouldExtendLifetime(mEntry, true);
+
+ assertEquals(mRemoteInputManager.getEntriesKeptForRemoteInputActive(),
+ Sets.newArraySet(mEntry));
+
+ mRemoteInputManager.onPanelCollapsed();
+
+ assertTrue(mRemoteInputManager.getEntriesKeptForRemoteInputActive().isEmpty());
+ }
+
+ @Test
+ public void testRebuildWithRemoteInput_noExistingInputNoSpinner() {
+ StatusBarNotification newSbn =
+ mRemoteInputManager.rebuildNotificationWithRemoteInput(mEntry, "A Reply", false);
+ CharSequence[] messages = newSbn.getNotification().extras
+ .getCharSequenceArray(Notification.EXTRA_REMOTE_INPUT_HISTORY);
+ assertEquals(1, messages.length);
+ assertEquals("A Reply", messages[0]);
+ assertFalse(newSbn.getNotification().extras
+ .getBoolean(Notification.EXTRA_SHOW_REMOTE_INPUT_SPINNER, false));
+ assertTrue(newSbn.getNotification().extras
+ .getBoolean(Notification.EXTRA_HIDE_SMART_REPLIES, false));
+ }
+
+ @Test
+ public void testRebuildWithRemoteInput_noExistingInputWithSpinner() {
+ StatusBarNotification newSbn =
+ mRemoteInputManager.rebuildNotificationWithRemoteInput(mEntry, "A Reply", true);
+ CharSequence[] messages = newSbn.getNotification().extras
+ .getCharSequenceArray(Notification.EXTRA_REMOTE_INPUT_HISTORY);
+ assertEquals(1, messages.length);
+ assertEquals("A Reply", messages[0]);
+ assertTrue(newSbn.getNotification().extras
+ .getBoolean(Notification.EXTRA_SHOW_REMOTE_INPUT_SPINNER, false));
+ assertTrue(newSbn.getNotification().extras
+ .getBoolean(Notification.EXTRA_HIDE_SMART_REPLIES, false));
+ }
+
+ @Test
+ public void testRebuildWithRemoteInput_withExistingInput() {
+ // Setup a notification entry with 1 remote input.
+ StatusBarNotification newSbn =
+ mRemoteInputManager.rebuildNotificationWithRemoteInput(mEntry, "A Reply", false);
+ NotificationData.Entry entry = new NotificationData.Entry(newSbn);
+
+ // Try rebuilding to add another reply.
+ newSbn = mRemoteInputManager.rebuildNotificationWithRemoteInput(entry, "Reply 2", true);
+ CharSequence[] messages = newSbn.getNotification().extras
+ .getCharSequenceArray(Notification.EXTRA_REMOTE_INPUT_HISTORY);
+ assertEquals(2, messages.length);
+ assertEquals("Reply 2", messages[0]);
+ assertEquals("A Reply", messages[1]);
+ }
+
+ @Test
+ public void testRebuildNotificationForCanceledSmartReplies() {
+ // Try rebuilding to remove spinner and hide buttons.
+ StatusBarNotification newSbn =
+ mRemoteInputManager.rebuildNotificationForCanceledSmartReplies(mEntry);
+ assertFalse(newSbn.getNotification().extras
+ .getBoolean(Notification.EXTRA_SHOW_REMOTE_INPUT_SPINNER, false));
+ assertTrue(newSbn.getNotification().extras
+ .getBoolean(Notification.EXTRA_HIDE_SMART_REPLIES, false));
+ }
+
+
private class TestableNotificationRemoteInputManager extends NotificationRemoteInputManager {
public TestableNotificationRemoteInputManager(Context context) {
@@ -118,5 +210,15 @@
super.setUpWithPresenter(presenter, entryManager, callback, delegate);
mRemoteInputController = controller;
}
+
+ @Override
+ protected void addLifetimeExtenders() {
+ mRemoteInputActiveExtender = new RemoteInputActiveExtender();
+ mRemoteInputHistoryExtender = new RemoteInputHistoryExtender();
+ mSmartReplyHistoryExtender = new SmartReplyHistoryExtender();
+ mLifetimeExtenders.add(mRemoteInputHistoryExtender);
+ mLifetimeExtenders.add(mSmartReplyHistoryExtender);
+ mLifetimeExtenders.add(mRemoteInputActiveExtender);
+ }
}
}
diff --git a/packages/SystemUI/tests/src/com/android/systemui/statusbar/SmartReplyControllerTest.java b/packages/SystemUI/tests/src/com/android/systemui/statusbar/SmartReplyControllerTest.java
index ada5785..17daaac 100644
--- a/packages/SystemUI/tests/src/com/android/systemui/statusbar/SmartReplyControllerTest.java
+++ b/packages/SystemUI/tests/src/com/android/systemui/statusbar/SmartReplyControllerTest.java
@@ -23,8 +23,11 @@
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
+import android.app.ActivityManager;
import android.app.Notification;
import android.os.RemoteException;
+import android.os.UserHandle;
+import android.service.notification.NotificationListenerService;
import android.service.notification.StatusBarNotification;
import android.support.test.filters.SmallTest;
import android.testing.AndroidTestingRunner;
@@ -35,6 +38,7 @@
import com.android.systemui.SysuiTestCase;
import com.android.systemui.statusbar.notification.NotificationData;
import com.android.systemui.statusbar.notification.NotificationEntryManager;
+import com.android.systemui.statusbar.notification.row.ExpandableNotificationRow;
import org.junit.Before;
import org.junit.Test;
@@ -46,97 +50,88 @@
@TestableLooper.RunWithLooper
@SmallTest
public class SmartReplyControllerTest extends SysuiTestCase {
- private static final String TEST_NOTIFICATION_KEY = "akey";
+ private static final String TEST_PACKAGE_NAME = "test";
+ private static final int TEST_UID = 0;
private static final String TEST_CHOICE_TEXT = "A Reply";
private static final int TEST_CHOICE_INDEX = 2;
private static final int TEST_CHOICE_COUNT = 4;
private Notification mNotification;
private NotificationData.Entry mEntry;
+ private SmartReplyController mSmartReplyController;
+ private NotificationRemoteInputManager mRemoteInputManager;
- @Mock
- private NotificationEntryManager mNotificationEntryManager;
- @Mock
- private IStatusBarService mIStatusBarService;
+ @Mock private NotificationPresenter mPresenter;
+ @Mock private RemoteInputController.Delegate mDelegate;
+ @Mock private NotificationRemoteInputManager.Callback mCallback;
+ @Mock private StatusBarNotification mSbn;
+ @Mock private NotificationEntryManager mNotificationEntryManager;
+ @Mock private IStatusBarService mIStatusBarService;
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
-
mDependency.injectTestDependency(NotificationEntryManager.class,
mNotificationEntryManager);
mDependency.injectTestDependency(IStatusBarService.class, mIStatusBarService);
+ mSmartReplyController = new SmartReplyController();
+ mDependency.injectTestDependency(SmartReplyController.class,
+ mSmartReplyController);
+
+ mRemoteInputManager = new NotificationRemoteInputManager(mContext);
+ mRemoteInputManager.setUpWithPresenter(mPresenter, mNotificationEntryManager, mCallback,
+ mDelegate);
mNotification = new Notification.Builder(mContext, "")
.setSmallIcon(R.drawable.ic_person)
.setContentTitle("Title")
.setContentText("Text").build();
- StatusBarNotification sbn = mock(StatusBarNotification.class);
- when(sbn.getNotification()).thenReturn(mNotification);
- when(sbn.getKey()).thenReturn(TEST_NOTIFICATION_KEY);
- mEntry = new NotificationData.Entry(sbn);
+
+ mSbn = new StatusBarNotification(TEST_PACKAGE_NAME, TEST_PACKAGE_NAME, 0, null, TEST_UID,
+ 0, mNotification, new UserHandle(ActivityManager.getCurrentUser()), null, 0);
+ mEntry = new NotificationData.Entry(mSbn);
}
@Test
public void testSendSmartReply_updatesRemoteInput() {
- StatusBarNotification sbn = mock(StatusBarNotification.class);
- when(sbn.getKey()).thenReturn(TEST_NOTIFICATION_KEY);
- when(mNotificationEntryManager.rebuildNotificationWithRemoteInput(
- argThat(entry -> entry.notification.getKey().equals(TEST_NOTIFICATION_KEY)),
- eq(TEST_CHOICE_TEXT), eq(true))).thenReturn(sbn);
-
- SmartReplyController controller = new SmartReplyController();
- controller.smartReplySent(mEntry, TEST_CHOICE_INDEX, TEST_CHOICE_TEXT);
+ mSmartReplyController.smartReplySent(mEntry, TEST_CHOICE_INDEX, TEST_CHOICE_TEXT);
// Sending smart reply should make calls to NotificationEntryManager
// to update the notification with reply and spinner.
- verify(mNotificationEntryManager).rebuildNotificationWithRemoteInput(
- argThat(entry -> entry.notification.getKey().equals(TEST_NOTIFICATION_KEY)),
- eq(TEST_CHOICE_TEXT), eq(true));
verify(mNotificationEntryManager).updateNotification(
- argThat(sbn2 -> sbn2.getKey().equals(TEST_NOTIFICATION_KEY)), isNull());
+ argThat(sbn -> sbn.getKey().equals(mSbn.getKey())), isNull());
}
@Test
public void testSendSmartReply_logsToStatusBar() throws RemoteException {
- StatusBarNotification sbn = mock(StatusBarNotification.class);
- when(sbn.getKey()).thenReturn(TEST_NOTIFICATION_KEY);
- when(mNotificationEntryManager.rebuildNotificationWithRemoteInput(
- argThat(entry -> entry.notification.getKey().equals(TEST_NOTIFICATION_KEY)),
- eq(TEST_CHOICE_TEXT), eq(true))).thenReturn(sbn);
-
- SmartReplyController controller = new SmartReplyController();
- controller.smartReplySent(mEntry, TEST_CHOICE_INDEX, TEST_CHOICE_TEXT);
+ mSmartReplyController.smartReplySent(mEntry, TEST_CHOICE_INDEX, TEST_CHOICE_TEXT);
// Check we log the result to the status bar service.
- verify(mIStatusBarService).onNotificationSmartReplySent(TEST_NOTIFICATION_KEY,
+ verify(mIStatusBarService).onNotificationSmartReplySent(mSbn.getKey(),
TEST_CHOICE_INDEX);
}
@Test
public void testShowSmartReply_logsToStatusBar() throws RemoteException {
- SmartReplyController controller = new SmartReplyController();
- controller.smartRepliesAdded(mEntry, TEST_CHOICE_COUNT);
+ mSmartReplyController.smartRepliesAdded(mEntry, TEST_CHOICE_COUNT);
// Check we log the result to the status bar service.
- verify(mIStatusBarService).onNotificationSmartRepliesAdded(TEST_NOTIFICATION_KEY,
+ verify(mIStatusBarService).onNotificationSmartRepliesAdded(mSbn.getKey(),
TEST_CHOICE_COUNT);
}
@Test
public void testSendSmartReply_reportsSending() {
- SmartReplyController controller = new SmartReplyController();
- controller.smartReplySent(mEntry, TEST_CHOICE_INDEX, TEST_CHOICE_TEXT);
+ mSmartReplyController.smartReplySent(mEntry, TEST_CHOICE_INDEX, TEST_CHOICE_TEXT);
- assertTrue(controller.isSendingSmartReply(TEST_NOTIFICATION_KEY));
+ assertTrue(mSmartReplyController.isSendingSmartReply(mSbn.getKey()));
}
@Test
public void testSendingSmartReply_afterRemove_shouldReturnFalse() {
- SmartReplyController controller = new SmartReplyController();
- controller.isSendingSmartReply(TEST_NOTIFICATION_KEY);
- controller.stopSending(mEntry);
+ mSmartReplyController.smartReplySent(mEntry, TEST_CHOICE_INDEX, TEST_CHOICE_TEXT);
+ mSmartReplyController.stopSending(mEntry);
- assertFalse(controller.isSendingSmartReply(TEST_NOTIFICATION_KEY));
+ assertFalse(mSmartReplyController.isSendingSmartReply(mSbn.getKey()));
}
}
diff --git a/packages/SystemUI/tests/src/com/android/systemui/statusbar/notification/NotificationEntryManagerTest.java b/packages/SystemUI/tests/src/com/android/systemui/statusbar/notification/NotificationEntryManagerTest.java
index 6543bdb..dacf59c 100644
--- a/packages/SystemUI/tests/src/com/android/systemui/statusbar/notification/NotificationEntryManagerTest.java
+++ b/packages/SystemUI/tests/src/com/android/systemui/statusbar/notification/NotificationEntryManagerTest.java
@@ -57,6 +57,7 @@
import com.android.systemui.ForegroundServiceController;
import com.android.systemui.R;
import com.android.systemui.SysuiTestCase;
+import com.android.systemui.statusbar.NotificationLifetimeExtender;
import com.android.systemui.statusbar.NotificationListener;
import com.android.systemui.statusbar.NotificationLockscreenUserManager;
import com.android.systemui.statusbar.NotificationMediaManager;
@@ -84,7 +85,6 @@
import java.util.ArrayList;
import java.util.Arrays;
-import java.util.List;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.TimeUnit;
@@ -143,6 +143,10 @@
public CountDownLatch getCountDownLatch() {
return mCountDownLatch;
}
+
+ public ArrayList<NotificationLifetimeExtender> getLifetimeExtenders() {
+ return mNotificationLifetimeExtenders;
+ }
}
private void setUserSentiment(String key, int sentiment) {
@@ -279,7 +283,6 @@
verify(mBarService, never()).onNotificationError(any(), any(), anyInt(), anyInt(), anyInt(),
any(), anyInt());
- verify(mRemoteInputManager).onUpdateNotification(mEntry);
verify(mPresenter).updateNotificationViews();
verify(mForegroundServiceController).updateNotification(eq(mSbn), anyInt());
verify(mCallback).onNotificationUpdated(mSbn);
@@ -301,8 +304,6 @@
any(), anyInt());
verify(mMediaManager).onNotificationRemoved(mSbn.getKey());
- verify(mRemoteInputManager).onRemoveNotification(mEntry);
- verify(mSmartReplyController).stopSending(mEntry);
verify(mForegroundServiceController).removeNotification(mSbn);
verify(mListContainer).cleanUpViewState(mRow);
verify(mPresenter).updateNotificationViews();
@@ -313,17 +314,23 @@
}
@Test
- public void testRemoveNotification_blockedBySendingSmartReply() throws Exception {
+ public void testRemoveNotification_blockedByLifetimeExtender() {
com.android.systemui.util.Assert.isNotMainThread();
+ NotificationLifetimeExtender extender = mock(NotificationLifetimeExtender.class);
+ when(extender.shouldExtendLifetime(mEntry)).thenReturn(true);
+
+ ArrayList<NotificationLifetimeExtender> extenders = mEntryManager.getLifetimeExtenders();
+ extenders.clear();
+ extenders.add(extender);
+
mEntry.row = mRow;
mEntryManager.getNotificationData().add(mEntry);
- when(mSmartReplyController.isSendingSmartReply(mEntry.key)).thenReturn(true);
mEntryManager.removeNotification(mSbn.getKey(), mRankingMap);
assertNotNull(mEntryManager.getNotificationData().get(mSbn.getKey()));
- assertTrue(mEntryManager.isNotificationKeptForRemoteInput(mEntry.key));
+ verify(extender).setShouldExtendLifetime(mEntry, true);
}
@Test
@@ -411,61 +418,6 @@
}
@Test
- public void testRebuildWithRemoteInput_noExistingInputNoSpinner() {
- StatusBarNotification newSbn =
- mEntryManager.rebuildNotificationWithRemoteInput(mEntry, "A Reply", false);
- CharSequence[] messages = newSbn.getNotification().extras
- .getCharSequenceArray(Notification.EXTRA_REMOTE_INPUT_HISTORY);
- Assert.assertEquals(1, messages.length);
- Assert.assertEquals("A Reply", messages[0]);
- Assert.assertFalse(newSbn.getNotification().extras
- .getBoolean(Notification.EXTRA_SHOW_REMOTE_INPUT_SPINNER, false));
- Assert.assertTrue(newSbn.getNotification().extras
- .getBoolean(Notification.EXTRA_HIDE_SMART_REPLIES, false));
- }
-
- @Test
- public void testRebuildWithRemoteInput_noExistingInputWithSpinner() {
- StatusBarNotification newSbn =
- mEntryManager.rebuildNotificationWithRemoteInput(mEntry, "A Reply", true);
- CharSequence[] messages = newSbn.getNotification().extras
- .getCharSequenceArray(Notification.EXTRA_REMOTE_INPUT_HISTORY);
- Assert.assertEquals(1, messages.length);
- Assert.assertEquals("A Reply", messages[0]);
- Assert.assertTrue(newSbn.getNotification().extras
- .getBoolean(Notification.EXTRA_SHOW_REMOTE_INPUT_SPINNER, false));
- Assert.assertTrue(newSbn.getNotification().extras
- .getBoolean(Notification.EXTRA_HIDE_SMART_REPLIES, false));
- }
-
- @Test
- public void testRebuildWithRemoteInput_withExistingInput() {
- // Setup a notification entry with 1 remote input.
- StatusBarNotification newSbn =
- mEntryManager.rebuildNotificationWithRemoteInput(mEntry, "A Reply", false);
- NotificationData.Entry entry = new NotificationData.Entry(newSbn);
-
- // Try rebuilding to add another reply.
- newSbn = mEntryManager.rebuildNotificationWithRemoteInput(entry, "Reply 2", true);
- CharSequence[] messages = newSbn.getNotification().extras
- .getCharSequenceArray(Notification.EXTRA_REMOTE_INPUT_HISTORY);
- Assert.assertEquals(2, messages.length);
- Assert.assertEquals("Reply 2", messages[0]);
- Assert.assertEquals("A Reply", messages[1]);
- }
-
- @Test
- public void testRebuildNotificationForCanceledSmartReplies() {
- // Try rebuilding to remove spinner and hide buttons.
- StatusBarNotification newSbn =
- mEntryManager.rebuildNotificationForCanceledSmartReplies(mEntry);
- Assert.assertFalse(newSbn.getNotification().extras
- .getBoolean(Notification.EXTRA_SHOW_REMOTE_INPUT_SPINNER, false));
- Assert.assertTrue(newSbn.getNotification().extras
- .getBoolean(Notification.EXTRA_HIDE_SMART_REPLIES, false));
- }
-
- @Test
public void testUpdateNotificationRanking() {
when(mPresenter.isDeviceProvisioned()).thenReturn(true);
when(mPresenter.isNotificationForCurrentProfiles(any())).thenReturn(true);
diff --git a/packages/SystemUI/tests/src/com/android/systemui/statusbar/notification/row/NotificationGutsManagerTest.java b/packages/SystemUI/tests/src/com/android/systemui/statusbar/notification/row/NotificationGutsManagerTest.java
index 676cb61..6656fdd 100644
--- a/packages/SystemUI/tests/src/com/android/systemui/statusbar/notification/row/NotificationGutsManagerTest.java
+++ b/packages/SystemUI/tests/src/com/android/systemui/statusbar/notification/row/NotificationGutsManagerTest.java
@@ -22,6 +22,8 @@
import static android.service.notification.NotificationListenerService.Ranking.USER_SENTIMENT_NEGATIVE;
import static junit.framework.Assert.assertNotNull;
+import static junit.framework.Assert.assertNull;
+import static junit.framework.Assert.assertTrue;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.fail;
@@ -30,6 +32,7 @@
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.doNothing;
+import static org.mockito.Mockito.doReturn;
import static org.mockito.Mockito.mock;
import static org.mockito.Mockito.when;
import static org.mockito.Mockito.spy;
@@ -54,6 +57,7 @@
import com.android.systemui.SysuiTestCase;
import com.android.systemui.plugins.statusbar.NotificationMenuRowPlugin;
+import com.android.systemui.statusbar.notification.NotificationData;
import com.android.systemui.statusbar.notification.NotificationEntryManager;
import com.android.systemui.statusbar.NotificationPresenter;
import com.android.systemui.statusbar.NotificationTestHelper;
@@ -99,7 +103,7 @@
mHelper = new NotificationTestHelper(mContext);
mGutsManager = new NotificationGutsManager(mContext);
- mGutsManager.setUpWithPresenter(mPresenter, mEntryManager, mStackScroller,
+ mGutsManager.setUpWithPresenter(mPresenter, mStackScroller,
mCheckSaveListener, mOnSettingsClickListener);
}
@@ -346,6 +350,35 @@
eq(true) /* isUserSentimentNegative */);
}
+ @Test
+ public void testShouldExtendLifetime() {
+ NotificationGuts guts = new NotificationGuts(mContext);
+ ExpandableNotificationRow row = spy(createTestNotificationRow());
+ doReturn(guts).when(row).getGuts();
+ NotificationData.Entry entry = row.getEntry();
+ entry.row = row;
+ mGutsManager.setExposedGuts(guts);
+
+ assertTrue(mGutsManager.shouldExtendLifetime(entry));
+ }
+
+ @Test
+ public void testSetShouldExtendLifetime_setShouldExtend() {
+ NotificationData.Entry entry = createTestNotificationRow().getEntry();
+ mGutsManager.setShouldExtendLifetime(entry, true /* shouldExtend */);
+
+ assertTrue(entry.key.equals(mGutsManager.mKeyToRemoveOnGutsClosed));
+ }
+
+ @Test
+ public void testSetShouldExtendLifetime_setShouldNotExtend() {
+ NotificationData.Entry entry = createTestNotificationRow().getEntry();
+ mGutsManager.mKeyToRemoveOnGutsClosed = entry.key;
+ mGutsManager.setShouldExtendLifetime(entry, false /* shouldExtend */);
+
+ assertNull(mGutsManager.mKeyToRemoveOnGutsClosed);
+ }
+
////////////////////////////////////////////////////////////////////////////////////////////////
// Utility methods:
diff --git a/packages/SystemUI/tests/src/com/android/systemui/statusbar/notification/stack/NotificationStackScrollLayoutTest.java b/packages/SystemUI/tests/src/com/android/systemui/statusbar/notification/stack/NotificationStackScrollLayoutTest.java
index c19188c..ce0bd58 100644
--- a/packages/SystemUI/tests/src/com/android/systemui/statusbar/notification/stack/NotificationStackScrollLayoutTest.java
+++ b/packages/SystemUI/tests/src/com/android/systemui/statusbar/notification/stack/NotificationStackScrollLayoutTest.java
@@ -112,7 +112,8 @@
mEntryManager = new TestableNotificationEntryManager(mSystemServicesProxy, mPowerManager,
mContext);
- mEntryManager.setUpForTest(mock(NotificationPresenter.class), null, null, null, mNotificationData);
+ mEntryManager.setUpForTest(mock(NotificationPresenter.class), null, null, mHeadsUpManager,
+ mNotificationData);
mDependency.injectTestDependency(NotificationEntryManager.class, mEntryManager);
NotificationShelf notificationShelf = spy(new NotificationShelf(getContext(), null));
diff --git a/packages/SystemUI/tests/src/com/android/systemui/statusbar/phone/HeadsUpManagerPhoneTest.java b/packages/SystemUI/tests/src/com/android/systemui/statusbar/phone/HeadsUpManagerPhoneTest.java
index bdf7cd3..a81d17f 100644
--- a/packages/SystemUI/tests/src/com/android/systemui/statusbar/phone/HeadsUpManagerPhoneTest.java
+++ b/packages/SystemUI/tests/src/com/android/systemui/statusbar/phone/HeadsUpManagerPhoneTest.java
@@ -23,6 +23,7 @@
import com.android.systemui.statusbar.AlertingNotificationManager;
import com.android.systemui.statusbar.AlertingNotificationManagerTest;
+import com.android.systemui.statusbar.notification.NotificationData;
import com.android.systemui.statusbar.notification.VisualStabilityManager;
import org.junit.Before;
@@ -83,4 +84,26 @@
assertFalse(mHeadsUpManager.contains(mEntry.key));
}
+
+ @Test
+ public void testShouldExtendLifetime_swipedOut() {
+ mHeadsUpManager.showNotification(mEntry);
+ mHeadsUpManager.addSwipedOutNotification(mEntry.key);
+
+ // Notification is swiped so its lifetime should not be extended even if it hasn't been
+ // shown long enough
+ assertFalse(mHeadsUpManager.shouldExtendLifetime(mEntry));
+ }
+
+ @Test
+ public void testShouldExtendLifetime_notTopEntry() {
+ NotificationData.Entry laterEntry = new NotificationData.Entry(createNewNotification(1));
+ laterEntry.row = mRow;
+ mHeadsUpManager.showNotification(mEntry);
+ mHeadsUpManager.showNotification(laterEntry);
+
+ // Notification is "behind" a higher priority notification so we have no reason to keep
+ // its lifetime extended
+ assertFalse(mHeadsUpManager.shouldExtendLifetime(mEntry));
+ }
}
diff --git a/services/core/java/com/android/server/InputMethodManagerService.java b/services/core/java/com/android/server/InputMethodManagerService.java
index 665c6b7..4d3468e 100644
--- a/services/core/java/com/android/server/InputMethodManagerService.java
+++ b/services/core/java/com/android/server/InputMethodManagerService.java
@@ -204,8 +204,6 @@
static final int MSG_START_INPUT = 2000;
static final int MSG_START_VR_INPUT = 2010;
- static final int MSG_ADD_CLIENT = 2980;
- static final int MSG_REMOVE_CLIENT = 2990;
static final int MSG_UNBIND_CLIENT = 3000;
static final int MSG_BIND_CLIENT = 3010;
static final int MSG_SET_ACTIVE = 3020;
@@ -1302,7 +1300,7 @@
@Override
public void onStart() {
LocalServices.addService(InputMethodManagerInternal.class,
- new LocalServiceImpl(mService.mHandler));
+ new LocalServiceImpl(mService));
publishBinderService(Context.INPUT_METHOD_SERVICE, mService);
}
@@ -1561,7 +1559,6 @@
final String defaultImiId = mSettings.getSelectedInputMethod();
final boolean imeSelectedOnBoot = !TextUtils.isEmpty(defaultImiId);
buildInputMethodListLocked(!imeSelectedOnBoot /* resetDefaultEnabledIme */);
- resetDefaultImeLocked(mContext);
updateFromSettingsLocked(true);
InputMethodUtils.setNonSelectedSystemImesDisabledUntilUsed(mIPackageManager,
mSettings.getEnabledInputMethodListLocked(), currentUserId,
@@ -3396,15 +3393,6 @@
}
// ---------------------------------------------------------
- case MSG_ADD_CLIENT:
- addClient((ClientState) msg.obj);
- return true;
-
- case MSG_REMOVE_CLIENT:
- removeClient((IInputMethodClient) msg.obj);
- return true;
-
- // ---------------------------------------------------------
case MSG_UNBIND_CLIENT:
try {
@@ -4397,22 +4385,27 @@
private static final class LocalServiceImpl extends InputMethodManagerInternal {
@NonNull
+ private final InputMethodManagerService mService;
+ @NonNull
private final Handler mHandler;
- LocalServiceImpl(@NonNull final Handler handler) {
- mHandler = handler;
+ LocalServiceImpl(@NonNull InputMethodManagerService service) {
+ mService = service;
+ mHandler = service.mHandler;
}
@Override
public void addClient(IInputMethodClient client, IInputContext inputContext, int uid,
int pid) {
- mHandler.sendMessage(mHandler.obtainMessage(MSG_ADD_CLIENT,
- new ClientState(client, inputContext, uid, pid)));
+ // Work around Bug 113877122: We need to handle this synchronously. Otherwise, some
+ // IMM binder calls from the client process before we register this client.
+ mService.addClient(new ClientState(client, inputContext, uid, pid));
}
@Override
public void removeClient(IInputMethodClient client) {
- mHandler.sendMessage(mHandler.obtainMessage(MSG_REMOVE_CLIENT, client));
+ // Handle this synchronously to be consistent with addClient().
+ mService.removeClient(client);
}
@Override
diff --git a/services/core/java/com/android/server/TelephonyRegistry.java b/services/core/java/com/android/server/TelephonyRegistry.java
index 566ce4f..c44a81e 100644
--- a/services/core/java/com/android/server/TelephonyRegistry.java
+++ b/services/core/java/com/android/server/TelephonyRegistry.java
@@ -50,6 +50,7 @@
import android.telephony.VoLteServiceState;
import android.util.LocalLog;
+import com.android.internal.annotations.VisibleForTesting;
import com.android.internal.app.IBatteryStats;
import com.android.internal.telephony.IOnSubscriptionsChangedListener;
import com.android.internal.telephony.IPhoneStateListener;
@@ -82,7 +83,8 @@
* Eventually we may want to remove the notion of dummy value but for now this
* looks like the best approach.
*/
-class TelephonyRegistry extends ITelephonyRegistry.Stub {
+@VisibleForTesting(visibility = VisibleForTesting.Visibility.PACKAGE)
+public class TelephonyRegistry extends ITelephonyRegistry.Stub {
private static final String TAG = "TelephonyRegistry";
private static final boolean DBG = false; // STOPSHIP if true
private static final boolean DBG_LOC = false; // STOPSHIP if true
@@ -315,7 +317,8 @@
// calls go through a oneway interface and local calls going through a
// handler before they get to app code.
- TelephonyRegistry(Context context) {
+ @VisibleForTesting(visibility = VisibleForTesting.Visibility.PACKAGE)
+ public TelephonyRegistry(Context context) {
CellLocation location = CellLocation.getEmpty();
mContext = context;
diff --git a/services/core/java/com/android/server/am/OWNERS b/services/core/java/com/android/server/am/OWNERS
index f60c5c3..79c98e5 100644
--- a/services/core/java/com/android/server/am/OWNERS
+++ b/services/core/java/com/android/server/am/OWNERS
@@ -4,7 +4,6 @@
jsharkey@google.com
hackbod@google.com
omakoto@google.com
-fkupolov@google.com
ctate@google.com
huiyu@google.com
mwachens@google.com
@@ -28,7 +27,4 @@
michaelwr@google.com
narayan@google.com
-per-file GlobalSettingsToPropertiesMapper.java=fkupolov@google.com
-per-file GlobalSettingsToPropertiesMapper.java=omakoto@google.com
-per-file GlobalSettingsToPropertiesMapper.java=svetoslavganov@google.com
-per-file GlobalSettingsToPropertiesMapper.java=yamasani@google.com
+per-file GlobalSettingsToPropertiesMapper.java = omakoto@google.com, svetoslavganov@google.com, yamasani@google.com
diff --git a/services/core/java/com/android/server/inputmethod/InputMethodManagerInternal.java b/services/core/java/com/android/server/inputmethod/InputMethodManagerInternal.java
index b57356f..b5a9f74 100644
--- a/services/core/java/com/android/server/inputmethod/InputMethodManagerInternal.java
+++ b/services/core/java/com/android/server/inputmethod/InputMethodManagerInternal.java
@@ -28,6 +28,10 @@
/**
* Called by the window manager service when a client process is being attached to the window
* manager service.
+ *
+ * <p>The caller must not have WindowManagerService lock. This method internally acquires
+ * InputMethodManagerService lock.</p>
+ *
* @param client {@link android.os.Binder} proxy that is associated with the singleton instance
* of {@link android.view.inputmethod.InputMethodManager} that runs on the client
* process
@@ -42,6 +46,10 @@
/**
* Called by the window manager service when a client process is being attached to the window
* manager service.
+ *
+ * <p>The caller must not have WindowManagerService lock. This method internally acquires
+ * InputMethodManagerService lock.</p>
+ *
* @param client {@link android.os.Binder} proxy that is associated with the singleton instance
* of {@link android.view.inputmethod.InputMethodManager} that runs on the client
* process
diff --git a/services/core/java/com/android/server/pm/PackageManagerService.java b/services/core/java/com/android/server/pm/PackageManagerService.java
index 9b097bf..07f3e17 100644
--- a/services/core/java/com/android/server/pm/PackageManagerService.java
+++ b/services/core/java/com/android/server/pm/PackageManagerService.java
@@ -1988,6 +1988,14 @@
mRequiredVerifierPackage, null /*finishedReceiver*/,
updateUserIds, instantUserIds);
}
+ // If package installer is defined, notify package installer about new
+ // app installed
+ if (mRequiredInstallerPackage != null) {
+ sendPackageBroadcast(Intent.ACTION_PACKAGE_ADDED, packageName,
+ extras, Intent.FLAG_RECEIVER_INCLUDE_BACKGROUND /*flags*/,
+ mRequiredInstallerPackage, null /*finishedReceiver*/,
+ firstUserIds, instantUserIds);
+ }
// Send replaced for users that don't see the package for the first time
if (update) {
diff --git a/services/robotests/src/com/android/server/backup/keyvalue/KeyValueBackupTaskTest.java b/services/robotests/src/com/android/server/backup/keyvalue/KeyValueBackupTaskTest.java
index 9fae43a..82d7ab8 100644
--- a/services/robotests/src/com/android/server/backup/keyvalue/KeyValueBackupTaskTest.java
+++ b/services/robotests/src/com/android/server/backup/keyvalue/KeyValueBackupTaskTest.java
@@ -63,6 +63,7 @@
import static org.robolectric.Shadows.shadowOf;
import static org.robolectric.shadow.api.Shadow.extract;
import static org.testng.Assert.fail;
+import static org.testng.Assert.expectThrows;
import static java.nio.file.StandardCopyOption.REPLACE_EXISTING;
import static java.util.Collections.emptyList;
@@ -1941,6 +1942,29 @@
task.markCancel();
}
+ @Test
+ public void testHandleCancel_callsMarkCancelAndWaitCancel() throws Exception {
+ TransportMock transportMock = setUpInitializedTransport(mTransport);
+ setUpAgentWithData(PACKAGE_1);
+ KeyValueBackupTask task = spy(createKeyValueBackupTask(transportMock, PACKAGE_1));
+ doNothing().when(task).waitCancel();
+
+ task.handleCancel(true);
+
+ InOrder inOrder = inOrder(task);
+ inOrder.verify(task).markCancel();
+ inOrder.verify(task).waitCancel();
+ }
+
+ @Test
+ public void testHandleCancel_whenCancelAllFalse_throws() throws Exception {
+ TransportMock transportMock = setUpInitializedTransport(mTransport);
+ setUpAgentWithData(PACKAGE_1);
+ KeyValueBackupTask task = createKeyValueBackupTask(transportMock, PACKAGE_1);
+
+ expectThrows(IllegalArgumentException.class, () -> task.handleCancel(false));
+ }
+
private void runTask(KeyValueBackupTask task) {
// Pretend we are not on the main-thread to prevent RemoteCall from complaining
mShadowMainLooper.setCurrentThread(false);
diff --git a/telephony/java/android/telephony/CarrierConfigManager.java b/telephony/java/android/telephony/CarrierConfigManager.java
index 8703e65..ffbe7d3 100644
--- a/telephony/java/android/telephony/CarrierConfigManager.java
+++ b/telephony/java/android/telephony/CarrierConfigManager.java
@@ -107,13 +107,34 @@
/**
* Boolean indicating if the "Call barring" item is visible in the Call Settings menu.
- * true means visible. false means gone.
- * @hide
+ * If true, the "Call Barring" menu will be visible. If false, the menu will be gone.
+ *
+ * Disabled by default.
*/
public static final String KEY_CALL_BARRING_VISIBILITY_BOOL =
"call_barring_visibility_bool";
/**
+ * Flag indicating whether or not changing the call barring password via the "Call Barring"
+ * settings menu is supported. If true, the option will be visible in the "Call
+ * Barring" settings menu. If false, the option will not be visible.
+ *
+ * Enabled by default.
+ */
+ public static final String KEY_CALL_BARRING_SUPPORTS_PASSWORD_CHANGE_BOOL =
+ "call_barring_supports_password_change_bool";
+
+ /**
+ * Flag indicating whether or not deactivating all call barring features via the "Call Barring"
+ * settings menu is supported. If true, the option will be visible in the "Call
+ * Barring" settings menu. If false, the option will not be visible.
+ *
+ * Enabled by default.
+ */
+ public static final String KEY_CALL_BARRING_SUPPORTS_DEACTIVATE_ALL_BOOL =
+ "call_barring_supports_deactivate_all_bool";
+
+ /**
* Flag indicating whether the Phone app should ignore EVENT_SIM_NETWORK_LOCKED
* events from the Sim.
* If true, this will prevent the IccNetworkDepersonalizationPanel from being shown, and
@@ -2125,6 +2146,8 @@
sDefaults.putBoolean(KEY_CARRIER_VOLTE_PROVISIONED_BOOL, false);
sDefaults.putBoolean(KEY_CALL_BARRING_VISIBILITY_BOOL, false);
+ sDefaults.putBoolean(KEY_CALL_BARRING_SUPPORTS_PASSWORD_CHANGE_BOOL, true);
+ sDefaults.putBoolean(KEY_CALL_BARRING_SUPPORTS_DEACTIVATE_ALL_BOOL, true);
sDefaults.putBoolean(KEY_CALL_FORWARDING_VISIBILITY_BOOL, true);
sDefaults.putBoolean(KEY_ADDITIONAL_SETTINGS_CALLER_ID_VISIBILITY_BOOL, true);
sDefaults.putBoolean(KEY_ADDITIONAL_SETTINGS_CALL_WAITING_VISIBILITY_BOOL, true);
diff --git a/telephony/java/android/telephony/PhoneStateListener.java b/telephony/java/android/telephony/PhoneStateListener.java
index bd6a59d..498be96 100644
--- a/telephony/java/android/telephony/PhoneStateListener.java
+++ b/telephony/java/android/telephony/PhoneStateListener.java
@@ -23,6 +23,7 @@
import android.os.Looper;
import android.os.Message;
+import com.android.internal.annotations.VisibleForTesting;
import com.android.internal.telephony.IPhoneStateListener;
import java.lang.ref.WeakReference;
@@ -778,8 +779,12 @@
}
}
+ /**
+ * @hide
+ */
+ @VisibleForTesting(visibility = VisibleForTesting.Visibility.PACKAGE)
@UnsupportedAppUsage
- IPhoneStateListener callback = new IPhoneStateListenerStub(this);
+ public final IPhoneStateListener callback = new IPhoneStateListenerStub(this);
private void log(String s) {
Rlog.d(LOG_TAG, s);
diff --git a/wifi/tests/src/android/net/wifi/WifiConfigurationTest.java b/wifi/tests/src/android/net/wifi/WifiConfigurationTest.java
index 3517984..3b9f93e 100644
--- a/wifi/tests/src/android/net/wifi/WifiConfigurationTest.java
+++ b/wifi/tests/src/android/net/wifi/WifiConfigurationTest.java
@@ -18,14 +18,14 @@
import static org.junit.Assert.assertArrayEquals;
import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
import static org.junit.Assert.assertNotEquals;
import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.assertFalse;
-import android.os.Parcel;
import android.net.MacAddress;
import android.net.wifi.WifiConfiguration.NetworkSelectionStatus;
-import android.net.wifi.WifiInfo;
+import android.os.Parcel;
+import android.support.test.filters.SmallTest;
import org.junit.Before;
import org.junit.Test;
@@ -33,6 +33,7 @@
/**
* Unit tests for {@link android.net.wifi.WifiConfiguration}.
*/
+@SmallTest
public class WifiConfigurationTest {
@Before
diff --git a/wifi/tests/src/android/net/wifi/WifiSsidTest.java b/wifi/tests/src/android/net/wifi/WifiSsidTest.java
index e5794c5..b58f2c7 100644
--- a/wifi/tests/src/android/net/wifi/WifiSsidTest.java
+++ b/wifi/tests/src/android/net/wifi/WifiSsidTest.java
@@ -19,14 +19,16 @@
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
+import android.support.test.filters.SmallTest;
+
import org.junit.Test;
import java.nio.charset.StandardCharsets;
-import java.util.Arrays;
/**
* Unit tests for {@link android.net.wifi.WifiSsid}.
*/
+@SmallTest
public class WifiSsidTest {
private static final String TEST_SSID = "Test SSID";
diff --git a/wifi/tests/src/android/net/wifi/p2p/WifiP2pDeviceTest.java b/wifi/tests/src/android/net/wifi/p2p/WifiP2pDeviceTest.java
index e492475..80f00a4 100644
--- a/wifi/tests/src/android/net/wifi/p2p/WifiP2pDeviceTest.java
+++ b/wifi/tests/src/android/net/wifi/p2p/WifiP2pDeviceTest.java
@@ -19,11 +19,14 @@
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
+import android.support.test.filters.SmallTest;
+
import org.junit.Test;
/**
* Unit test harness for {@link android.net.wifi.p2p.WifiP2pDevice}
*/
+@SmallTest
public class WifiP2pDeviceTest {
/**
diff --git a/wifi/tests/src/android/net/wifi/p2p/WifiP2pManagerTest.java b/wifi/tests/src/android/net/wifi/p2p/WifiP2pManagerTest.java
index e8e4dc2..2132b41 100644
--- a/wifi/tests/src/android/net/wifi/p2p/WifiP2pManagerTest.java
+++ b/wifi/tests/src/android/net/wifi/p2p/WifiP2pManagerTest.java
@@ -21,6 +21,7 @@
import android.content.Context;
import android.os.test.TestLooper;
+import android.support.test.filters.SmallTest;
import libcore.junit.util.ResourceLeakageDetector;
@@ -33,6 +34,7 @@
/**
* Unit test harness for WifiP2pManager.
*/
+@SmallTest
public class WifiP2pManagerTest {
private WifiP2pManager mDut;
private TestLooper mTestLooper;
diff --git a/wifi/tests/src/android/net/wifi/rtt/WifiRttManagerTest.java b/wifi/tests/src/android/net/wifi/rtt/WifiRttManagerTest.java
index ccb9031..8997ae9 100644
--- a/wifi/tests/src/android/net/wifi/rtt/WifiRttManagerTest.java
+++ b/wifi/tests/src/android/net/wifi/rtt/WifiRttManagerTest.java
@@ -31,6 +31,7 @@
import android.os.IBinder;
import android.os.Parcel;
import android.os.test.TestLooper;
+import android.support.test.filters.SmallTest;
import org.junit.Before;
import org.junit.Test;
@@ -45,6 +46,7 @@
/**
* Unit test harness for WifiRttManager class.
*/
+@SmallTest
public class WifiRttManagerTest {
private WifiRttManager mDut;
private TestLooper mMockLooper;