Java Code Examples for android.os.PowerManager#SCREEN_BRIGHT_WAKE_LOCK

@SuppressWarnings("deprecation")
private boolean isWakeLockLevelSupportedInternal(int level) {
    synchronized (mLock) {
        switch (level) {
            case PowerManager.PARTIAL_WAKE_LOCK:
            case PowerManager.SCREEN_DIM_WAKE_LOCK:
            case PowerManager.SCREEN_BRIGHT_WAKE_LOCK:
            case PowerManager.FULL_WAKE_LOCK:
            case PowerManager.DOZE_WAKE_LOCK:
            case PowerManager.DRAW_WAKE_LOCK:
                return true;

            case PowerManager.PROXIMITY_SCREEN_OFF_WAKE_LOCK:
                return mSystemReady && mDisplayManagerInternal.isProximitySensorAvailable();

            default:
                return false;
        }
    }
}
 

/** Get wake lock summary flags that correspond to the given wake lock. */
private int getWakeLockSummaryFlags(WakeLock wakeLock) {
    switch (wakeLock.mFlags & PowerManager.WAKE_LOCK_LEVEL_MASK) {
        case PowerManager.PARTIAL_WAKE_LOCK:
            if (!wakeLock.mDisabled) {
                // We only respect this if the wake lock is not disabled.
                return WAKE_LOCK_CPU;
            }
            break;
        case PowerManager.FULL_WAKE_LOCK:
            return WAKE_LOCK_SCREEN_BRIGHT | WAKE_LOCK_BUTTON_BRIGHT;
        case PowerManager.SCREEN_BRIGHT_WAKE_LOCK:
            return WAKE_LOCK_SCREEN_BRIGHT;
        case PowerManager.SCREEN_DIM_WAKE_LOCK:
            return WAKE_LOCK_SCREEN_DIM;
        case PowerManager.PROXIMITY_SCREEN_OFF_WAKE_LOCK:
            return WAKE_LOCK_PROXIMITY_SCREEN_OFF;
        case PowerManager.DOZE_WAKE_LOCK:
            return WAKE_LOCK_DOZE;
        case PowerManager.DRAW_WAKE_LOCK:
            return WAKE_LOCK_DRAW;
    }
    return 0;
}
 

@SuppressWarnings("deprecation")
private String getLockLevelString() {
    switch (mFlags & PowerManager.WAKE_LOCK_LEVEL_MASK) {
        case PowerManager.FULL_WAKE_LOCK:
            return "FULL_WAKE_LOCK                ";
        case PowerManager.SCREEN_BRIGHT_WAKE_LOCK:
            return "SCREEN_BRIGHT_WAKE_LOCK       ";
        case PowerManager.SCREEN_DIM_WAKE_LOCK:
            return "SCREEN_DIM_WAKE_LOCK          ";
        case PowerManager.PARTIAL_WAKE_LOCK:
            return "PARTIAL_WAKE_LOCK             ";
        case PowerManager.PROXIMITY_SCREEN_OFF_WAKE_LOCK:
            return "PROXIMITY_SCREEN_OFF_WAKE_LOCK";
        case PowerManager.DOZE_WAKE_LOCK:
            return "DOZE_WAKE_LOCK                ";
        case PowerManager.DRAW_WAKE_LOCK:
            return "DRAW_WAKE_LOCK                ";
        default:
            return "???                           ";
    }
}
 

@SuppressWarnings("deprecation")
private static boolean isScreenLock(final WakeLock wakeLock) {
    switch (wakeLock.mFlags & PowerManager.WAKE_LOCK_LEVEL_MASK) {
        case PowerManager.FULL_WAKE_LOCK:
        case PowerManager.SCREEN_BRIGHT_WAKE_LOCK:
        case PowerManager.SCREEN_DIM_WAKE_LOCK:
            return true;
    }
    return false;
}
 

private int getBatteryStatsWakeLockMonitorType(int flags) {
    switch (flags & PowerManager.WAKE_LOCK_LEVEL_MASK) {
        case PowerManager.PARTIAL_WAKE_LOCK:
            return BatteryStats.WAKE_TYPE_PARTIAL;

        case PowerManager.SCREEN_DIM_WAKE_LOCK:
        case PowerManager.SCREEN_BRIGHT_WAKE_LOCK:
            return BatteryStats.WAKE_TYPE_FULL;

        case PowerManager.PROXIMITY_SCREEN_OFF_WAKE_LOCK:
            if (mSuspendWhenScreenOffDueToProximityConfig) {
                return -1;
            }
            return BatteryStats.WAKE_TYPE_PARTIAL;

        case PowerManager.DRAW_WAKE_LOCK:
            return BatteryStats.WAKE_TYPE_DRAW;

        case PowerManager.DOZE_WAKE_LOCK:
            // Doze wake locks are an internal implementation detail of the
            // communication between dream manager service and power manager
            // service.  They have no additive battery impact.
            return -1;

        default:
            return -1;
    }
}
 

