KeyguardSensorInjector from MIUI 13 (lisa)

KeyguardSensorInjector.java

package com.android.keyguard.injector;

import android.content.Context;
import android.hardware.Sensor;
import android.hardware.SensorEvent;
import android.hardware.SensorEventListener;
import android.hardware.SensorManager;
import android.os.Handler;
import android.os.Looper;
import android.os.PowerManager;
import android.os.SystemClock;
import android.os.SystemProperties;
import android.util.Log;
import android.util.Slog;
import android.view.Display;
import android.view.WindowManager;
import com.android.keyguard.KeyguardUpdateMonitor;
import com.android.keyguard.MiuiKeyguardUpdateMonitorCallback;
import com.android.keyguard.analytics.AnalyticsHelper;
import com.android.keyguard.injector.KeyguardSensorInjector;
import com.android.keyguard.utils.MiuiKeyguardUtils;
import com.android.keyguard.wallpaper.MiuiKeyguardWallpaperControllerImpl;
import com.android.systemui.Dependency;
import com.android.systemui.R;
import com.android.systemui.UiOffloadThread;
import com.android.systemui.keyguard.KeyguardViewMediator;
import com.android.systemui.keyguard.WakefulnessLifecycle;
import com.miui.systemui.SettingsObserver;
import com.miui.systemui.util.CommonUtil;
import com.miui.systemui.util.MiuiTextUtils;
import java.util.Objects;
import java.util.concurrent.Executor;
import kotlin.collections.ArraysKt___ArraysKt;
import kotlin.jvm.internal.Intrinsics;
import kotlin.text.StringsKt__StringsJVMKt;
import miui.os.Build;
import miui.util.ProximitySensorWrapper;
import org.jetbrains.annotations.NotNull;
import org.jetbrains.annotations.Nullable;
/* compiled from: KeyguardSensorInjector.kt */
/* loaded from: classes.dex */
public final class KeyguardSensorInjector implements SettingsObserver.Callback, WakefulnessLifecycle.Observer {
    @NotNull
    private final Context mContext;
    @Nullable
    private Display mDisplay;
    private boolean mIsDeviceSupportLargeAreaTouch;
    @NotNull
    private final KeyguardUpdateMonitor mKeyguardUpdateMonitor;
    @NotNull
    private final MiuiKeyguardUpdateMonitorCallback mKeyguardUpdateMonitorCallback;
    @NotNull
    private final KeyguardViewMediator mKeyguardViewMediator;
    @Nullable
    private Sensor mLargeAreaTouchSensor;
    private boolean mPickupSensorSettingsOpened;
    @NotNull
    private final PowerManager mPowerManager;
    @Nullable
    private ProximitySensorChangeCallback mProximitySensorChangeCallback;
    @Nullable
    private ProximitySensorWrapper mProximitySensorWrapper;
    @NotNull
    private final SensorManager mSensorManager;
    @NotNull
    private final Executor mUiBgExecutor;
    @Nullable
    private Sensor mWakeupAndSleepSensor;
    private boolean mWakeupByPickUp;
    private final boolean sIsEllipticProximity;
    @NotNull
    private final String TAG = "KeyguardSensorInjector";
    private final UiOffloadThread mUiOffloadThread = (UiOffloadThread) Dependency.get(UiOffloadThread.class);
    @NotNull
    private final Handler mHandler = new Handler(Looper.getMainLooper());
    @NotNull
    private final String SCREEN_OPEN_REASON = "keyguard_screen_on_reason";
    @NotNull
    private final String SCREEN_OFF_REASON = "keyguard_screen_off_reason";
    private final int LARGE_AREA_TOUCH_SENSOR = 33171031;
    @NotNull
    private final String LARGE_AREA_TOUCH_SENSOR_NAME = "Touch Sensor";
    private final int WAKEUP_AND_SLEEP_SENSOR_XIAOMI = 33171036;
    private final int WAKEUP_AND_SLEEP_SENSOR_MTK = 22;
    @NotNull
    private final String WAKEUP_AND_SLEEP_SENSOR_NAME1 = "oem7 Pick Up Gesture";
    @NotNull
    private final String WAKEUP_AND_SLEEP_SENSOR_NAME2 = "pickup  Wakeup";
    @NotNull
    private final Runnable mUnregisterProximitySensorRunnable = new Runnable() { // from class: com.android.keyguard.injector.KeyguardSensorInjector$mUnregisterProximitySensorRunnable$1
        @Override // java.lang.Runnable
        public final void run() {
            KeyguardSensorInjector.this.unregisterProximitySensor();
        }
    };
    @NotNull
    private final ProximitySensorWrapper.ProximitySensorChangeListener mProximitySensorListener = new ProximitySensorWrapper.ProximitySensorChangeListener() { // from class: com.android.keyguard.injector.KeyguardSensorInjector$mProximitySensorListener$1
        public final void onSensorChanged(boolean z) {
            KeyguardSensorInjector.ProximitySensorChangeCallback proximitySensorChangeCallback;
            KeyguardSensorInjector.ProximitySensorChangeCallback proximitySensorChangeCallback2;
            proximitySensorChangeCallback = KeyguardSensorInjector.this.mProximitySensorChangeCallback;
            if (proximitySensorChangeCallback != null) {
                AnalyticsHelper.getInstance(KeyguardSensorInjector.this.getMContext()).recordKeyguardProximitySensor(z);
                proximitySensorChangeCallback2 = KeyguardSensorInjector.this.mProximitySensorChangeCallback;
                Intrinsics.checkNotNull(proximitySensorChangeCallback2);
                proximitySensorChangeCallback2.onChange(z);
            }
            KeyguardSensorInjector.this.unregisterProximitySensor();
        }
    };
    @NotNull
    private final SensorEventListener mPickupSensorListener = new SensorEventListener() { // from class: com.android.keyguard.injector.KeyguardSensorInjector$mPickupSensorListener$1
        @Override // android.hardware.SensorEventListener
        public void onAccuracyChanged(@NotNull Sensor sensor, int i) {
            Intrinsics.checkNotNullParameter(sensor, "sensor");
        }

        @Override // android.hardware.SensorEventListener
        public void onSensorChanged(@NotNull SensorEvent event) {
            boolean z;
            String str;
            Display display;
            Display display2;
            String str2;
            Intrinsics.checkNotNullParameter(event, "event");
            float[] fArr = event.values;
            boolean z2 = true;
            if (fArr != null) {
                if (fArr[0] == 1.0f) {
                    display2 = KeyguardSensorInjector.this.mDisplay;
                    Intrinsics.checkNotNull(display2);
                    if ((display2.getState() != 2 || !((MiuiKeyguardWallpaperControllerImpl) Dependency.get(MiuiKeyguardWallpaperControllerImpl.class)).isAodUsingSuperWallpaper()) && !KeyguardSensorInjector.this.getMKeyguardViewMediator().isLidShowing()) {
                        KeyguardSensorInjector.this.getMPowerManager().wakeUp(SystemClock.uptimeMillis(), "com.android.systemui:PICK_UP");
                        KeyguardSensorInjector.this.mWakeupByPickUp = true;
                        String tag = KeyguardSensorInjector.this.getTAG();
                        str2 = KeyguardSensorInjector.this.SCREEN_OPEN_REASON;
                        Slog.i(tag, Intrinsics.stringPlus(str2, ":pick up"));
                        return;
                    }
                    return;
                }
            }
            if (fArr != null) {
                if (!(fArr[0] == 2.0f)) {
                    if (fArr[0] != 0.0f) {
                        z2 = false;
                    }
                    if (!z2) {
                        return;
                    }
                }
                z = KeyguardSensorInjector.this.mWakeupByPickUp;
                if (!z) {
                    return;
                }
                if ((KeyguardSensorInjector.this.getMKeyguardViewMediator().isShowingAndNotOccluded() || MiuiKeyguardUtils.showMXTelcelLockScreen(KeyguardSensorInjector.this.getMContext())) && !KeyguardSensorInjector.this.getMKeyguardViewMediator().isLidShowing()) {
                    String tag2 = KeyguardSensorInjector.this.getTAG();
                    str = KeyguardSensorInjector.this.SCREEN_OFF_REASON;
                    Slog.i(tag2, Intrinsics.stringPlus(str, ":put down"));
                    KeyguardSensorInjector.this.getMPowerManager().goToSleep(SystemClock.uptimeMillis());
                    display = KeyguardSensorInjector.this.mDisplay;
                    Intrinsics.checkNotNull(display);
                    display.getState();
                }
            }
        }
    };
    @NotNull
    private final SensorEventListener mLargeAreaTouchSensorListener = new SensorEventListener() { // from class: com.android.keyguard.injector.KeyguardSensorInjector$mLargeAreaTouchSensorListener$1
        @Override // android.hardware.SensorEventListener
        public void onAccuracyChanged(@NotNull Sensor sensor, int i) {
            Intrinsics.checkNotNullParameter(sensor, "sensor");
        }

        @Override // android.hardware.SensorEventListener
        public void onSensorChanged(@NotNull SensorEvent event) {
            String str;
            Intrinsics.checkNotNullParameter(event, "event");
            float[] fArr = event.values;
            if (fArr != null) {
                boolean z = false;
                if (fArr[0] == 1.0f) {
                    z = true;
                }
                if (z && !KeyguardSensorInjector.this.getMKeyguardViewMediator().isHiding() && KeyguardSensorInjector.this.getMKeyguardViewMediator().isShowing() && !((KeyguardUpdateMonitorInjector) Dependency.get(KeyguardUpdateMonitorInjector.class)).isFingerprintUnlock()) {
                    if (!KeyguardSensorInjector.this.getMKeyguardViewMediator().isOccluded() || !MiuiKeyguardUtils.keepScreenOnWhenLargeAreaTouch(KeyguardSensorInjector.this.getMContext())) {
                        String tag = KeyguardSensorInjector.this.getTAG();
                        str = KeyguardSensorInjector.this.SCREEN_OFF_REASON;
                        Slog.i(tag, Intrinsics.stringPlus(str, ":large area touch"));
                        KeyguardSensorInjector.this.getMPowerManager().goToSleep(SystemClock.uptimeMillis());
                    }
                }
            }
        }
    };

