Android: come attivare e disattivare lo schermo a livello di programmazione?

Prima di contrassegnare questo post come "duplicato", scrivo questo post perché nessun altro post contiene la soluzione al problema.

Sto provando a spegnere il dispositivo, quindi dopo alcuni minuti o dopo aver cambiato il sensore, riaccendilo.

Disattiva i test del display

Sono in grado di spegnere lo schermo utilizzando:

params.flags |= LayoutParams.FLAG_KEEP_SCREEN_ON;
params.screenBrightness = 0;
getWindow().setAttributes(params);

Non sono riuscito a spegnere lo schermo utilizzando il metodo wl.release ().

Attiva il test del display

La mia prima ipotesi, come segue, non funziona. Non succede niente, lo schermo rimane spento.

params.flags |= LayoutParams.FLAG_KEEP_SCREEN_ON;
params.screenBrightness = -1f;
getWindow().setAttributes(params);

Ho anche provato a usare wakelocks, senza successo.

PowerManager.WakeLock wl = pm.newWakeLock(PowerManager.SCREEN_BRIGHT_WAKE_LOCK, "tag");
wl.acquire();

Finalmente ho provato quanto segue, senza risultato.

getWindow().addFlags(WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON);

Tutto sommato, non ricevo alcun tipo di errore nella console per nessuno di questi metodi. Il testo di prova "Lo schermo dovrebbe essere acceso" viene visualizzato sullo schermo quando accendo il dispositivo utilizzando il pulsante di accensione. Questo mostra che il codice avrebbe dovuto essere eseguito. Per favore rispondi solo se hai testato il codice, sembra che molte delle funzioni come params.screenBrightness = -1, non funzionino come dovrebbero secondo sdk.

Presumo che tu voglia che questo sia attivo solo mentre la tua applicazione è in primo piano.

Questo codice:

params.flags |= LayoutParams.FLAG_KEEP_SCREEN_ON;
params.screenBrightness = 0;
getWindow().setAttributes(params);

Non spegne lo schermo nel senso tradizionale. Rende lo schermo il più scuro possibile. Nella piattaforma standard c'è un limite a quanto può essere debole; se il tuo dispositivo sta effettivamente permettendo allo schermo di spegnersi completamente, allora è una particolarità dell'implementazione di quel dispositivo e non un comportamento su cui puoi contare su tutti i dispositivi.

In effetti, l'utilizzo di questo in combinazione con FLAG_KEEP_SCREEN_ON significa che non consentirai mai che lo schermo si spenga (e quindi il dispositivo vada in modalità a basso consumo) anche se il particolare dispositivo ti consente di impostare la luminosità dello schermo al massimo. Tienilo ben presente. Userai molta più energia di quanto faresti se lo schermo fosse davvero spento.

Ora per riportare lo schermo alla luminosità normale, è sufficiente impostare il valore di luminosità:

WindowManager.LayoutParams params = getWindow().getAttributes();
params.screenBrightness = -1;
getWindow().setAttributes(params);

Non riesco a spiegare perché questo non sostituirebbe il valore 0 che avevi impostato in precedenza. Come test, potresti provare a inserire una luminosità completa forzata per forzare quella luminosità specifica:

WindowManager.LayoutParams params = getWindow().getAttributes();
params.screenBrightness = 1;
getWindow().setAttributes(params);

Funziona decisamente. Ad esempio, le app di Google Libri lo utilizzano per consentirti di impostare la luminosità dello schermo in modo che si attenui durante l'utilizzo di un libro e quindi tornare alla luminosità normale quando lo spegni.

Per aiutare il debug, puoi usare "adb shell dumpsys window" per vedere lo stato corrente della tua finestra. Nei dati per la tua finestra, ti dirà i LayoutParams correnti che sono stati impostati per essa. Assicurati che il valore che pensi sia effettivamente presente.

E ancora, FLAG_KEEP_SCREEN_ON è un concetto separato; esso e la luminosità non hanno alcun impatto diretto l'uno sull'altro. (E non ci sarebbe alcun motivo per impostare di nuovo il flag quando si annulla la luminosità, se lo si fosse già impostato quando si mette la luminosità a 0. Il flag rimarrà impostato fino a quando non lo si modifica.)

