android - tecla - Anular el botón de encendido al igual que el botón Inicio

desactivar botones tactiles samsung

Question

Bien, estoy haciendo algo en lo que quiero desactivar todos los botones duros del dispositivo.

Botones duros como Energía, Inicio, Subir volumen, Bajar volumen, Buscar, Atrás.

He superado con éxito casi todos los botones here excepto Power.

Así que solo quiero que la gente vea y, por favor, comparta algunas ideas para que pueda hacerlo.

Estoy recibiendo la pulsación larga de Power keyevent en onDispatchKeyEvent() , de la misma manera que quiero capturar el clic corto de la misma. Además, al presionar el poder, también traté de detener la pantalla al obtener la Broadcast de SCREEN_OFF y logré recibirla, pero no pude manejarla.

Gracias.

Luego, creé una ReceiverScreen que recibe transmisión de pantalla on / off

ReceiverScreen.java

public class ReceiverScreen extends BroadcastReceiver {

    public static boolean wasScreenOn = true;

    @Override
    public void onReceive(Context context, Intent intent) {
        if (intent.getAction().equals(Intent.ACTION_SCREEN_OFF)) {
            // do whatever you need to do here
            wasScreenOn = false;
        } else if (intent.getAction().equals(Intent.ACTION_SCREEN_ON)) {
            // and do whatever you need to do here
            wasScreenOn = true;
        }
    }
}

DisableHardButton.java

public class DisableHardButton extends Activity {

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

    setContentView(R.layout.main);
    IntentFilter filter = new IntentFilter(Intent.ACTION_SCREEN_ON);
    filter.addAction(Intent.ACTION_SCREEN_OFF);
    BroadcastReceiver mReceiver = new ReceiverScreen();
    registerReceiver(mReceiver, filter);
    }

@Override
    protected void onPause() {
        // when the screen is about to turn off
        if (ScreenReceiver.wasScreenOn) {
            // this is the case when onPause() is called by the system due to a screen state change
            System.out.println("SCREEN TURNED OFF");

    } else {
        // this is when onPause() is called when the screen state has not changed
    }
    super.onPause();
}

@Override
protected void onResume() {
    // only when screen turns on
    if (!ScreenReceiver.wasScreenOn) {
        // this is when onResume() is called due to a screen state change
        System.out.println("SCREEN TURNED ON");
    } else {
        // this is when onResume() is called when the screen state has not changed
    }
    super.onResume();
}
}

Answer 1

Al contrario de todas las respuestas. Mira esto:

@Override
public boolean dispatchKeyEvent(KeyEvent event) {
        if (event.getKeyCode() == KeyEvent.KEYCODE_POWER) {
                Log.i("", "Dispath event power");
                Intent closeDialog = new Intent(Intent.ACTION_CLOSE_SYSTEM_DIALOGS);
                sendBroadcast(closeDialog);
                return true;
        }

        return super.dispatchKeyEvent(event);
}

Que hace:

Cada vez que el usuario presiona el botón de encendido. ¡Cancelamos el Diálogo antes de que sea visto! :). Esto funciona para mí ... (Probado en la nota 2)

Answer 2

Esto es lo que hice:

(1) Crear una clase de receptor:

public class ScreenReceiver extends BroadcastReceiver {

    @Override
    public void onReceive(Context context, Intent intent) {
        String action = intent.getAction();
        switch (action) {
            case Intent.ACTION_SCREEN_OFF:
                BaseActivity.unlockScreen();
                break;

            case Intent.ACTION_SCREEN_ON:
                // and do whatever you need to do here
                BaseActivity.clearScreen();
        }
    }
}

(2) Los dos métodos que se mencionan arriba se ve así:

public static void unlockScreen () {
    if (current == null) return;

    Log.i( Constants.TAG, "Turning on screen ... " );

    Window window = current.getWindow();
    window.addFlags( WindowManager.LayoutParams.FLAG_DISMISS_KEYGUARD );
    window.addFlags( WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED );
    window.addFlags( WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON   );
}

public static void clearScreen () {
    if (current == null) return;

    Log.i( Constants.TAG, "Clearing screen flag when on ... " );

    Window window = current.getWindow();
    window.clearFlags( WindowManager.LayoutParams.FLAG_DISMISS_KEYGUARD );
    window.clearFlags( WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED );
    window.clearFlags( WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON   );
}

private static BaseActivity current;

@Override
protected void onResume () {
    current = this;
}

(3) En la clase de actividad principal en el método de creación (), registre el receptor:

    IntentFilter filter = new IntentFilter( Intent.ACTION_SCREEN_ON );
    filter.addAction( Intent.ACTION_SCREEN_OFF );
    registerReceiver(new ScreenReceiver(), filter);

