Unter Android 12 sind öffentliche APIs verfügbar, mit denen Fensterunschärfe-Effekte wie Hintergrundunschärfe und Unschärfe im Hintergrund implementiert werden können.
Mit Fensterunschärfen oder Fensterübergreifenden Unschärfen wird der Bildschirm hinter dem jeweiligen Fenster unkenntlich gemacht. Es gibt zwei Arten von Fensterunschärfe, mit denen sich unterschiedliche visuelle Effekte erzielen lassen:
Mit der Hintergrundunschärfe können Sie Fenster mit unscharfen Hintergründen erstellen, um einen Milchglaseffekt zu erzielen.
Mit Hintergrund unkenntlich machen können Sie den gesamten Bildschirm hinter einem (Dialog-)Fenster unkenntlich machen und so einen Schärfentiefeeffekt erzeugen.
Die beiden Effekte können separat oder kombiniert verwendet werden, wie in der folgenden Abbildung dargestellt:
a |
b |
 c |
Abbildung 1: Nur Hintergrund weichzeichnen (a), nur Hintergrund weichzeichnen (b), Hintergrund und Hintergrund weichzeichnen (c)
Die Funktion zum Unkenntlichmachen von Fenstern funktioniert unabhängig vom Fenster, also auch dann, wenn sich hinter dem Fenster eine andere App befindet. Dieser Effekt ist nicht mit dem Rendereffekt „Unkenntlich machen“ identisch, bei dem die Inhalte innerhalb desselben Fensters unkenntlich gemacht werden. Fensterunschärfen sind nützlich für Dialogfelder, Ansichten am unteren Rand und andere Overlays.
Implementierung
App-Entwickler
App-Entwickler müssen einen Unkenntlichmachungsradius angeben, um einen Unkenntlichmachungseffekt zu erzielen. Mit dem Unkenntlichmachungsradius wird die Dichte der Unkenntlichmachung gesteuert. Je höher der Radius, desto stärker die Unkenntlichmachung. Ein Wert von 0 px bedeutet, dass keine Unschärfe angewendet wird. Für das Weichzeichnen im Hintergrund sorgt ein Radius von 20 px für einen guten Schärfentiefeeffekt, während ein Radius von 80 px für einen guten Milchglaseffekt sorgt. Vermeiden Sie Unkenntlichmachungsradien von mehr als 150 Pixeln, da sich dies erheblich auf die Leistung auswirkt.
Um den gewünschten Weichzeichnereffekt zu erzielen und die Lesbarkeit zu verbessern, wählen Sie einen Wert für den Weichzeichnerradius aus, der durch eine durchsichtige Farbschicht ergänzt wird.
Weichgezeichneter Hintergrund
Mit der Hintergrundunschärfe für schwebende Fenster können Sie einen Fensterhintergrundeffekt erstellen, bei dem der zugrunde liegende Inhalt unscharf dargestellt wird. So fügen Sie Ihrem Fenster einen weichgezeichneten Hintergrund hinzu:
Rufen Sie Window#setBackgroundBlurRadius(int) auf, um einen Radius für die Hintergrundunschärfe festzulegen. Alternativ können Sie im Fensterdesign R.attr.windowBackgroundBlurRadius festlegen.
Legen Sie R.attr.windowIsTranslucent auf „wahr“ fest, um das Fenster halbtransparent zu machen. Die Unkenntlichmachung wird unter der Fensteroberfläche gezeichnet. Das Fenster muss also durchscheinend sein, damit die Unkenntlichmachung sichtbar ist.
Optional können Sie Window#setBackgroundDrawableResource(int) aufrufen, um einen rechteckigen Fensterhintergrund mit einer durchsichtigen Farbe hinzuzufügen. Sie können auch R.attr.windowBackground im Fensterdesign festlegen.
Wenn Sie ein Fenster mit abgerundeten Ecken haben, legen Sie die abgerundeten Ecken für den unscharfen Bereich fest, indem Sie ein ShapeDrawable mit abgerundeten Ecken als Drawable für den Fensterhintergrund festlegen.
Deaktivieren und Aktivieren von Unkenntlichmachen verarbeiten Weitere Informationen finden Sie im Abschnitt Richtlinien für die Verwendung von Fensterunkenntlichmachung in Apps.
Hintergrund weichzeichnen
Durch die Unkenntlichmachung wird der gesamte Bildschirm hinter dem Fenster unkenntlich gemacht. Mit diesem Effekt wird die Aufmerksamkeit des Nutzers auf den Inhalt des Fensters gelenkt, indem alles auf dem Bildschirm hinter dem Fenster unscharf gemacht wird.
So können Sie den Inhalt hinter Ihrem Fenster unkenntlich machen:
Fügen Sie den Fenster-Flags
FLAG_BLUR_BEHINDhinzu, um den Hintergrund zu weichzeichnen. Sie können auch im Fensterdesign R.attr.windowBlurBehindEnabled festlegen.Rufen Sie
WindowManager.LayoutParams#setBlurBehindRadiusauf, um einen Radius für das Weichzeichnen festzulegen. Alternativ können Sie im Fensterdesign R.attr.windowBlurBehindRadius festlegen.Optional: Wählen Sie eine ergänzende dim Menge aus.
Deaktivieren und Aktivieren von Unkenntlichmachen verarbeiten Weitere Informationen finden Sie im Abschnitt Richtlinien für die Verwendung von Fensterunkenntlichmachung in Apps.
Richtlinien für die Verwendung von Fensterunkenntlichmachung in Apps
Die Unterstützung für das Unkenntlichmachen von Fenstern hängt von folgenden Faktoren ab:
Android-Version: Die APIs zum Unkenntlichmachen von Fenstern sind nur unter Android 12 und höher verfügbar. Prüfen Sie im Geräte-SDK die Android-Version.
Grafikleistung: Geräte mit weniger leistungsfähigen GPUs unterstützen möglicherweise keine Fensterunschärfe.
Systemstatus: Der Systemserver deaktiviert die Fensterunschärfe möglicherweise vorübergehend zur Laufzeit, z. B. im Akkusparmodus, beim Abspielen bestimmter Videoinhalte oder aufgrund einer Entwicklerüberschreibung.
Beachten Sie die folgenden Richtlinien, damit Ihre App mit allen Android-Versionen, Geräten und Systemstatus kompatibel ist:
Fügen Sie über WindowManager#addCrossWindowBlurEnabledListener einen Listener hinzu, um benachrichtigt zu werden, wenn die Fensterunschärfe aktiviert oder deaktiviert ist. Außerdem können Sie mit
WindowManager#isCrossWindowBlurEnabledabfragen, ob Fensterunschärfen derzeit aktiviert sind.Implementieren Sie zwei Versionen für den Fensterhintergrund, um den aktivierten oder deaktivierten Status der Fensterunschärfe zu berücksichtigen.
Wenn Unkenntlichmachungen aktiviert sind, sollte der Fensterhintergrund durchscheinend sein, damit die Unkenntlichmachung sichtbar ist. In diesem Zustand überlappen sich die Inhalte des Fensters, wenn das Weichzeichnen deaktiviert ist, direkt mit den Inhalten des darunter liegenden Fensters, wodurch das überlappende Fenster weniger lesbar ist. Um einen solchen Effekt zu vermeiden, passen Sie die Benutzeroberfläche der App so an, wenn die Fensterunschärfe deaktiviert ist:
Für den Weichgezeichneten Hintergrund erhöhen Sie den Alphawert des Fensterhintergrunds, um ihn undurchsichtiger zu machen.
Wenn Sie den Hintergrund unscharfstellen möchten, fügen Sie eine Ebene mit einem höheren Dimmwert hinzu.
Beispiel für Weichzeichnen im Hintergrund und Weichzeichnen des Hintergrunds
In diesem Abschnitt finden Sie ein Beispiel für eine Aktivität, bei der sowohl die Funktion „Weichzeichnen im Hintergrund“ als auch die Funktion „Weichzeichnen des Hintergrunds“ verwendet werden.
Das folgende Beispiel für MainActivity.java ist ein Dialogfeld mit einem Unkenntlichmachungsradius von 20 px im Hintergrund und einem Unkenntlichmachungsradius von 80 px im Hintergrund. Es hat abgerundete Ecken, die im XML-Code im drawable-Element für den Fensterhintergrund definiert sind. Es werden verschiedene Android-Versionen, verschiedene Geräte (die möglicherweise keine Fensterunkenntlichmachung unterstützen) und Änderungen an der Laufzeitunkenntlichmachung korrekt verarbeitet. Durch die Anpassung des Alphakanals des Fensterhintergrunds und der Abdunkelung des Fensters wird dafür gesorgt, dass der Dialoginhalt unter allen diesen Bedingungen lesbar ist.
public class MainActivity extends Activity {
private final int mBackgroundBlurRadius = 80;
private final int mBlurBehindRadius = 20;
// We set a different dim amount depending on whether window blur is enabled or disabled
private final float mDimAmountWithBlur = 0.1f;
private final float mDimAmountNoBlur = 0.4f;
// We set a different alpha depending on whether window blur is enabled or disabled
private final int mWindowBackgroundAlphaWithBlur = 170;
private final int mWindowBackgroundAlphaNoBlur = 255;
// Use a rectangular shape drawable for the window background. The outline of this drawable
// dictates the shape and rounded corners for the window background blur area.
private Drawable mWindowBackgroundDrawable;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);
mWindowBackgroundDrawable = getDrawable(R.drawable.window_background);
getWindow().setBackgroundDrawable(mWindowBackgroundDrawable);
if (buildIsAtLeastS()) {
// Enable blur behind. This can also be done in xml with R.attr#windowBlurBehindEnabled
getWindow().addFlags(WindowManager.LayoutParams.FLAG_BLUR_BEHIND);
// Register a listener to adjust window UI whenever window blurs are enabled/disabled
setupWindowBlurListener();
} else {
// Window blurs are not available prior to Android S
updateWindowForBlurs(false /* blursEnabled */);
}
// Enable dim. This can also be done in xml, see R.attr#backgroundDimEnabled
getWindow().addFlags(WindowManager.LayoutParams.FLAG_DIM_BEHIND);
}
/**
* Set up a window blur listener.
*
* Window blurs might be disabled at runtime in response to user preferences or system states
* (e.g. battery saving mode). WindowManager#addCrossWindowBlurEnabledListener allows to
* listen for when that happens. In that callback we adjust the UI to account for the
* added/missing window blurs.
*
* For the window background blur we adjust the window background drawable alpha:
* - lower when window blurs are enabled to make the blur visible through the window
* background drawable
* - higher when window blurs are disabled to ensure that the window contents are readable
*
* For window blur behind we adjust the dim amount:
* - higher when window blurs are disabled - the dim creates a depth of field effect,
* bringing the user's attention to the dialog window
* - lower when window blurs are enabled - no need for a high alpha, the blur behind is
* enough to create a depth of field effect
*/
@RequiresApi(api = Build.VERSION_CODES.S)
private void setupWindowBlurListener() {
Consumer<Boolean> windowBlurEnabledListener = this::updateWindowForBlurs;
getWindow().getDecorView().addOnAttachStateChangeListener(
new View.OnAttachStateChangeListener() {
@Override
public void onViewAttachedToWindow(View v) {
getWindowManager().addCrossWindowBlurEnabledListener(
windowBlurEnabledListener);
}
@Override
public void onViewDetachedFromWindow(View v) {
getWindowManager().removeCrossWindowBlurEnabledListener(
windowBlurEnabledListener);
}
});
}
private void updateWindowForBlurs(boolean blursEnabled) {
mWindowBackgroundDrawable.setAlpha(blursEnabled && mBackgroundBlurRadius > 0 ?
mWindowBackgroundAlphaWithBlur : mWindowBackgroundAlphaNoBlur);
getWindow().setDimAmount(blursEnabled && mBlurBehindRadius > 0 ?
mDimAmountWithBlur : mDimAmountNoBlur);
if (buildIsAtLeastS()) {
// Set the window background blur and blur behind radii
getWindow().setBackgroundBlurRadius(mBackgroundBlurRadius);
getWindow().getAttributes().setBlurBehindRadius(mBlurBehindRadius);
getWindow().setAttributes(getWindow().getAttributes());
}
}
private static boolean buildIsAtLeastS() {
return Build.VERSION.SDK_INT >= Build.VERSION_CODES.S;
}
}
Um abgerundete Ecken für das Fenster zu erstellen, definieren wir den Fensterhintergrund in res/drawable/window_background.xml als ShapeDrawable mit abgerundeten Ecken mit einem Radius von 20 dp:
<shape xmlns:android="http://schemas.android.com/apk/res/android" android:shape="rectangle" >
<corners android:radius="20dp"/>
<solid android:color="#AAAAAA"/>
</shape>
Bei der Fensterunkenntlichmachung wird der Inhalt des Fensters unter der Aktivität unkenntlich gemacht. Das unscharfe Bild wird unter diesem Aktivitätsfenster gezeichnet. Das Aktivitätsfenster muss also durchsichtig sein, damit die Unschärfe sichtbar ist. Um das Fenster halbtransparent zu machen, legen wir R.attr.windowIsTranslucent im Aktivitätsthema so fest:
<style name="Theme.BlurryDialog" parent="Theme.MaterialComponents.Dialog">
<item name="android:windowIsTranslucent">true</item>
</style>
OEMs und Partner
Damit die Fensterunkenntlichmachung auf einem Gerät funktioniert, muss der OEM erklären, dass das Gerät die Funktion unterstützt.
So prüfen Sie, ob Ihr Gerät Fensterunkenntlichmachungen unterstützt:
Achten Sie darauf, dass das Gerät die zusätzliche GPU-Belastung bewältigen kann. Geräte mit geringerer Leistung können die zusätzliche Belastung möglicherweise nicht bewältigen, was zu Frame-Ausfällen führen kann. Aktivieren Sie die Fensterunschärfe nur auf getesteten Geräten mit ausreichender GPU-Leistung.
Wenn Sie eine benutzerdefinierte Rendering-Engine verwenden, muss diese die Unkenntlichmachung implementieren. Die standardmäßige Render-Engine von Android 12 implementiert die Unkenntlichmachungslogik in
BlurFilter.cpp.
Wenn Sie sichergestellt haben, dass Ihr Gerät Fensterunschärfe unterstützt, legen Sie die folgenden Surface Flinger-sysprop-Einstellungen fest:
PRODUCT_VENDOR_PROPERTIES += \
ro.surface_flinger.supports_background_blur=1
Zertifizierungsstufe
So prüfen Sie, ob Ihr App-Fenster beim Wechsel zwischen aktiviertem und deaktiviertem Unkenntlichmachen ordnungsgemäß verarbeitet wird:
Öffnen Sie die Benutzeroberfläche mit Unkenntlichmachung.
Sie können die Fensterunkenntlichmachung aktivieren oder deaktivieren.
Prüfen Sie, ob die Benutzeroberfläche des Fensters wie erwartet zwischen einem unscharfen und einem scharfen Zustand wechselt.
Weichzeichnen von Fenstern aktivieren und deaktivieren
Wenn Sie testen möchten, wie die Fenster-UI mit dem Unkenntlichmachen von Fenstern gerendert wird, können Sie die Unkenntlichmachung mit einer der folgenden Methoden aktivieren oder deaktivieren:
Über die Entwickleroptionen:
Einstellungen -> System -> Entwickleroptionen -> Hardware beschleunigtes Rendering -> Unkenntlichmachung auf Fensterebene zulassen
Über das Terminal auf einem gerooteten Gerät:
adb shell wm disable-blur 1 # 1 disables window blurs, 0 allows them
Wenn Sie prüfen möchten, ob Ihr Gerät mit Android 12 oder höher Fensterunschärfe unterstützt und ob diese Funktion derzeit aktiviert ist, führen Sie adb shell wm disable-blur auf einem gerooteten Gerät aus.
Fehlerbehebung
Die folgenden Informationen können Ihnen bei der Fehlerbehebung während der Validierung helfen.
Keine Unschärfe
Prüfen Sie, ob die Unkenntlichmachungen derzeit aktiviert sind und von Ihrer Hardware unterstützt werden. Weitere Informationen finden Sie unter Weichzeichnen von Fenstern aktivieren und deaktivieren.
Achten Sie darauf, dass Sie eine halbtransparente Hintergrundfarbe für das Fenster festlegen. Ein undurchsichtiger Fensterhintergrund verdeckt den unscharfen Bereich.
Testgerät unterstützt keine Fensterunschärfe
- Testen Sie Ihre App im Android 12-Emulator. Informationen zum Einrichten eines Android-Emulators finden Sie unter Android-Emulator einrichten. Alle virtuellen Android-Geräte, die Sie mit dem Emulator erstellen, unterstützen die Fensterunschärfe.
Keine abgerundeten Ecken
- Legen Sie einen Zeichnbaren für den Fensterhintergrund fest, um abgerundete Ecken zu definieren. Mit diesem Drawable wird der Umriss des unscharfen Bereichs festgelegt.
Durch Aktualisieren der Entwickleroption werden keine Unkenntlichmachungen aktiviert
- Prüfe, ob sich das Gerät im Energiesparmodus befindet oder Multimedia-Tunneling verwendet. Auf einigen Fernsehern wird die Fensterunkenntlichmachung möglicherweise auch während der Videowiedergabe deaktiviert.
Weichgezeichneter Hintergrund wird im Vollbildmodus und nicht innerhalb des Fensters dargestellt
Prüfen Sie unter android:windowIsFloating, ob Ihr Fenster als „unverankert“ gekennzeichnet ist.
Achten Sie darauf, dass ein Zeichnen für den Fensterhintergrund festgelegt ist. Mit dieser Einstellung wird der Umriss des unscharfen Bereichs festgelegt.
Updates vom Listener werden nicht auf dem Bildschirm angewendet
- Die Listener-Aktualisierungen werden möglicherweise auf eine alte Fensterinstanz angewendet. Prüfen Sie, ob das Fenster mit dem richtigen Listener-Update zerstört und neu erstellt wird.