Avevo scritto questo metodo per accendere lo schermo dopo il blocco dello schermo. Funziona perfettamente per me. Provalo-

    private void unlockScreen() {
        Window window = this.getWindow();
        window.addFlags(WindowManager.LayoutParams.FLAG_DISMISS_KEYGUARD);
        window.addFlags(WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED);
        window.addFlags(WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON);
    }

E chiama questo metodo da onResume().

Suggerirei questo:

PowerManager.WakeLock wl = pm.newWakeLock(PowerManager.SCREEN_BRIGHT_WAKE_LOCK | PowerManager.ACQUIRE_CAUSES_WAKEUP, "tag");
wl.acquire();

Il flag ACQUIRE_CAUSES_WAKEUP è spiegato così:

I normali wakelock in realtà non accendono l'illuminazione. Invece, fanno sì che l'illuminazione rimanga accesa una volta che si accende (ad esempio dall'attività dell'utente). Questo flag costringerà lo schermo e / o la tastiera ad accendersi immediatamente, quando il WakeLock viene acquisito. Un utilizzo tipico sarebbe per le notifiche che sono importanti per l'utente da vedere immediatamente.

Inoltre, assicurati di disporre della seguente autorizzazione nel file AndroidManifewst.xml:

<uses-permission android:name="android.permission.WAKE_LOCK" />

Ciao, spero che questo ti aiuti:

 private PowerManager mPowerManager;
 private PowerManager.WakeLock mWakeLock;

 public void turnOnScreen(){
     // turn on screen
     Log.v("ProximityActivity", "ON!");
     mWakeLock = mPowerManager.newWakeLock(PowerManager.SCREEN_BRIGHT_WAKE_LOCK | PowerManager.ACQUIRE_CAUSES_WAKEUP, "tag");
     mWakeLock.acquire();
}

 @TargetApi(21) //Suppress lint error for PROXIMITY_SCREEN_OFF_WAKE_LOCK
 public void turnOffScreen(){
     // turn off screen
     Log.v("ProximityActivity", "OFF!");
     mWakeLock = mPowerManager.newWakeLock(PowerManager.PROXIMITY_SCREEN_OFF_WAKE_LOCK, "tag");
     mWakeLock.acquire();
}

     WakeLock screenLock =    ((PowerManager)getSystemService(POWER_SERVICE)).newWakeLock(
    PowerManager.SCREEN_BRIGHT_WAKE_LOCK | PowerManager.ACQUIRE_CAUSES_WAKEUP, "TAG");
    screenLock.acquire();

  //later
  screenLock.release();

// File manifest dell'utente

Sei sicuro di aver richiesto l'autorizzazione appropriata nel tuo file Manifest?

<uses-permission android:name="android.permission.WAKE_LOCK" />

Puoi utilizzare la classe AlarmManager 1 per attivare un intento che avvia la tua attività e acquisisce il wakelock. Questo accenderà lo schermo e lo manterrà acceso. Il rilascio del wakelock consentirà al dispositivo di andare a dormire da solo.

Puoi anche dare un'occhiata all'uso di PowerManager per impostare il dispositivo in modalità di sospensione: http://developer.android.com/reference/android/os/PowerManager.html#goToSleep(long)

Il modo migliore per farlo (utilizzando dispositivi rooted):

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    .
    .
    .

    int flags = WindowManager.LayoutParams.FLAG_DISMISS_KEYGUARD | WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED | WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON;
    getWindow().addFlags(flags); // this is how your app will wake up the screen
    //you will call this activity later

   .
   .
   .
}

Ora abbiamo queste due funzioni:

private void turnOffScreen(){

  try{
     Class c = Class.forName("android.os.PowerManager");
     PowerManager  mPowerManager = (PowerManager) this.getSystemService(Context.POWER_SERVICE);
     for(Method m : c.getDeclaredMethods()){
        if(m.getName().equals("goToSleep")){
          m.setAccessible(true);
          if(m.getParameterTypes().length == 1){
            m.invoke(mPowerManager,SystemClock.uptimeMillis()-2);
          }
        }
     } 
  } catch (Exception e){
  }
}

E questo:

public void turnOnScreen(){
  Intent i = new Intent(this,YOURACTIVITYWITHFLAGS.class);
  startActivity(i);
}

Scusa per il mio cattivo inglese.