Answer 3

Puede conocer la pulsación del botón de encendido, pero no creo que pueda anularlo y podrá cerrar el cuadro de diálogo para apagarlo y mostrar algo más.

Esto es lo que he intentado,

package com.easylogs.app;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.util.Log;
import android.widget.Toast;

public class CloseSystemDialogsIntentReceiver extends BroadcastReceiver {
    public void onReceive(final Context context, final Intent intent) {
        Log.i("HERE", "------------------------------------HERE");
        Toast.makeText(context, "OFFFFFFFFFFFFFFFF",Toast.LENGTH_LONG).show();
    }
}

y declaración en Manifiesto como,

    <receiver android:name="CloseSystemDialogsIntentReceiver">
    <intent-filter>
            <action android:name="android.intent.action.CLOSE_SYSTEM_DIALOGS" />
            <category android:name="android.intent.category.DEFAULT" />
        </intent-filter>
    </receiver>

Answer 4

Sé que es demasiado tarde, pero puede ser útil para otros desarrolladores en el futuro. Probado en Android N. Referencia de https://.com/a/15828592/1065357

 @Override
    public void onWindowFocusChanged(boolean hasFocus) {
        super.onWindowFocusChanged(hasFocus);
        if(!hasFocus) {
           Intent closeDialog = new Intent(Intent.ACTION_CLOSE_SYSTEM_DIALOGS);
            sendBroadcast(closeDialog);
        }
    }

Answer 5

Uf. Esta es una pregunta bastante disputada, con una gran cantidad de comentarios detrás de ella.

Permítanme comenzar reformulando su pregunta un poco. Si entiendo claramente, le gustaría desactivar todos los botones físicos en el dispositivo por la duración de su actividad. Esto incluye el botón de encendido, que detecta al manejar el intento ACTION_SCREEN_OFF . Su solución actual (exitosa) para este escenario es emitir un ACTION_SCREEN_ON , dando vida a la pantalla cuando está apagada, siempre que el host implemente esto correctamente.

Ahora desea hacer un esfuerzo adicional, al hacer que esta acción sea innecesaria, si (y solo si) puede capturar y manejar ACTION_SCREEN_OFF antes de que se envíe al sistema. ¿Es posible? y si lo es, cómo?

Esto lleva algo de discusión. La versión corta, sin embargo, es simple: esto no es posible, sin una modificación personalizada de su firmware o el núcleo del sistema operativo Android, para un número limitado de dispositivos.

El sistema Android, por lo que se documenta, define esto como una acción de difusión . Siguiendo el patrón de publicación-suscripción de la propagación de mensajes, este mensaje notificará a todas las partes interesadas de esta acción. Debido a que este mensaje es enviado por el sistema, debido a que el sistema administra la pila de mensajes y porque el sistema también recibe el mensaje, su código simplemente no se inyecta en el lugar correcto para bloquear la recepción de este mensaje.

Además, para algunos dispositivos, este será un interruptor físico que no tiene interrupción programática alguna. En el mejor de los casos, el sistema Android puede esperar manejar el evento cuando sucede, que es precisamente por lo que este mensaje de difusión es algo así como un caso especial en la pila de servicios. Según mi leal saber y entender y sobre la base de la escasa documentación sobre este escenario, esta es la razón por la cual no es una función compatible lista para utilizar, antes de considerar cualquiera de los posibles vectores de abuso.

Su mejor recurso es en realidad uno mucho más simple, si tiene la capacidad de modificar el hardware físico para el dispositivo en cuestión: restringir el acceso a, modificar o desactivar el botón de encendido físico. En muchos escenarios esto no es deseable, pero esto funciona en situaciones donde su dispositivo Android se está utilizando, por ejemplo, como un punto de venta o una máquina de servicio público. Si esto no funciona, puede que baste con restringir físicamente el acceso al botón de encendido; para el resto de los casos, (por ejemplo, un intento de alternar la pantalla) enviando ACTION_SCREEN_ON .

Solo recuerde, esta estrategia no es infalible. Hagan esto de manera competente y documenten bien el procedimiento, para que no se conviertan en forraje para la próxima exposición de 2600 .

La mejor de las suertes con tu aplicación.

Answer 6

@Override
public boolean dispatchKeyEvent(KeyEvent event) {
    if (event.getKeyCode() == KeyEvent.KEYCODE_POWER) {

        return true;
    }

    return super.dispatchKeyEvent(event);
}

¿Has probado el código anterior donde podemos manejar el evento clave de encendido? También eche un vistazo a este LINK que ha manejado el evento presionado por el botón de encendido.