Android: comment activer et désactiver l'écran par programmation?

Avant de marquer ce message comme "duplicata", j'écris ce message car aucun autre message ne contient la solution au problème.

J'essaie d'éteindre l'appareil, puis après quelques minutes ou un changement de capteur, rallumez-le.

Désactiver les tests d'affichage

Je peux éteindre l'écran en utilisant:

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

Je n'ai pas pu éteindre l'écran en utilisant la méthode wl.release ().

Activer le test d'affichage

Ma première hypothèse, comme suit, ne fonctionne pas. Rien ne se passe, l'écran reste éteint.

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

J'ai également essayé d'utiliser des wakelocks, sans succès.

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

Enfin, j'ai essayé ce qui suit, sans résultat.

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

Dans l'ensemble, je n'obtiens aucune sorte d'erreur dans la console pour aucune de ces méthodes. Mon texte de test «L'écran doit être allumé» s'affiche à l'écran lorsque j'allume l'appareil à l'aide du bouton d'alimentation. Cela montre que le code aurait dû s'exécuter. Veuillez ne répondre que si vous avez testé le code, il semble que de nombreuses fonctions telles que params.screenBrightness = -1, ne fonctionnent pas comme elles le devraient selon le sdk.

Je vais supposer que vous voulez que cela ne soit en vigueur que lorsque votre application est au premier plan.

Ce code:

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

N'éteint pas l'écran au sens traditionnel du terme. Cela rend l'écran aussi sombre que possible. Dans la plate-forme standard, la luminosité peut être limitée; si votre appareil permet en fait à l'écran de s'éteindre complètement, c'est une particularité de la mise en œuvre de cet appareil et non un comportement sur lequel vous pouvez compter sur tous les appareils.

En fait, l'utiliser en conjonction avec FLAG_KEEP_SCREEN_ON signifie que vous ne permettrez jamais à l'écran de s'éteindre (et donc à l'appareil de passer en mode basse consommation), même si l'appareil particulier vous permet de régler la luminosité de l'écran à son maximum. Gardez cela à l'esprit. Vous utiliserez beaucoup plus d'énergie que si l'écran était vraiment éteint.

Maintenant, pour ramener l'écran à la luminosité normale, il suffit de régler la valeur de luminosité:

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

Je ne peux pas expliquer pourquoi cela ne remplacerait pas la valeur 0 que vous aviez précédemment définie. À titre de test, vous pouvez essayer d'y mettre une luminosité totale forcée pour forcer cette luminosité spécifique:

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

Cela fonctionne vraiment. Par exemple, les applications Livres de Google l'utilisent pour vous permettre de régler la luminosité de l'écran sur la luminosité lorsque vous utilisez un livre, puis de revenir à la luminosité normale lorsque vous la désactivez.

Pour aider au débogage, vous pouvez utiliser "adb shell dumpsys window" pour voir l'état actuel de votre fenêtre. Dans les données de votre fenêtre, il vous indiquera les LayoutParams actuels qui ont été définis pour elle. Assurez-vous que la valeur que vous pensez est bien là.

Et encore une fois, FLAG_KEEP_SCREEN_ON est un concept distinct; elle et la luminosité n'ont aucun impact direct l'une sur l'autre. (Et il n'y aurait aucune raison de redéfinir l'indicateur lors de l'annulation de la luminosité, si vous l'aviez déjà défini lors de la mise à 0. L'indicateur restera activé jusqu'à ce que vous le changiez.)

J'avais écrit cette méthode pour allumer l'écran après le verrouillage de l'écran. Cela fonctionne parfaitement pour moi. Essayez-le

    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);
    }

Et appelez cette méthode à partir de onResume().

Je suggérerais celui-ci:

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

Le drapeau ACQUIRE_CAUSES_WAKEUP est expliqué comme ça:

Les verrous de réveil normaux n'activent pas réellement l'éclairage. Au lieu de cela, ils font que l'éclairage reste allumé une fois qu'il est allumé (par exemple à cause de l'activité de l'utilisateur). Cet indicateur forcera l'écran et / ou le clavier à s'allumer immédiatement, lorsque le WakeLock sera acquis. Une utilisation typique serait pour les notifications qui sont importantes pour l'utilisateur à voir immédiatement.

