594 lines
21 KiB
Java
594 lines
21 KiB
Java
/*
|
|
* Copyright (C) 2023 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 android.service.notification;
|
|
|
|
import android.annotation.FlaggedApi;
|
|
import android.annotation.IntDef;
|
|
import android.annotation.NonNull;
|
|
import android.annotation.Nullable;
|
|
import android.annotation.TestApi;
|
|
import android.app.Flags;
|
|
import android.os.Parcel;
|
|
import android.os.Parcelable;
|
|
|
|
import java.lang.annotation.Retention;
|
|
import java.lang.annotation.RetentionPolicy;
|
|
import java.util.ArrayList;
|
|
import java.util.Collections;
|
|
import java.util.HashSet;
|
|
import java.util.Objects;
|
|
import java.util.Set;
|
|
|
|
/**
|
|
* Represents the set of device effects (affecting display and device behavior in general) that
|
|
* are applied whenever an {@link android.app.AutomaticZenRule} is active.
|
|
*/
|
|
@FlaggedApi(Flags.FLAG_MODES_API)
|
|
public final class ZenDeviceEffects implements Parcelable {
|
|
|
|
/**
|
|
* Enum for the user-modifiable fields in this object.
|
|
* @hide
|
|
*/
|
|
@IntDef(flag = true, prefix = { "FIELD_" }, value = {
|
|
FIELD_GRAYSCALE,
|
|
FIELD_SUPPRESS_AMBIENT_DISPLAY,
|
|
FIELD_DIM_WALLPAPER,
|
|
FIELD_NIGHT_MODE,
|
|
FIELD_DISABLE_AUTO_BRIGHTNESS,
|
|
FIELD_DISABLE_TAP_TO_WAKE,
|
|
FIELD_DISABLE_TILT_TO_WAKE,
|
|
FIELD_DISABLE_TOUCH,
|
|
FIELD_MINIMIZE_RADIO_USAGE,
|
|
FIELD_MAXIMIZE_DOZE,
|
|
FIELD_EXTRA_EFFECTS
|
|
})
|
|
@Retention(RetentionPolicy.SOURCE)
|
|
public @interface ModifiableField {}
|
|
|
|
/**
|
|
* @hide
|
|
*/
|
|
public static final int FIELD_GRAYSCALE = 1 << 0;
|
|
/**
|
|
* @hide
|
|
*/
|
|
public static final int FIELD_SUPPRESS_AMBIENT_DISPLAY = 1 << 1;
|
|
/**
|
|
* @hide
|
|
*/
|
|
public static final int FIELD_DIM_WALLPAPER = 1 << 2;
|
|
/**
|
|
* @hide
|
|
*/
|
|
public static final int FIELD_NIGHT_MODE = 1 << 3;
|
|
/**
|
|
* @hide
|
|
*/
|
|
public static final int FIELD_DISABLE_AUTO_BRIGHTNESS = 1 << 4;
|
|
/**
|
|
* @hide
|
|
*/
|
|
public static final int FIELD_DISABLE_TAP_TO_WAKE = 1 << 5;
|
|
/**
|
|
* @hide
|
|
*/
|
|
public static final int FIELD_DISABLE_TILT_TO_WAKE = 1 << 6;
|
|
/**
|
|
* @hide
|
|
*/
|
|
public static final int FIELD_DISABLE_TOUCH = 1 << 7;
|
|
/**
|
|
* @hide
|
|
*/
|
|
public static final int FIELD_MINIMIZE_RADIO_USAGE = 1 << 8;
|
|
/**
|
|
* @hide
|
|
*/
|
|
public static final int FIELD_MAXIMIZE_DOZE = 1 << 9;
|
|
/**
|
|
* @hide
|
|
*/
|
|
public static final int FIELD_EXTRA_EFFECTS = 1 << 10;
|
|
|
|
private static final int MAX_EFFECTS_LENGTH = 2_000; // characters
|
|
|
|
private final boolean mGrayscale;
|
|
private final boolean mSuppressAmbientDisplay;
|
|
private final boolean mDimWallpaper;
|
|
private final boolean mNightMode;
|
|
|
|
private final boolean mDisableAutoBrightness;
|
|
private final boolean mDisableTapToWake;
|
|
private final boolean mDisableTiltToWake;
|
|
private final boolean mDisableTouch;
|
|
private final boolean mMinimizeRadioUsage;
|
|
private final boolean mMaximizeDoze;
|
|
private final Set<String> mExtraEffects;
|
|
|
|
private ZenDeviceEffects(boolean grayscale, boolean suppressAmbientDisplay,
|
|
boolean dimWallpaper, boolean nightMode, boolean disableAutoBrightness,
|
|
boolean disableTapToWake, boolean disableTiltToWake, boolean disableTouch,
|
|
boolean minimizeRadioUsage, boolean maximizeDoze, Set<String> extraEffects) {
|
|
mGrayscale = grayscale;
|
|
mSuppressAmbientDisplay = suppressAmbientDisplay;
|
|
mDimWallpaper = dimWallpaper;
|
|
mNightMode = nightMode;
|
|
mDisableAutoBrightness = disableAutoBrightness;
|
|
mDisableTapToWake = disableTapToWake;
|
|
mDisableTiltToWake = disableTiltToWake;
|
|
mDisableTouch = disableTouch;
|
|
mMinimizeRadioUsage = minimizeRadioUsage;
|
|
mMaximizeDoze = maximizeDoze;
|
|
mExtraEffects = Collections.unmodifiableSet(extraEffects);
|
|
}
|
|
|
|
/** @hide */
|
|
@FlaggedApi(Flags.FLAG_MODES_API)
|
|
public void validate() {
|
|
int extraEffectsLength = 0;
|
|
for (String extraEffect : mExtraEffects) {
|
|
extraEffectsLength += extraEffect.length();
|
|
}
|
|
if (extraEffectsLength > MAX_EFFECTS_LENGTH) {
|
|
throw new IllegalArgumentException(
|
|
"Total size of extra effects must be at most " + MAX_EFFECTS_LENGTH
|
|
+ " characters");
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean equals(Object obj) {
|
|
if (!(obj instanceof final ZenDeviceEffects that)) return false;
|
|
if (obj == this) return true;
|
|
|
|
return this.mGrayscale == that.mGrayscale
|
|
&& this.mSuppressAmbientDisplay == that.mSuppressAmbientDisplay
|
|
&& this.mDimWallpaper == that.mDimWallpaper
|
|
&& this.mNightMode == that.mNightMode
|
|
&& this.mDisableAutoBrightness == that.mDisableAutoBrightness
|
|
&& this.mDisableTapToWake == that.mDisableTapToWake
|
|
&& this.mDisableTiltToWake == that.mDisableTiltToWake
|
|
&& this.mDisableTouch == that.mDisableTouch
|
|
&& this.mMinimizeRadioUsage == that.mMinimizeRadioUsage
|
|
&& this.mMaximizeDoze == that.mMaximizeDoze
|
|
&& Objects.equals(this.mExtraEffects, that.mExtraEffects);
|
|
}
|
|
|
|
@Override
|
|
public int hashCode() {
|
|
return Objects.hash(mGrayscale, mSuppressAmbientDisplay, mDimWallpaper, mNightMode,
|
|
mDisableAutoBrightness, mDisableTapToWake, mDisableTiltToWake, mDisableTouch,
|
|
mMinimizeRadioUsage, mMaximizeDoze, mExtraEffects);
|
|
}
|
|
|
|
@Override
|
|
public String toString() {
|
|
ArrayList<String> effects = new ArrayList<>(11);
|
|
if (mGrayscale) effects.add("grayscale");
|
|
if (mSuppressAmbientDisplay) effects.add("suppressAmbientDisplay");
|
|
if (mDimWallpaper) effects.add("dimWallpaper");
|
|
if (mNightMode) effects.add("nightMode");
|
|
if (mDisableAutoBrightness) effects.add("disableAutoBrightness");
|
|
if (mDisableTapToWake) effects.add("disableTapToWake");
|
|
if (mDisableTiltToWake) effects.add("disableTiltToWake");
|
|
if (mDisableTouch) effects.add("disableTouch");
|
|
if (mMinimizeRadioUsage) effects.add("minimizeRadioUsage");
|
|
if (mMaximizeDoze) effects.add("maximizeDoze");
|
|
if (mExtraEffects.size() > 0) {
|
|
effects.add("extraEffects=[" + String.join(",", mExtraEffects) + "]");
|
|
}
|
|
return "[" + String.join(", ", effects) + "]";
|
|
}
|
|
|
|
/** @hide */
|
|
public static String fieldsToString(@ModifiableField int bitmask) {
|
|
ArrayList<String> modified = new ArrayList<>();
|
|
if ((bitmask & FIELD_GRAYSCALE) != 0) {
|
|
modified.add("FIELD_GRAYSCALE");
|
|
}
|
|
if ((bitmask & FIELD_SUPPRESS_AMBIENT_DISPLAY) != 0) {
|
|
modified.add("FIELD_SUPPRESS_AMBIENT_DISPLAY");
|
|
}
|
|
if ((bitmask & FIELD_DIM_WALLPAPER) != 0) {
|
|
modified.add("FIELD_DIM_WALLPAPER");
|
|
}
|
|
if ((bitmask & FIELD_NIGHT_MODE) != 0) {
|
|
modified.add("FIELD_NIGHT_MODE");
|
|
}
|
|
if ((bitmask & FIELD_DISABLE_AUTO_BRIGHTNESS) != 0) {
|
|
modified.add("FIELD_DISABLE_AUTO_BRIGHTNESS");
|
|
}
|
|
if ((bitmask & FIELD_DISABLE_TAP_TO_WAKE) != 0) {
|
|
modified.add("FIELD_DISABLE_TAP_TO_WAKE");
|
|
}
|
|
if ((bitmask & FIELD_DISABLE_TILT_TO_WAKE) != 0) {
|
|
modified.add("FIELD_DISABLE_TILT_TO_WAKE");
|
|
}
|
|
if ((bitmask & FIELD_DISABLE_TOUCH) != 0) {
|
|
modified.add("FIELD_DISABLE_TOUCH");
|
|
}
|
|
if ((bitmask & FIELD_MINIMIZE_RADIO_USAGE) != 0) {
|
|
modified.add("FIELD_MINIMIZE_RADIO_USAGE");
|
|
}
|
|
if ((bitmask & FIELD_MAXIMIZE_DOZE) != 0) {
|
|
modified.add("FIELD_MAXIMIZE_DOZE");
|
|
}
|
|
if ((bitmask & FIELD_EXTRA_EFFECTS) != 0) {
|
|
modified.add("FIELD_EXTRA_EFFECTS");
|
|
}
|
|
return "{" + String.join(",", modified) + "}";
|
|
}
|
|
|
|
/**
|
|
* Whether the level of color saturation of the display should be set to minimum, effectively
|
|
* switching it to grayscale, while the rule is active.
|
|
*/
|
|
public boolean shouldDisplayGrayscale() {
|
|
return mGrayscale;
|
|
}
|
|
|
|
/**
|
|
* Whether the ambient (always-on) display feature should be disabled while the rule is active.
|
|
* This will have no effect if the device doesn't support always-on display or if it's not
|
|
* generally enabled.
|
|
*/
|
|
public boolean shouldSuppressAmbientDisplay() {
|
|
return mSuppressAmbientDisplay;
|
|
}
|
|
|
|
/** Whether the wallpaper should be dimmed while the rule is active. */
|
|
public boolean shouldDimWallpaper() {
|
|
return mDimWallpaper;
|
|
}
|
|
|
|
/** Whether night mode (aka dark theme) should be applied while the rule is active. */
|
|
public boolean shouldUseNightMode() {
|
|
return mNightMode;
|
|
}
|
|
|
|
/**
|
|
* Whether the display's automatic brightness adjustment should be disabled while the rule is
|
|
* active.
|
|
* @hide
|
|
*/
|
|
public boolean shouldDisableAutoBrightness() {
|
|
return mDisableAutoBrightness;
|
|
}
|
|
|
|
/**
|
|
* Whether "tap to wake" should be disabled while the rule is active.
|
|
* @hide
|
|
*/
|
|
public boolean shouldDisableTapToWake() {
|
|
return mDisableTapToWake;
|
|
}
|
|
|
|
/**
|
|
* Whether "tilt to wake" should be disabled while the rule is active.
|
|
* @hide
|
|
*/
|
|
public boolean shouldDisableTiltToWake() {
|
|
return mDisableTiltToWake;
|
|
}
|
|
|
|
/**
|
|
* Whether touch interactions should be disabled while the rule is active.
|
|
* @hide
|
|
*/
|
|
public boolean shouldDisableTouch() {
|
|
return mDisableTouch;
|
|
}
|
|
|
|
/**
|
|
* Whether radio (wi-fi, LTE, etc) traffic, and its attendant battery consumption, should be
|
|
* minimized while the rule is active.
|
|
* @hide
|
|
*/
|
|
public boolean shouldMinimizeRadioUsage() {
|
|
return mMinimizeRadioUsage;
|
|
}
|
|
|
|
/**
|
|
* Whether Doze should be enhanced (e.g. with more aggressive activation, or less frequent
|
|
* maintenance windows) while the rule is active.
|
|
* @hide
|
|
*/
|
|
public boolean shouldMaximizeDoze() {
|
|
return mMaximizeDoze;
|
|
}
|
|
|
|
/**
|
|
* (Immutable) set of extra effects to be applied while the rule is active. Extra effects are
|
|
* not used in AOSP, but OEMs may add support for them by providing a custom
|
|
* {@link DeviceEffectsApplier}.
|
|
* @hide
|
|
*/
|
|
@TestApi
|
|
@NonNull
|
|
public Set<String> getExtraEffects() {
|
|
return mExtraEffects;
|
|
}
|
|
|
|
/**
|
|
* Whether any of the effects are set up.
|
|
* @hide
|
|
*/
|
|
public boolean hasEffects() {
|
|
return mGrayscale || mSuppressAmbientDisplay || mDimWallpaper || mNightMode
|
|
|| mDisableAutoBrightness || mDisableTapToWake || mDisableTiltToWake
|
|
|| mDisableTouch || mMinimizeRadioUsage || mMaximizeDoze
|
|
|| mExtraEffects.size() > 0;
|
|
}
|
|
|
|
/** {@link Parcelable.Creator} that instantiates {@link ZenDeviceEffects} objects. */
|
|
@NonNull
|
|
public static final Creator<ZenDeviceEffects> CREATOR = new Creator<ZenDeviceEffects>() {
|
|
@Override
|
|
public ZenDeviceEffects createFromParcel(Parcel in) {
|
|
return new ZenDeviceEffects(in.readBoolean(),
|
|
in.readBoolean(), in.readBoolean(), in.readBoolean(), in.readBoolean(),
|
|
in.readBoolean(), in.readBoolean(), in.readBoolean(), in.readBoolean(),
|
|
in.readBoolean(),
|
|
Set.of(in.readArray(String.class.getClassLoader(), String.class)));
|
|
}
|
|
|
|
@Override
|
|
public ZenDeviceEffects[] newArray(int size) {
|
|
return new ZenDeviceEffects[size];
|
|
}
|
|
};
|
|
|
|
@Override
|
|
public int describeContents() {
|
|
return 0;
|
|
}
|
|
|
|
@Override
|
|
public void writeToParcel(@NonNull Parcel dest, int flags) {
|
|
dest.writeBoolean(mGrayscale);
|
|
dest.writeBoolean(mSuppressAmbientDisplay);
|
|
dest.writeBoolean(mDimWallpaper);
|
|
dest.writeBoolean(mNightMode);
|
|
dest.writeBoolean(mDisableAutoBrightness);
|
|
dest.writeBoolean(mDisableTapToWake);
|
|
dest.writeBoolean(mDisableTiltToWake);
|
|
dest.writeBoolean(mDisableTouch);
|
|
dest.writeBoolean(mMinimizeRadioUsage);
|
|
dest.writeBoolean(mMaximizeDoze);
|
|
dest.writeArray(mExtraEffects.toArray(new String[0]));
|
|
}
|
|
|
|
/** Builder class for {@link ZenDeviceEffects} objects. */
|
|
@FlaggedApi(Flags.FLAG_MODES_API)
|
|
public static final class Builder {
|
|
|
|
private boolean mGrayscale;
|
|
private boolean mSuppressAmbientDisplay;
|
|
private boolean mDimWallpaper;
|
|
private boolean mNightMode;
|
|
private boolean mDisableAutoBrightness;
|
|
private boolean mDisableTapToWake;
|
|
private boolean mDisableTiltToWake;
|
|
private boolean mDisableTouch;
|
|
private boolean mMinimizeRadioUsage;
|
|
private boolean mMaximizeDoze;
|
|
private final HashSet<String> mExtraEffects = new HashSet<>();
|
|
|
|
/**
|
|
* Instantiates a new {@link ZenPolicy.Builder} with all effects set to default (disabled).
|
|
*/
|
|
public Builder() {
|
|
}
|
|
|
|
/**
|
|
* Instantiates a new {@link ZenPolicy.Builder} with all effects set to their corresponding
|
|
* values in the supplied {@link ZenDeviceEffects}.
|
|
*/
|
|
public Builder(@NonNull ZenDeviceEffects zenDeviceEffects) {
|
|
mGrayscale = zenDeviceEffects.shouldDisplayGrayscale();
|
|
mSuppressAmbientDisplay = zenDeviceEffects.shouldSuppressAmbientDisplay();
|
|
mDimWallpaper = zenDeviceEffects.shouldDimWallpaper();
|
|
mNightMode = zenDeviceEffects.shouldUseNightMode();
|
|
mDisableAutoBrightness = zenDeviceEffects.shouldDisableAutoBrightness();
|
|
mDisableTapToWake = zenDeviceEffects.shouldDisableTapToWake();
|
|
mDisableTiltToWake = zenDeviceEffects.shouldDisableTiltToWake();
|
|
mDisableTouch = zenDeviceEffects.shouldDisableTouch();
|
|
mMinimizeRadioUsage = zenDeviceEffects.shouldMinimizeRadioUsage();
|
|
mMaximizeDoze = zenDeviceEffects.shouldMaximizeDoze();
|
|
mExtraEffects.addAll(zenDeviceEffects.getExtraEffects());
|
|
}
|
|
|
|
/**
|
|
* Sets whether the level of color saturation of the display should be set to minimum,
|
|
* effectively switching it to grayscale, while the rule is active.
|
|
*/
|
|
@NonNull
|
|
public Builder setShouldDisplayGrayscale(boolean grayscale) {
|
|
mGrayscale = grayscale;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets whether the ambient (always-on) display feature should be disabled while the rule
|
|
* is active. This will have no effect if the device doesn't support always-on display or if
|
|
* it's not generally enabled.
|
|
*/
|
|
@NonNull
|
|
public Builder setShouldSuppressAmbientDisplay(boolean suppressAmbientDisplay) {
|
|
mSuppressAmbientDisplay = suppressAmbientDisplay;
|
|
return this;
|
|
}
|
|
|
|
/** Sets whether the wallpaper should be dimmed while the rule is active. */
|
|
@NonNull
|
|
public Builder setShouldDimWallpaper(boolean dimWallpaper) {
|
|
mDimWallpaper = dimWallpaper;
|
|
return this;
|
|
}
|
|
|
|
/** Sets whether night mode (aka dark theme) should be applied while the rule is active. */
|
|
@NonNull
|
|
public Builder setShouldUseNightMode(boolean nightMode) {
|
|
mNightMode = nightMode;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets whether the display's automatic brightness adjustment should be disabled while the
|
|
* rule is active.
|
|
* @hide
|
|
*/
|
|
@NonNull
|
|
public Builder setShouldDisableAutoBrightness(boolean disableAutoBrightness) {
|
|
mDisableAutoBrightness = disableAutoBrightness;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets whether "tap to wake" should be disabled while the rule is active.
|
|
* @hide
|
|
*/
|
|
@NonNull
|
|
public Builder setShouldDisableTapToWake(boolean disableTapToWake) {
|
|
mDisableTapToWake = disableTapToWake;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets whether "tilt to wake" should be disabled while the rule is active.
|
|
* @hide
|
|
*/
|
|
@NonNull
|
|
public Builder setShouldDisableTiltToWake(boolean disableTiltToWake) {
|
|
mDisableTiltToWake = disableTiltToWake;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets whether touch interactions should be disabled while the rule is active.
|
|
* @hide
|
|
*/
|
|
@NonNull
|
|
public Builder setShouldDisableTouch(boolean disableTouch) {
|
|
mDisableTouch = disableTouch;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets whether radio (wi-fi, LTE, etc) traffic, and its attendant battery consumption,
|
|
* should be minimized while the rule is active.
|
|
* @hide
|
|
*/
|
|
@NonNull
|
|
public Builder setShouldMinimizeRadioUsage(boolean minimizeRadioUsage) {
|
|
mMinimizeRadioUsage = minimizeRadioUsage;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets whether Doze should be enhanced (e.g. with more aggressive activation, or less
|
|
* frequent maintenance windows) while the rule is active.
|
|
* @hide
|
|
*/
|
|
@NonNull
|
|
public Builder setShouldMaximizeDoze(boolean maximizeDoze) {
|
|
mMaximizeDoze = maximizeDoze;
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Sets the extra effects to be applied while the rule is active. Extra effects are not
|
|
* used in AOSP, but OEMs may add support for them by providing a custom
|
|
* {@link DeviceEffectsApplier}.
|
|
*
|
|
* @apiNote The total size of the extra effects (concatenation of strings) is limited.
|
|
*
|
|
* @hide
|
|
*/
|
|
@TestApi
|
|
@NonNull
|
|
public Builder setExtraEffects(@NonNull Set<String> extraEffects) {
|
|
Objects.requireNonNull(extraEffects);
|
|
mExtraEffects.clear();
|
|
mExtraEffects.addAll(extraEffects);
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Adds the supplied extra effects to the set to be applied while the rule is active.
|
|
* Extra effects are not used in AOSP, but OEMs may add support for them by providing a
|
|
* custom {@link DeviceEffectsApplier}.
|
|
*
|
|
* @apiNote The total size of the extra effects (concatenation of strings) is limited.
|
|
*
|
|
* @hide
|
|
*/
|
|
@NonNull
|
|
public Builder addExtraEffects(@NonNull Set<String> extraEffects) {
|
|
mExtraEffects.addAll(Objects.requireNonNull(extraEffects));
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Adds the supplied extra effect to the set to be applied while the rule is active.
|
|
* Extra effects are not used in AOSP, but OEMs may add support for them by providing a
|
|
* custom {@link DeviceEffectsApplier}.
|
|
*
|
|
* @apiNote The total size of the extra effects (concatenation of strings) is limited.
|
|
*
|
|
* @hide
|
|
*/
|
|
@NonNull
|
|
public Builder addExtraEffect(@NonNull String extraEffect) {
|
|
mExtraEffects.add(Objects.requireNonNull(extraEffect));
|
|
return this;
|
|
}
|
|
|
|
/**
|
|
* Applies the effects that are {@code true} on the supplied {@link ZenDeviceEffects} to
|
|
* this builder (essentially logically-ORing the effect set).
|
|
* @hide
|
|
*/
|
|
@NonNull
|
|
public Builder add(@Nullable ZenDeviceEffects effects) {
|
|
if (effects == null) return this;
|
|
if (effects.shouldDisplayGrayscale()) setShouldDisplayGrayscale(true);
|
|
if (effects.shouldSuppressAmbientDisplay()) setShouldSuppressAmbientDisplay(true);
|
|
if (effects.shouldDimWallpaper()) setShouldDimWallpaper(true);
|
|
if (effects.shouldUseNightMode()) setShouldUseNightMode(true);
|
|
if (effects.shouldDisableAutoBrightness()) setShouldDisableAutoBrightness(true);
|
|
if (effects.shouldDisableTapToWake()) setShouldDisableTapToWake(true);
|
|
if (effects.shouldDisableTiltToWake()) setShouldDisableTiltToWake(true);
|
|
if (effects.shouldDisableTouch()) setShouldDisableTouch(true);
|
|
if (effects.shouldMinimizeRadioUsage()) setShouldMinimizeRadioUsage(true);
|
|
if (effects.shouldMaximizeDoze()) setShouldMaximizeDoze(true);
|
|
addExtraEffects(effects.getExtraEffects());
|
|
return this;
|
|
}
|
|
|
|
/** Builds a {@link ZenDeviceEffects} object based on the builder's state. */
|
|
@NonNull
|
|
public ZenDeviceEffects build() {
|
|
return new ZenDeviceEffects(mGrayscale,
|
|
mSuppressAmbientDisplay, mDimWallpaper, mNightMode, mDisableAutoBrightness,
|
|
mDisableTapToWake, mDisableTiltToWake, mDisableTouch, mMinimizeRadioUsage,
|
|
mMaximizeDoze, mExtraEffects);
|
|
}
|
|
}
|
|
}
|