@SuppressWarnings("deprecation")
private static final String wakeModeToString(int mode) {
    StringBuilder sb = new StringBuilder();

    if ((mode & PowerManager.PARTIAL_WAKE_LOCK) != 0) {
        appendWithOR(sb, "PARTIAL_WAKE_LOCK");
    }

    if ((mode & PowerManager.ACQUIRE_CAUSES_WAKEUP) != 0) {
        appendWithOR(sb, "ACQUIRE_CAUSES_WAKEUP");
    }

    if ((mode & PowerManager.ON_AFTER_RELEASE) != 0) {
        appendWithOR(sb, "ON_AFTER_RELEASE");
    }

    // deprecated values
    if ((mode & PowerManager.FULL_WAKE_LOCK) != 0) {
        appendWithOR(sb, "FULL_WAKE_LOCK");
    }

    if ((mode & PowerManager.SCREEN_DIM_WAKE_LOCK) != 0) {
        appendWithOR(sb, "SCREEN_DIM_WAKE_LOCK");
    }

    if ((mode & PowerManager.SCREEN_BRIGHT_WAKE_LOCK) != 0) {
        appendWithOR(sb, "SCREEN_BRIGHT_WAKE_LOCK");
    }

    return sb.toString();
}
 

@SuppressWarnings("deprecation")
private boolean goToSleepNoUpdateLocked(long eventTime, int reason, int flags, int uid) {
    if (DEBUG_SPEW) {
        Slog.d(TAG, "goToSleepNoUpdateLocked: eventTime=" + eventTime
                + ", reason=" + reason + ", flags=" + flags + ", uid=" + uid);
    }

    if (eventTime < mLastWakeTime
            || mWakefulness == WAKEFULNESS_ASLEEP
            || mWakefulness == WAKEFULNESS_DOZING
            || !mBootCompleted || !mSystemReady) {
        return false;
    }

    Trace.traceBegin(Trace.TRACE_TAG_POWER, "goToSleep");
    try {
        switch (reason) {
            case PowerManager.GO_TO_SLEEP_REASON_DEVICE_ADMIN:
                Slog.i(TAG, "Going to sleep due to device administration policy "
                        + "(uid " + uid +")...");
                break;
            case PowerManager.GO_TO_SLEEP_REASON_TIMEOUT:
                Slog.i(TAG, "Going to sleep due to screen timeout (uid " + uid +")...");
                break;
            case PowerManager.GO_TO_SLEEP_REASON_LID_SWITCH:
                Slog.i(TAG, "Going to sleep due to lid switch (uid " + uid +")...");
                break;
            case PowerManager.GO_TO_SLEEP_REASON_POWER_BUTTON:
                Slog.i(TAG, "Going to sleep due to power button (uid " + uid +")...");
                break;
            case PowerManager.GO_TO_SLEEP_REASON_SLEEP_BUTTON:
                Slog.i(TAG, "Going to sleep due to sleep button (uid " + uid +")...");
                break;
            case PowerManager.GO_TO_SLEEP_REASON_HDMI:
                Slog.i(TAG, "Going to sleep due to HDMI standby (uid " + uid +")...");
                break;
            case PowerManager.GO_TO_SLEEP_REASON_ACCESSIBILITY:
                Slog.i(TAG, "Going to sleep by an accessibility service request (uid "
                        + uid +")...");
                break;
            default:
                Slog.i(TAG, "Going to sleep by application request (uid " + uid +")...");
                reason = PowerManager.GO_TO_SLEEP_REASON_APPLICATION;
                break;
        }

        mLastSleepTime = eventTime;
        mSandmanSummoned = true;
        setWakefulnessLocked(WAKEFULNESS_DOZING, reason);

        // Report the number of wake locks that will be cleared by going to sleep.
        int numWakeLocksCleared = 0;
        final int numWakeLocks = mWakeLocks.size();
        for (int i = 0; i < numWakeLocks; i++) {
            final WakeLock wakeLock = mWakeLocks.get(i);
            switch (wakeLock.mFlags & PowerManager.WAKE_LOCK_LEVEL_MASK) {
                case PowerManager.FULL_WAKE_LOCK:
                case PowerManager.SCREEN_BRIGHT_WAKE_LOCK:
                case PowerManager.SCREEN_DIM_WAKE_LOCK:
                    numWakeLocksCleared += 1;
                    break;
            }
        }
        EventLogTags.writePowerSleepRequested(numWakeLocksCleared);

        // Skip dozing if requested.
        if ((flags & PowerManager.GO_TO_SLEEP_FLAG_NO_DOZE) != 0) {
            reallyGoToSleepNoUpdateLocked(eventTime, uid);
        }
    } finally {
        Trace.traceEnd(Trace.TRACE_TAG_POWER);
    }
    return true;
}
 