Ecco un esempio riuscito di implementazione della stessa cosa, su un dispositivo che supportava valori di luminosità dello schermo inferiori (l'ho testato su un tablet Allwinner Chinese 7 "con API15).

WindowManager.LayoutParams params = this.getWindow().getAttributes();

/** Turn off: */
params.flags = WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON;
//TODO Store original brightness value
params.screenBrightness = 0.1f;
this.getWindow().setAttributes(params);

/** Turn on: */
params.flags = WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON;
//TODO restoring from original value
params.screenBrightness = 0.9f;
this.getWindow().setAttributes(params);

Se qualcun altro lo prova, commenta di seguito se ha funzionato / non ha funzionato e il dispositivo, l'API Android.

Per mantenere lo schermo attivo:

getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);

Torna alla modalità predefinita dello schermo: basta cancellare il flag FLAG_KEEP_SCREEN_ON

getWindow().clearFlags(android.view.WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);

Funziona su Marshmallow

private final String TAG = "OnOffScreen";
private PowerManager _powerManager;
private PowerManager.WakeLock _screenOffWakeLock;

public void turnOnScreen() {
    if (_screenOffWakeLock != null) {
        _screenOffWakeLock.release();
    }
}

public void turnOffScreen() {
    try {
        _powerManager = (PowerManager) this.getSystemService(POWER_SERVICE);
        if (_powerManager != null) {
            _screenOffWakeLock = _powerManager.newWakeLock(PROXIMITY_SCREEN_OFF_WAKE_LOCK, TAG);
            if (_screenOffWakeLock != null) {
                _screenOffWakeLock.acquire();
            }
        }
    } catch (Exception ex) {
        ex.printStackTrace();
    }
}

Per quanto riguarda la documentazione di Android, può essere ottenuto utilizzando la seguente riga di codice:

getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);

L'ho aggiunto nel mio onCreatemetodo e funziona bene.

Sul link troverai diversi modi per ottenere questo e anche una spiegazione generale.

Link alla documentazione: https://developer.android.com/training/scheduling/wakelock.html

Se la tua app è un'app di sistema, puoi utilizzare PowerManager.goToSleep () per disattivare lo schermo, è necessaria un'autorizzazione speciale

prima di usare goToSleep (), devi usare la riflessione proprio come:

public static void goToSleep(Context context) {
    PowerManager powerManager= (PowerManager)context.getSystemService(Context.POWER_SERVICE);
    try {
        powerManager.getClass().getMethod("goToSleep", new Class[]{long.class}).invoke(powerManager, SystemClock.uptimeMillis());
    } catch (IllegalAccessException e) {
        e.printStackTrace();
    } catch (InvocationTargetException e) {
        e.printStackTrace();
    } catch (NoSuchMethodException e) {
        e.printStackTrace();
    }
}

Ora puoi usare goToSleep () per disattivare lo schermo.

Questo è ciò che accade quando si preme il tasto di accensione per spegnere lo schermo.

Aggiungi semplicemente

android:keepScreenOn="true" 

oppure chiama

setKeepScreenOn(true) 

in vista genitore.

Non avrei speranza di "svegliare lo schermo" nell'attività. Se lo schermo è spento, l'attività è probabilmente in uno stato di pausa e non dovrebbe eseguire alcun codice.

Al risveglio, c'è il problema della schermata di blocco. Non so come qualsiasi app possa bypassare automaticamente la schermata di blocco.

Dovresti considerare di eseguire le tue attività in background in un servizio e quindi utilizzare il gestore delle notifiche per inviare una notifica quando viene rilevato qualsiasi cosa. La notifica dovrebbe fornire una sorta di avviso del dispositivo (attivazione dello schermo, icona di notifica, LED di notifica, ecc.). Quando si fa clic sulla notifica, è possibile avviare l'intento di avviare la propria attività.

Puoi anche tentare di avviare l'attività direttamente dal servizio, ma non so davvero se questo accenderà lo schermo o aggirerà la schermata di blocco.

In base all'API 28 di Android e versioni successive, è necessario eseguire le seguenti operazioni per accendere lo schermo

setShowWhenLocked(true); 
setTurnScreenOn(true); 
KeyguardManager keyguardManager = (KeyguardManager)
getSystemService(Context.KEYGUARD_SERVICE);
keyguardManager.requestDismissKeyguard(this, null);

Ho provato tutte le soluzioni sopra ma nessuna ha funzionato per me. quindi ho cercato su Google e ho trovato le soluzioni di seguito. Ho provato e ha funzionato.

https://www.tutorialspoint.com/how-to-turn-android-device-screen-on-and-off-programmaticamente

se c'è qualche suggerimento, si prega di dare