Android: como ligar e desligar a tela de maneira programática?

Antes de marcar este post como "duplicado", estou escrevendo este post porque nenhum outro post contém a solução para o problema.

Estou tentando desligar o dispositivo e, após alguns minutos ou troca de sensor, ligue-o novamente.

Desligue os testes de exibição

Consigo desligar a tela usando:

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

Não consigo desligar a tela usando o método wl.release ().

Ativar teste de exibição

Meu primeiro palpite, como segue, não funciona. Nada acontece, a tela permanece desligada.

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

Também tentei usar wakelocks, sem sucesso.

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

Finalmente tentei o seguinte, sem resultado.

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

Resumindo, não recebo nenhum tipo de erro no console para nenhum desses métodos. Meu texto de teste "A tela deve estar ligada" aparece na tela quando ligo o dispositivo usando o botão liga / desliga. Isso mostra que o código deveria ter sido executado. Por favor, responda somente se você testou o código, parece que muitas das funções, como params.screenBrightness = -1, não funcionam como deveriam de acordo com o SDK.

Vou presumir que você só deseja que isso entre em vigor enquanto seu aplicativo estiver em primeiro plano.

Este código:

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

Não desliga a tela no sentido tradicional. Isso torna a tela o mais escura possível. Na plataforma padrão, há um limite para a intensidade da luz; se o seu dispositivo está realmente permitindo que a tela desligue completamente, então é alguma peculiaridade da implementação desse dispositivo e não um comportamento com o qual você pode contar em todos os dispositivos.

Na verdade, usar isso em conjunto com FLAG_KEEP_SCREEN_ON significa que você nunca permitirá que a tela se apague (e, portanto, o dispositivo entre no modo de baixo consumo de energia), mesmo se o dispositivo específico estiver permitindo que você defina o brilho da tela para totalmente desligado. Tenha isso em mente. Você usará muito mais energia do que se a tela estivesse realmente desligada.

Agora, para retornar a tela ao brilho normal, basta definir o valor do brilho:

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

Não consigo explicar por que isso não substituiria o valor 0 que você definiu anteriormente. Como teste, você pode tentar colocar um brilho total forçado ali para forçar esse brilho específico:

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

Isso definitivamente funciona. Por exemplo, os aplicativos de livros do Google usam isso para permitir que você defina o brilho da tela para diminuir ao usar um livro e, em seguida, retornar ao brilho normal ao desligar.

Para ajudar a depurar, você pode usar "adb shell dumpsys window" para ver o estado atual de sua janela. Nos dados de sua janela, ele informará os LayoutParams atuais que foram definidos para ela. Certifique-se de que o valor que você acha que está realmente lá.

E, novamente, FLAG_KEEP_SCREEN_ON é um conceito separado; ele e o brilho não têm impacto direto um no outro. (E não haveria razão para definir o sinalizador novamente ao desfazer o brilho, se você já o tivesse definido ao colocar o brilho em 0. O sinalizador permanecerá definido até que você o altere.)

Eu escrevi esse método para ligar a tela após o bloqueio da tela. Funciona perfeitamente para mim. Tente-

    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 chame esse método de onResume().

Eu sugeriria este:

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

A sinalização ACQUIRE_CAUSES_WAKEUP é explicada assim:

Os wake locks normais não ativam a iluminação. Em vez disso, eles fazem com que a iluminação permaneça acesa depois de ligada (por exemplo, pela atividade do usuário). Este sinalizador forçará a tela e / ou teclado a ligar imediatamente, quando o WakeLock for adquirido. Um uso típico seria para notificações que são importantes para o usuário ver imediatamente.

Além disso, certifique-se de ter a seguinte permissão no arquivo AndroidManifewst.xml:

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

Olá, espero que ajude:

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

// Arquivo de manifesto do usuário

Tem certeza de que solicitou a permissão adequada em seu arquivo de manifesto?

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

Você pode usar o AlarmManager 1 classe para disparar um intent que inicia sua atividade e adquire o wake lock. Isso ligará a tela e a manterá ligada. Liberar o wakelock permitirá que o dispositivo entre no modo de espera por conta própria.

Você também pode dar uma olhada em usar o PowerManager para configurar o dispositivo para hibernar: http://developer.android.com/reference/android/os/PowerManager.html#goToSleep(long)

A melhor maneira de fazer isso (usando dispositivos com acesso root):

@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

   .
   .
   .
}

Agora temos essas duas funções:

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 isto:

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

Desculpe pelo meu péssimo inglês.

Aqui está um exemplo bem-sucedido de uma implementação da mesma coisa, em um dispositivo que suportava valores de brilho de tela mais baixos (testei em um tablet Allwinner chinês 7 "executando 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 alguém tentar fazer isso, por favor, comente abaixo se funcionou / não funcionou e o dispositivo, API Android.

Para manter a tela ligada:

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

Voltar ao modo padrão da tela: basta limpar o sinalizador FLAG_KEEP_SCREEN_ON

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

Isso é trabalhado em 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();
    }
}

Com relação à documentação do Android, isso pode ser obtido usando a seguinte linha de código:

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

Eu adicionei isso no meu onCreate método e funciona bem.

No link, você encontrará diferentes maneiras de fazer isso e também uma explicação geral.

Link para a documentação: https://developer.android.com/training/scheduling/wakelock.html

Se seu aplicativo for um aplicativo de sistema, você pode usar PowerManager.goToSleep () para desligar a tela, você requer uma permissão especial

antes de usar goToSleep (), você precisa usar reflexão, assim como:

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

Agora, você pode usar goToSleep () para desligar a tela.

Isso é o que acontece quando a tecla liga / desliga é pressionada para desligar a tela.

Basta adicionar

android:keepScreenOn="true" 

ou chamar

setKeepScreenOn(true) 

na visão dos pais.

Eu não teria esperança de "acordar a tela" na atividade. Se a tela estiver desligada, a atividade provavelmente está em um estado de pausa e não deve estar executando nenhum código.

Ao acordar, surge a questão da tela de bloqueio. Não sei como qualquer aplicativo pode ignorar automaticamente a tela de bloqueio.

Você deve considerar a execução de suas tarefas em segundo plano em um serviço e, em seguida, usar o gerenciador de notificações para enviar uma notificação quando o que for detectado. A notificação deve fornecer algum tipo de alerta do dispositivo (tela de ativação, ícone de notificação, led de notificação, etc). Ao clicar na notificação, ele pode lançar a intenção de iniciar sua atividade.

Você também pode tentar iniciar a atividade direto do serviço, mas realmente não sei se isso ligará a tela ou ignorará a tela de bloqueio.

De acordo com a API 28 do Android e acima, você precisa fazer o seguinte para ligar a tela

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

Eu tentei todas as soluções acima, mas nenhuma funcionou para mim. então pesquisei e encontrei as soluções abaixo. Eu tentei e funcionou.

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

se houver alguma sugestão, por favor, dê