    /* compiled from: KeyguardSensorInjector.kt */
    /* loaded from: classes.dex */
    public interface ProximitySensorChangeCallback {
        void onChange(boolean z);
    }

    public KeyguardSensorInjector(@NotNull Context mContext, @NotNull KeyguardViewMediator mKeyguardViewMediator, @NotNull PowerManager mPowerManager, @NotNull KeyguardUpdateMonitor mKeyguardUpdateMonitor, @NotNull WakefulnessLifecycle wakefulnessLifecycle, @NotNull Executor mUiBgExecutor) {
        Intrinsics.checkNotNullParameter(mContext, "mContext");
        Intrinsics.checkNotNullParameter(mKeyguardViewMediator, "mKeyguardViewMediator");
        Intrinsics.checkNotNullParameter(mPowerManager, "mPowerManager");
        Intrinsics.checkNotNullParameter(mKeyguardUpdateMonitor, "mKeyguardUpdateMonitor");
        Intrinsics.checkNotNullParameter(wakefulnessLifecycle, "wakefulnessLifecycle");
        Intrinsics.checkNotNullParameter(mUiBgExecutor, "mUiBgExecutor");
        this.mContext = mContext;
        this.mKeyguardViewMediator = mKeyguardViewMediator;
        this.mPowerManager = mPowerManager;
        this.mKeyguardUpdateMonitor = mKeyguardUpdateMonitor;
        this.mUiBgExecutor = mUiBgExecutor;
        Object systemService = mContext.getSystemService("sensor");
        Objects.requireNonNull(systemService, "null cannot be cast to non-null type android.hardware.SensorManager");
        this.mSensorManager = (SensorManager) systemService;
        MiuiKeyguardUpdateMonitorCallback keyguardSensorInjector$mKeyguardUpdateMonitorCallback$1 = new MiuiKeyguardUpdateMonitorCallback() { // from class: com.android.keyguard.injector.KeyguardSensorInjector$mKeyguardUpdateMonitorCallback$1
            @Override // com.android.keyguard.KeyguardUpdateMonitorCallback
            public void onKeyguardBouncerChanged(boolean z) {
                KeyguardSensorInjector.this.disableFullScreenGesture();
            }

            @Override // com.android.keyguard.MiuiKeyguardUpdateMonitorCallback
            public void onKeyguardShowingChanged(boolean z) {
                if (!z) {
                    KeyguardSensorInjector.this.unregisterPickupSensor();
                    KeyguardSensorInjector.this.unregisterProximitySensor();
                    KeyguardSensorInjector.this.unregisterLargeAreaTouchSensor();
                }
            }
        };
        this.mKeyguardUpdateMonitorCallback = keyguardSensorInjector$mKeyguardUpdateMonitorCallback$1;
        mKeyguardUpdateMonitor.registerCallback(keyguardSensorInjector$mKeyguardUpdateMonitorCallback$1);
        wakefulnessLifecycle.addObserver(this);
        boolean z = false;
        this.sIsEllipticProximity = (SystemProperties.getBoolean("ro.vendor.audio.us.proximity", false) || SystemProperties.getBoolean("ro.audio.us.proximity", false)) ? true : z;
    }

