¿La capa inferior de Android admite la activación de notificaciones para el estado del protector de pantalla?
Después de que algunos teléfonos móviles Samsung apagan la pantalla, la actividad en primer plano se reanudará tan pronto como se encienda la pantalla. Debido a que utilizamos el motor cocos2d-x, los eventos de reanudación y actividad predeterminados. son consistentes cuando reanudamos El sonido cerrado se vuelve a abrir, de modo que después de que el usuario encienda la pantalla (aún no desbloqueada), escuchará el sonido del juego (si nuestro juego está en primer plano cuando la pantalla está apagada). .
Para resolver este problema, necesitamos modificar el momento de activación de nuestro currículum. Asegúrate de ingresar al estado de reanudación de nuestro juego después de desbloquearlo.
Entonces, ¿cuándo debería nuestro juego entrar en el estado de reanudación?
Cuando la actividad del sistema entra en estado de reanudación y la pantalla está encendida, la pantalla no está bloqueada.
La pantalla simplemente se ilumina, la pantalla no está bloqueada y el sistema la actividad ha entrado en estado de reanudación
La pantalla está desbloqueada, lo que significa que la pantalla debe estar brillante y la actividad ha entrado en estado de reanudación
Con los tres puntos anteriores, creo que la El código lógico no es difícil de escribir. A continuación se explica cómo hacer que la pantalla del sistema se apague, el evento de desbloqueo de la pantalla y cómo determinar si la pantalla actual está desbloqueada (porque el usuario puede configurar si desea bloquearla). la pantalla después de apagarla, por lo que es posible que el evento de desbloqueo de pantalla no se active en absoluto, entonces no podemos determinar mediante el seguimiento del evento su estado)
Para manejar los tres eventos de pantalla encendida, pantalla apagada, y desbloqueo de pantalla, necesitamos registrar y monitorear las tres acciones ACTION_SCREEN_ON, ACTION_SCREEN_OFF y ACTION_USER_PRESENT en el código. El método de escritura específico es el siguiente:
[java] ver copia simple
. /**
* receptor de transmisión de estado de pantalla
*/
clase privada ScreenBroadcastReceiver extiende BroadcastReceiver {
@Override
public void onReceive(Contexto contexto, Intención intención) {
if(Intent.ACTION_SCREEN_ON.equals(intent.getAction())) {
mScreenStateListener.onScreenOn();
}else if(Intent.ACTION_SCREEN_OFF.equals(intent.getAction())){
mScreenStateListener.onScreenOff(
}else if(Intent); .ACTION_USER_PRESENT.equals(intent.getAction())){
mScreenStateListener.onUserPresent()
}
p>}
[java] ver copia simple
/**
* Detener actualización de estado de pantalla
p>
*/
public void stopScreenStateUpdate() {
mContext.unregisterReceiver(mScreenReceiver
}
/ **
<); p> * Receptor de transmisión de estado de pantalla de inicio*/
private void startScreenBroadcastReceiver() {
filtro IntentFilter = new IntentFilter (); p> filtro.addAction(Intent.ACTION_SCREEN_ON
);
filter.addAction(Intent.ACTION_SCREEN_OFF);
filter.addAction(Intent.ACTION_USER_PRESENT);
mContext.registerReceiver(mScreenReceiver, filtro);
}
Debido a que el usuario puede configurar si la pantalla está bloqueada después de apagarla, no podemos juzgar su estado mediante el seguimiento del evento de desbloqueo. Necesitamos una función que pueda hacerlo. obtenga el estado de vez en cuando:
[java] ver copia simple
//Determine si la pantalla está bloqueada
public final static boolean isScreenLocked(Context c ) {
android .app.KeyguardManager mKeyguardManager = (KeyguardManager) c.getSystemService(c.KEYGUARD_SERVICE
return mKeyguardManager.inKeyguardRestrictedInputMode();
Cosas a tener en cuenta Sí, la mayoría de los eventos se pueden registrar en AndroidManifest.xml, pero los eventos ACTION_SCREEN_ON, ACTION_SCREEN_OFF y ACTION_USER_PRESENT están restringidos por PowerManager. Deben registrarse en el código como se indica arriba antes de poder monitorearlos. , así que no los pises. Qué trampa~~~
El siguiente es un código de clase para empaquetar eventos de pantalla, solo como referencia:
[java] ver copia simple.
paquete com.example. myfirstapp;
importar java.lang.reflect.Method
importar android.app.Activity; >importar android.app.KeyguardManager
importar android.content.BroadcastReceiver
importar android.content.Context
importar android.content.Intent;
importar android.content.
importar android.os.PowerManager
importar android.util.Log; **
* Pantalla del monitor ON y OFF Estado PRESENTE
*
* @author
* @2014
*
*/
clase pública ScreenObserver {
cadena estática privada TAG = "ScreenObserver"
contexto privado mContext;
ScreenBroadcastReceiver privado mScreenReceiver
<p> ScreenStateListener privado mScreenStateListener;
Método estático privado mReflectScreenState;
ScreenObserver público (contexto de contexto) {
mContext = contexto; mScreenReceiver = new ScreenBroadcastReceiver();
prueba {
mReflectScreenState = PowerManager.class.getMethod("isScreenOn",
new Class[] {});
} catch (Excepción nsme) {
Log.d(TAG, "API < 7," + nsme
}
<); p> }/**
* Receptor de transmisión de estado de pantalla
*/
clase privada ScreenBroadcastReceiver extiende BroadcastReceiver {
p>
@Override
public void onReceive (contexto de contexto, intención de intención) {
if (Intent.ACTION_SCREEN_ON.equals(intent.getAction()) ) {
p>
mScreenStateListener.onScreenOn();
} else if (Intent.ACTION_SCREEN_OFF.equals(intent.getAction())) {
mScreenStateListener.onScreenOff();
} else if (Intent.ACTION_USER_PRESENT.equals(intent.getAction())) {
mScreenStateListener.onUserPresent();
}
}
}
/**
* Solicitar actualización del estado de la pantalla
* /
public void requestScreenStateUpdate(escucha de ScreenStateListener) {
mScreenStateListener = oyente
startScreenBroadcastReceiver;
();
firstGetScreenState();
}
/**
* Primera solicitud de estado de la pantalla
*/
private void firstGetScreenState() {
PowerManager manager = (PowerManager) mContext
.getSystemService(Activity.POWER_SERVICE
);if (isScreenOn(manager)) {
if (mScreenStateListener != null) {
mScreenStateListener.onScreenOn()
}
p>
} else {
if (mScreenStateListener != null) {
mScreenStateListener.onScreenOff()
}
}
}
/**
* Detener actualización de estado de pantalla
*/
public void stopScreenStateUpdate() {
mContext.unregisterReceiver(mScreenReceiver
}
/**
* Iniciar el receptor de transmisión de estado de pantalla
*/
private void startScreenBroadcastReceiver() {
filtro IntentFilter = nuevo filtro IntentFilter(); addAction(Intent.ACTION_SCREEN_ON);
filter.addAction(Intent.ACTION_SCREEN_OFF);
filter.addAction(Intent.ACTION_USER_PRESENT
mContext.registerReceiver(); mScreenReceiver, filtro)
}
/**
* Si la pantalla está abierta
*/
privado estático booleano isScreenOn(PowerManager pm) {
booleano screenState
prueba {
scre;
enState = (Booleano) mReflectScreenState.invoke(pm);
} catch (Excepción e) {
screenState = false
}
return screenState;
}
// Interfaz de llamada externa
interfaz pública ScreenStateListener {
public void onScreenOn(); /p>
public void onScreenOff();
public void onUserPresent();
}
public final static boolean isScreenLocked(Contexto c) {
android.app.KeyguardManager mKeyguardManager = (KeyguardManager) c
.getSystemService(c.KEYGUARD_SERVICE
return mKeyguardManager.inKeyguardRestrictedInputMode(); >
}
}