public static void enableWakeLock() {
    try {
        boolean disable = false;
        int new_level = 0;
        if (!Preferences.GLOBAL_RUN_SCREEN_OFF) {
            if (!existCurrentActivity()) {
                disable = true;
            } else {
                if (Preferences.APPEARANCE_HIGHLIGHT == VALUE_HIGHLIGHT_OFF) {
                    disable = true;
                } else if (Preferences.APPEARANCE_HIGHLIGHT == VALUE_HIGHLIGHT_ONLY_GPS) {
                    if (!LocationState.isActuallyHardwareGpsOn()) {
                        disable = true;
                    }
                }
            }
        }

        if ((Preferences.APPEARANCE_HIGHLIGHT == VALUE_HIGHLIGHT_ONLY_GPS || Preferences.APPEARANCE_HIGHLIGHT == VALUE_HIGHLIGHT_ALWAYS) && existCurrentActivity()) {
            new_level = PowerManager.SCREEN_BRIGHT_WAKE_LOCK;
        } else {
            if (Preferences.GLOBAL_RUN_SCREEN_OFF) {
                new_level = PowerManager.PARTIAL_WAKE_LOCK;
            }
        }
        Logger.w(TAG, "enableWakeLock(), dis:" + disable + " level:" + new_level + ", wl:" + wl + " current level:" + wl_level);
        if ((disable || new_level == 0) && wl != null) {
            disableWakeLock();
        } else if (!disable && new_level != wl_level) {
            if (wl != null) {
                wl.release();
            }
            PowerManager pm = (PowerManager) A.getApp().getSystemService(Context.POWER_SERVICE);
            if (pm != null) {
                wl = pm.newWakeLock(new_level, TAG);
                wl.acquire();
                wl_level = new_level;
            }
        }
        // Logger.w(TAG, "enableWakeLock(), res:" + wl);
    } catch (Exception e) {
        Logger.e(TAG, "enableWakeLock(), e:" + e.toString());
    }
}
 

public void wakeUp() {
    appendLog(getBaseContext(), TAG, "powerManager:", powerManager);

    boolean isInUse;

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT_WATCH) {
        isInUse = powerManager.isInteractive();
    } else {
        isInUse = powerManager.isScreenOn();
    }

    if (isInUse || ((wakeLock != null) && wakeLock.isHeld())) {
        appendLog(getBaseContext(), TAG, "lock is held");
        return;
    }

    timerWakeUpHandler.postDelayed(timerWakeUpRunnable, WAKEUP_TIMEOUT_IN_MS);

    String wakeUpStrategy = PreferenceManager.getDefaultSharedPreferences(getBaseContext())
            .getString(Constants.KEY_WAKE_UP_STRATEGY, "nowakeup");
    appendLog(getBaseContext(), TAG, "wakeLock:wakeUpStrategy:", wakeUpStrategy);
    if (wakeLock != null) {
        try {
            wakeLock.release();
        } catch (Throwable th) {
            // ignoring this exception, probably wakeLock was already released
        }
    }
    if ("nowakeup".equals(wakeUpStrategy)) {
        return;
    }
    int powerLockID;
    if ("wakeupfull".equals(wakeUpStrategy)) {
        powerLockID = PowerManager.SCREEN_BRIGHT_WAKE_LOCK | PowerManager.ACQUIRE_CAUSES_WAKEUP;
    } else {
        powerLockID = PowerManager.PARTIAL_WAKE_LOCK;
    }
    appendLog(getBaseContext(), TAG, "wakeLock:powerLockID:", powerLockID);
    wakeLock = powerManager.newWakeLock(powerLockID, "YourLocalWeather:PowerLock");
    appendLog(getBaseContext(), TAG, "wakeLock:", wakeLock, ":", wakeLock.isHeld());
    if (!wakeLock.isHeld()) {
        wakeLock.acquire();
    }
    appendLog(getBaseContext(), TAG, "wakeLock acquired");
}
 

/**
 * Acquire a WakeLock which ensures the screen is on and then pokes the user activity timer.
 */
void pokeScreenTimer() {
    initPowerManager();
    int flags = PowerManager.SCREEN_BRIGHT_WAKE_LOCK | PowerManager.ON_AFTER_RELEASE;
    powerManager.newWakeLock(flags, "heads-up:pokeScreenTimer").acquire(1000);
}