    @NotNull
    public final Context getMContext() {
        return this.mContext;
    }

    @NotNull
    public final KeyguardViewMediator getMKeyguardViewMediator() {
        return this.mKeyguardViewMediator;
    }

    @NotNull
    public final PowerManager getMPowerManager() {
        return this.mPowerManager;
    }

    @NotNull
    public final String getTAG() {
        return this.TAG;
    }

    public final void setupSensors() {
        Object systemService = this.mContext.getSystemService("window");
        Objects.requireNonNull(systemService, "null cannot be cast to non-null type android.view.WindowManager");
        this.mDisplay = ((WindowManager) systemService).getDefaultDisplay();
        this.mIsDeviceSupportLargeAreaTouch = isDeviceSupportLargeAreaTouch();
        ((SettingsObserver) Dependency.get(SettingsObserver.class)).addCallbackForType(this, 1, "pick_up_gesture_wakeup_mode");
    }

    @Override // com.android.systemui.keyguard.WakefulnessLifecycle.Observer
    public void onStartedWakingUp() {
        registerLargeAreaTouchSensor();
    }

    @Override // com.android.systemui.keyguard.WakefulnessLifecycle.Observer
    public void onStartedGoingToSleep() {
        this.mWakeupByPickUp = false;
        registerPickupSensor();
    }