Assurez-vous également que vous disposez de l'autorisation suivante dans le fichier AndroidManifewst.xml:

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

Salut j'espère que cela aidera:

 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();

// Fichier manifeste de l'utilisateur

Êtes-vous sûr d'avoir demandé l'autorisation appropriée dans votre fichier manifeste?

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

Vous pouvez utiliser la classe AlarmManager 1 pour déclencher une intention qui démarre votre activité et acquiert le verrou de réveil. Cela allumera l'écran et le gardera allumé. Le relâchement du wakelock permettra à l'appareil de s'endormir tout seul.

Vous pouvez également jeter un œil à l'utilisation du PowerManager pour mettre l'appareil en veille: http://developer.android.com/reference/android/os/PowerManager.html#goToSleep(long)

La meilleure façon de le faire (en utilisant des appareils rootés):

@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

   .
   .
   .
}

Maintenant, nous avons ces deux fonctions:

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){
  }
}

Et ça:

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

Désolé pour mon mauvais anglais.

Voici un exemple réussi d'une implémentation de la même chose, sur un appareil prenant en charge des valeurs de luminosité d'écran inférieures (j'ai testé sur une tablette Allwinner Chinese 7 "exécutant 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);

Si quelqu'un d'autre essaie cela, veuillez commenter ci-dessous si cela a fonctionné / n'a pas fonctionné et l'appareil, l'API Android.

Pour garder l'écran allumé:

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

Retour au mode par défaut de l'écran: effacez simplement l'indicateur FLAG_KEEP_SCREEN_ON

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

Ceci est travaillé sur 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();
    }
}

En ce qui concerne la documentation Android, cela peut être réalisé en utilisant la ligne de code suivante:

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

J'ai ajouté ceci dans ma onCreateméthode et cela fonctionne très bien.

Sur le lien, vous trouverez différentes façons d'y parvenir ainsi que des explications générales.

Lien vers la documentation: https://developer.android.com/training/scheduling/wakelock.html

Si votre application est une application système, vous pouvez utiliser PowerManager.goToSleep () pour désactiver l'écran, vous avez besoin d'une autorisation spéciale

avant d'utiliser goToSleep (), vous devez utiliser la réflexion comme:

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();
    }
}

Maintenant, vous pouvez utiliser goToSleep () pour éteindre l'écran.

C'est ce qui se produit lorsque vous appuyez sur la touche marche / arrêt pour éteindre l'écran.

Ajoutez simplement

android:keepScreenOn="true" 

ou appeler

setKeepScreenOn(true) 

sur la vue parent.

Je n'aurais pas l'espoir de "réveiller l'écran" dans l'activité. Si l'écran est éteint, l'activité est probablement en pause et ne doit pas exécuter de code.

Au réveil, il y a le problème de l'écran de verrouillage. Je ne sais pas comment une application peut automatiquement contourner l'écran de verrouillage.

Vous devriez envisager d'exécuter vos tâches d'arrière-plan dans un service, puis d'utiliser le gestionnaire de notifications pour envoyer une notification lorsque tout ce qui est détecté. La notification doit fournir une sorte d'alerte de l'appareil (réveil de l'écran, icône de notification, voyant de notification, etc.). En cliquant sur la notification, il peut lancer l'intention de démarrer votre activité.

Vous pouvez également essayer de démarrer l'activité directement à partir du service, mais je ne sais vraiment pas si cela activera l'écran ou contournera l'écran de verrouillage.

Conformément à l'API Android 28 et au-dessus, vous devez effectuer les opérations suivantes pour allumer l'écran

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

J'ai essayé toutes les solutions ci-dessus mais aucune n'a fonctionné pour moi. J'ai donc cherché sur Google et trouvé des solutions ci-dessous. J'ai essayé et cela a fonctionné.

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

s'il y a une suggestion, veuillez donner