    @Override // com.android.systemui.keyguard.WakefulnessLifecycle.Observer
    public void onFinishedGoingToSleep() {
        unregisterLargeAreaTouchSensor();
        unregisterProximitySensor();
    }

    public final void registerProximitySensor(@Nullable ProximitySensorChangeCallback proximitySensorChangeCallback) {
        if (this.mProximitySensorWrapper == null) {
            ProximitySensorWrapper proximitySensorWrapper = new ProximitySensorWrapper(this.mContext);
            this.mProximitySensorWrapper = proximitySensorWrapper;
            Intrinsics.checkNotNull(proximitySensorWrapper);
            proximitySensorWrapper.registerListener(this.mProximitySensorListener);
            this.mProximitySensorChangeCallback = proximitySensorChangeCallback;
            this.mHandler.postDelayed(this.mUnregisterProximitySensorRunnable, 2000L);
        }
    }

    public final void unregisterProximitySensor() {
        if (this.mProximitySensorWrapper != null) {
            this.mHandler.removeCallbacks(this.mUnregisterProximitySensorRunnable);
            ProximitySensorWrapper proximitySensorWrapper = this.mProximitySensorWrapper;
            Intrinsics.checkNotNull(proximitySensorWrapper);
            proximitySensorWrapper.unregisterAllListeners();
            this.mProximitySensorWrapper = null;
            this.mProximitySensorChangeCallback = null;
        }
    }

    /* JADX WARN: Code restructure failed: missing block: B:19:0x0039, code lost:
        if (r0 != false) goto L_0x003b;
     */
    /* JADX WARN: Removed duplicated region for block: B:26:0x0059  */
    /* JADX WARN: Removed duplicated region for block: B:29:0x005d  */
    /* JADX WARN: Removed duplicated region for block: B:32:? A[RETURN, SYNTHETIC] */
    /*
        Code decompiled incorrectly, please refer to instructions dump.
    */
    private final void registerPickupSensor() {
        Sensor defaultSensor;
        boolean equals;
        boolean equals2;
        if (this.mWakeupAndSleepSensor == null && this.mPickupSensorSettingsOpened) {
            boolean z = true;
            Sensor defaultSensor2 = this.mSensorManager.getDefaultSensor(this.WAKEUP_AND_SLEEP_SENSOR_XIAOMI, true);
            this.mWakeupAndSleepSensor = defaultSensor2;
            if (defaultSensor2 != null) {
                String str = null;
                equals = StringsKt__StringsJVMKt.equals(this.WAKEUP_AND_SLEEP_SENSOR_NAME1, defaultSensor2 == null ? null : defaultSensor2.getName(), true);
                if (!equals) {
                    String str2 = this.WAKEUP_AND_SLEEP_SENSOR_NAME2;
                    Sensor sensor = this.mWakeupAndSleepSensor;
                    if (sensor != null) {
                        str = sensor.getName();
                    }
                    equals2 = StringsKt__StringsJVMKt.equals(str2, str, true);
                }
                z = true;
                if (!z && ((KeyguardSensorInjector) Dependency.get(KeyguardSensorInjector.class)).isSupportPickupByMTK()) {
                    defaultSensor = this.mSensorManager.getDefaultSensor(this.WAKEUP_AND_SLEEP_SENSOR_MTK, true);
                    this.mWakeupAndSleepSensor = defaultSensor;
                    if (defaultSensor == null) {
                        z = false;
                    }
                }
                if (!z) {
                    this.mUiOffloadThread.submit(new Runnable() { // from class: com.android.keyguard.injector.KeyguardSensorInjector$registerPickupSensor$2
                        @Override // java.lang.Runnable
                        public final void run() {
                            Sensor sensor2;
                            SensorManager sensorManager;
                            SensorEventListener sensorEventListener;
                            Sensor sensor3;
                            sensor2 = KeyguardSensorInjector.this.mWakeupAndSleepSensor;
                            if (sensor2 != null) {
                                Slog.i(KeyguardSensorInjector.this.getTAG(), "register pickup sensor");
                                sensorManager = KeyguardSensorInjector.this.mSensorManager;
                                sensorEventListener = KeyguardSensorInjector.this.mPickupSensorListener;
                                sensor3 = KeyguardSensorInjector.this.mWakeupAndSleepSensor;
                                sensorManager.registerListener(sensorEventListener, sensor3, 3);
                            }
                        }
                    });
                    return;
                }
                return;
            }
            z = false;
            if (!z) {
                defaultSensor = this.mSensorManager.getDefaultSensor(this.WAKEUP_AND_SLEEP_SENSOR_MTK, true);
                this.mWakeupAndSleepSensor = defaultSensor;
                if (defaultSensor == null) {
                }
            }
            if (!z) {
            }
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public final void unregisterPickupSensor() {
        this.mUiOffloadThread.submit(new Runnable() { // from class: com.android.keyguard.injector.KeyguardSensorInjector$unregisterPickupSensor$1
            @Override // java.lang.Runnable
            public final void run() {
                SensorManager sensorManager;
                SensorEventListener sensorEventListener;
                Slog.i(KeyguardSensorInjector.this.getTAG(), "unregister pickup sensor");
                KeyguardSensorInjector.this.mWakeupAndSleepSensor = null;
                sensorManager = KeyguardSensorInjector.this.mSensorManager;
                if (sensorManager != null) {
                    sensorEventListener = KeyguardSensorInjector.this.mPickupSensorListener;
                    sensorManager.unregisterListener(sensorEventListener);
                }
            }
        });
    }

    @Override // com.miui.systemui.SettingsObserver.Callback
    public void onContentChanged(@Nullable String str, @Nullable String str2) {
        if (Intrinsics.areEqual("pick_up_gesture_wakeup_mode", str)) {
            MiuiTextUtils miuiTextUtils = MiuiTextUtils.INSTANCE;
            this.mPickupSensorSettingsOpened = MiuiTextUtils.parseBoolean(str2);
            String str3 = this.TAG;
            Log.d(str3, " onContentChanged mPickupGestureWakeupOpened:" + this.mPickupSensorSettingsOpened + "  newValue:" + ((Object) str2));
            if (this.mPickupSensorSettingsOpened) {
                registerPickupSensor();
            } else {
                unregisterPickupSensor();
            }
        }
    }

    public final void registerLargeAreaTouchSensor() {
        if (shouldRegisterLargeAreaSensor()) {
            this.mUiOffloadThread.submit(new Runnable() { // from class: com.android.keyguard.injector.KeyguardSensorInjector$registerLargeAreaTouchSensor$1
                @Override // java.lang.Runnable
                public final void run() {
                    boolean shouldRegisterLargeAreaSensor;
                    SensorManager sensorManager;
                    int i;
                    SensorManager sensorManager2;
                    SensorEventListener sensorEventListener;
                    Sensor sensor;
                    shouldRegisterLargeAreaSensor = KeyguardSensorInjector.this.shouldRegisterLargeAreaSensor();
                    if (shouldRegisterLargeAreaSensor) {
                        Slog.i(KeyguardSensorInjector.this.getTAG(), "register large area touch sensor");
                        KeyguardSensorInjector keyguardSensorInjector = KeyguardSensorInjector.this;
                        sensorManager = keyguardSensorInjector.mSensorManager;
                        i = KeyguardSensorInjector.this.LARGE_AREA_TOUCH_SENSOR;
                        keyguardSensorInjector.mLargeAreaTouchSensor = sensorManager.getDefaultSensor(i);
                        sensorManager2 = KeyguardSensorInjector.this.mSensorManager;
                        sensorEventListener = KeyguardSensorInjector.this.mLargeAreaTouchSensorListener;
                        sensor = KeyguardSensorInjector.this.mLargeAreaTouchSensor;
                        sensorManager2.registerListener(sensorEventListener, sensor, 3);
                    }
                }
            });
        }
    }

    public final void unregisterLargeAreaTouchSensor() {
        if (this.mIsDeviceSupportLargeAreaTouch) {
            this.mUiOffloadThread.submit(new Runnable() { // from class: com.android.keyguard.injector.KeyguardSensorInjector$unregisterLargeAreaTouchSensor$1
                @Override // java.lang.Runnable
                public final void run() {
                    SensorManager sensorManager;
                    Sensor sensor;
                    SensorManager sensorManager2;
                    SensorEventListener sensorEventListener;
                    sensorManager = KeyguardSensorInjector.this.mSensorManager;
                    if (sensorManager != null) {
                        sensor = KeyguardSensorInjector.this.mLargeAreaTouchSensor;
                        if (sensor != null) {
                            Slog.i(KeyguardSensorInjector.this.getTAG(), "unregister large area touch sensor");
                            KeyguardSensorInjector.this.mLargeAreaTouchSensor = null;
                            sensorManager2 = KeyguardSensorInjector.this.mSensorManager;
                            sensorEventListener = KeyguardSensorInjector.this.mLargeAreaTouchSensorListener;
                            sensorManager2.unregisterListener(sensorEventListener);
                        }
                    }
                }
            });
        }
    }

    private final boolean isDeviceSupportLargeAreaTouch() {
        Sensor defaultSensor;
        SensorManager sensorManager = this.mSensorManager;
        return (sensorManager == null || (defaultSensor = sensorManager.getDefaultSensor(this.LARGE_AREA_TOUCH_SENSOR)) == null || !Intrinsics.areEqual(this.LARGE_AREA_TOUCH_SENSOR_NAME, defaultSensor.getName())) ? false : true;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public final boolean shouldRegisterLargeAreaSensor() {
        return this.mIsDeviceSupportLargeAreaTouch && this.mSensorManager != null && this.mLargeAreaTouchSensor == null && !this.mKeyguardViewMediator.isHiding() && this.mKeyguardViewMediator.isShowing();
    }

    public final boolean isProximitySensorDisabled() {
        return this.mSensorManager.getDefaultSensor(8) == null || this.sIsEllipticProximity;
    }

    public final boolean isSupportPickupByMTK() {
        boolean contains;
        String[] stringArray = this.mContext.getResources().getStringArray(R.array.device_support_pickup_by_MTK);
        Intrinsics.checkNotNullExpressionValue(stringArray, "mContext.resources.getStringArray(R.array.device_support_pickup_by_MTK)");
        contains = ArraysKt___ArraysKt.contains(stringArray, Build.DEVICE);
        return contains;
    }

    public final void disableFullScreenGesture() {
        if (MiuiKeyguardUtils.isFullScreenGestureOpened()) {
            CommonUtil.updateFsgState(this.mContext, "typefrom_keyguard", this.mKeyguardViewMediator.isShowing() && !this.mKeyguardViewMediator.isOccluded() && !this.mKeyguardUpdateMonitor.isBouncerShowing(), this.mUiBgExecutor);
        }
    }
}