Rileva la pressione del pulsante home in Android

Questo mi sta facendo impazzire da un po 'di tempo.

Esiste un modo per rilevare in modo affidabile se il pulsante Home è stato premuto in un'applicazione Android?

In caso contrario, c'è un modo efficace per dire cosa ha causato un'attività in pausa? cioè Possiamo rilevare se è stato causato dal lancio di una nuova attività o premendo back / home.

Un suggerimento che ho visto è di sovrascrivere onPause () e chiamare isFinishing (), ma questo restituirà false quando si preme il pulsante home proprio come farebbe se una nuova attività sta iniziando, quindi questo non riesce a distinguere tra i due.

Qualsiasi aiuto molto apprezzato.

** Aggiornamento **: Grazie a @ android-hungry per questo link: https://nishandroid.blogspot.com/

Ignorando il seguente metodo:

@Override
public void onAttachedToWindow() {
    super.onAttachedToWindow();
    this.getWindow().setType(WindowManager.LayoutParams.TYPE_KEYGUARD);           
}

Quindi il seguente evento verrà attivato per la pressione del pulsante home:

@Override
public boolean onKeyDown(int keyCode, KeyEvent event) {     

    if(keyCode == KeyEvent.KEYCODE_HOME)
    {
       //The Code Want to Perform. 
    }
});

Non sono sicuro che ci siano effetti collaterali con questa linea:

this.getWindow().setType(WindowManager.LayoutParams.TYPE_KEYGUARD);   

Quindi sembrerebbe che contrariamente alla credenza popolare, puoi effettivamente ascoltare la chiave di casa. È preoccupante che tu possa restituire false e che la chiave home non faccia nulla.

Aggiornamento : come previsto, ci sono alcuni effetti collaterali con questo: sembra che i video incorporati e le mappe di Google non siano visibili con questa modalità abilitata.

Aggiornamento : presumibilmente questo hack non funziona più da Android 4.0 in poi

Il codice seguente funziona per me :)

HomeWatcher mHomeWatcher = new HomeWatcher(this);
mHomeWatcher.setOnHomePressedListener(new OnHomePressedListener() {
    @Override
    public void onHomePressed() {
        // do something here...
    }
    @Override
    public void onHomeLongPressed() {
    }
});
mHomeWatcher.startWatch();

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.util.Log;

public class HomeWatcher {

    static final String TAG = "hg";
    private Context mContext;
    private IntentFilter mFilter;
    private OnHomePressedListener mListener;
    private InnerReceiver mReceiver;

    public HomeWatcher(Context context) {
        mContext = context;
        mFilter = new IntentFilter(Intent.ACTION_CLOSE_SYSTEM_DIALOGS);
    }

    public void setOnHomePressedListener(OnHomePressedListener listener) {
        mListener = listener;
        mReceiver = new InnerReceiver();
    }

    public void startWatch() {
        if (mReceiver != null) {
            mContext.registerReceiver(mReceiver, mFilter);
        }
    }

    public void stopWatch() {
        if (mReceiver != null) {
            mContext.unregisterReceiver(mReceiver);
        }
    }

    class InnerReceiver extends BroadcastReceiver {
        final String SYSTEM_DIALOG_REASON_KEY = "reason";
        final String SYSTEM_DIALOG_REASON_GLOBAL_ACTIONS = "globalactions";
        final String SYSTEM_DIALOG_REASON_RECENT_APPS = "recentapps";
        final String SYSTEM_DIALOG_REASON_HOME_KEY = "homekey";

        @Override
        public void onReceive(Context context, Intent intent) {
            String action = intent.getAction();
            if (action.equals(Intent.ACTION_CLOSE_SYSTEM_DIALOGS)) {
                String reason = intent.getStringExtra(SYSTEM_DIALOG_REASON_KEY);
                if (reason != null) {
                    Log.e(TAG, "action:" + action + ",reason:" + reason);
                    if (mListener != null) {
                        if (reason.equals(SYSTEM_DIALOG_REASON_HOME_KEY)) {
                            mListener.onHomePressed();
                        } else if (reason.equals(SYSTEM_DIALOG_REASON_RECENT_APPS)) {
                            mListener.onHomeLongPressed();
                        }
                    }
                }
            }
        }
    }
}

public interface OnHomePressedListener {
    void onHomePressed();
    void onHomeLongPressed();
}

Questa è una vecchia domanda ma potrebbe aiutare qualcuno.

@Override
protected void onUserLeaveHint()
{
    Log.d("onUserLeaveHint","Home button pressed");
    super.onUserLeaveHint();
}

Secondo la documentazione, il metodo onUserLeaveHint () viene chiamato quando l'utente fa clic sul pulsante home OPPURE quando qualcosa interrompe la tua applicazione (come una telefonata in arrivo).

Questo funziona per me .. :)

È impossibile rilevare e / o intercettare il pulsante HOME da un'app Android. Questo è integrato nel sistema per prevenire app dannose che non possono essere chiuse.

Avevo bisogno di avviare / interrompere la musica di sottofondo nella mia applicazione quando la prima attività si apre e si chiude o quando qualsiasi attività viene messa in pausa dal pulsante Home e quindi ripresa dal task manager. Riproduzione pura interrompendo / riprendendo Activity.onPause()e Activity.onResume()interrompendo la musica per un po ', quindi ho dovuto scrivere il seguente codice:

@Override
public void onResume() {
  super.onResume();

  // start playback here (if not playing already)
}

@Override
public void onPause() {
  super.onPause();

  ActivityManager manager = (ActivityManager) this.getSystemService(Activity.ACTIVITY_SERVICE);
  List<ActivityManager.RunningTaskInfo> tasks = manager.getRunningTasks(Integer.MAX_VALUE);
  boolean is_finishing = this.isFinishing();
  boolean is_last = false;
  boolean is_topmost = false;
  for (ActivityManager.RunningTaskInfo task : tasks) {
    if (task.topActivity.getPackageName().startsWith("cz.matelier.skolasmyku")) {
      is_last = task.numRunning == 1;
      is_topmost = task.topActivity.equals(this.getComponentName());
      break;
    }
  }

  if ((is_finishing && is_last) || (!is_finishing && is_topmost && !mIsStarting)) {
    mIsStarting = false;
    // stop playback here
  }
}

che interrompe la riproduzione solo quando l'applicazione (tutte le sue attività) viene chiusa o quando viene premuto il tasto home. Sfortunatamente non sono riuscito a cambiare l'ordine delle chiamate del onPause()metodo dell'attività iniziale e dell'attività onResume()avviata quando Activity.startActivity()viene chiamato (o rilevare in onPause()quell'attività che sta avviando un'altra attività in altro modo) quindi questo caso deve essere gestito in modo speciale:

private boolean mIsStarting;

@Override
public void startActivity(Intent intent) {
  mIsStarting = true;
  super.startActivity(intent);
}

Un altro svantaggio è che ciò richiede l' GET_TASKSautorizzazione aggiunta a AndroidManifest.xml:

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

Modificare questo codice in modo che reagisca solo alla pressione del pulsante home è immediato.

Ignora onUserLeaveHint()l'attività. Non ci sarà mai alcuna richiamata all'attività quando viene rilevata una nuova attività o l'utente preme indietro.

onUserLeaveHint ();

sovrascrivere questo metodo della classe di attività. Questo rileverà il clic del tasto home. Questo metodo viene chiamato subito prima del callback onPause () dell'attività, ma non verrà chiamato quando un'attività viene interrotta come un'attività in chiamata viene in primo piano, a parte le interruzioni che chiamerà quando l'utente fa clic sul tasto home.

@Override
protected void onUserLeaveHint() {
    super.onUserLeaveHint();
    Log.d(TAG, "home key clicked");
}

Prova a creare un contatore per ogni schermata. Se l'utente tocca HOME, il contatore sarà zero.

public void onStart() {
  super.onStart();
  counter++;
}

public void onStop() {
  super.onStop();
  counter--;    
  if (counter == 0) {
      // Do..
  }
}

Potresti prendere in considerazione una soluzione di Andreas Shrade nel suo post su How-To Create a Kiosk Mode in Android . È un po 'hacky, ma visti i motivi per cui l'intercettazione del pulsante home è impedita, deve esserlo;)

Ho avuto questo problema e poiché l'override del metodo onKeyDown () non ha ottenuto nulla perché il sistema Android sottostante non ha chiamato questo metodo, l'ho risolto sovrascrivendo onBackPressed () e avevo un valore booleano impostato su false , perché ho premuto indietro, lascia che ti mostri cosa intendo in codice:

import android.util.Log;
public class HomeButtonActivity extends Activity {
    boolean homePressed = false;
    // override onCreate() here.

    @Override
    public void onBackPressed() {
        homePressed = false; // simply set homePressed to false
    }

    @Overide
    public void onResume() {
        super.onResume();
        homePressed = true; // default: other wise onBackPressed will set it to false
    }

    @Override
    public void onPause() {
        super.onPause();
        if(homePressed) { Log.i("homePressed", "yay"); }
    }

Quindi il motivo per cui ha funzionato è perché l'unico modo per navigare al di fuori di questa attività è premendo back o home quindi se back è stato premuto allora so che la causa non era home, ma altrimenti la causa era home, quindi ho impostato il booleano predefinito valore per home Premuto per essere vero. Tuttavia questo funzionerà solo con una singola istanza di attività nella tua applicazione perché altrimenti hai più possibilità di far chiamare il metodo onPause ().

Dall'API 14 è possibile utilizzare la funzione onTrimMemory()e verificare la presenza del flagTRIM_MEMORY_UI_HIDDEN . Questo ti dirà che la tua applicazione sta andando in background.

Quindi nella tua classe Application personalizzata puoi scrivere qualcosa come:

override fun onTrimMemory(level: Int) {
    if (level == TRIM_MEMORY_UI_HIDDEN) {
        // Application going to background, do something
    }
}

Per uno studio approfondito di questo, ti invito a leggere questo articolo: http://www.developerphil.com/no-you-can-not-override-the-home-button-but-you-dont-have -per/

Un'opzione per la tua applicazione sarebbe scrivere una schermata Home sostitutiva utilizzando l'intento android.intent.category.HOME. Credo che questo tipo di intento possa vedere il pulsante home.

Più dettagli:

http://developer.android.com/guide/topics/intents/intents-filters.html#imatch

Poiché desideri che l'attività di root venga mostrata nuovamente all'avvio dell'app, forse puoi ottenere questo comportamento cambiando le modalità di avvio, ecc. Nel manifest?

Ad esempio, hai provato ad applicare l' attributo android: clearTaskOnLaunch = "true" alla tua attività di lancio, magari in tandem con android: launchMode = "singleInstance" ?

Tasks and Back Stack è un'ottima risorsa per mettere a punto questo tipo di comportamento.

È una cattiva idea cambiare il comportamento della chiave home. Questo è il motivo per cui Google non ti consente di sovrascrivere la chiave home. Non scherzerei con la chiave di casa in generale. Devi dare all'utente un modo per uscire dalla tua app se si spegne tra le erbacce per qualsiasi motivo.

Immagino che qualsiasi soluzione abbia effetti collaterali indesiderati.

Recentemente stavo cercando di rilevare il pulsante home press, perché avevo bisogno che facesse lo stesso del metodo " onBackPressed () ". Per fare ciò, ho dovuto sovrascrivere il metodo " onSupportNavigateUp () " in questo modo:

override fun onSupportNavigateUp(): Boolean {
    onBackPressed()
    return true
}

Ha funzionato perfettamente. =)

La risposta di Jack funziona perfettamente per l' clickevento mentre longClicksta prendendo in considerazione il menuclic del pulsante.

A proposito, se qualcuno si sta chiedendo come fare tramite kotlin,

class HomeButtonReceiver(private var context: Context,private var listener: OnHomeButtonClickListener) {
    private val mFilter: IntentFilter = IntentFilter(Intent.ACTION_CLOSE_SYSTEM_DIALOGS)
    private var mReceiver: InnerReceiver = InnerReceiver()

    fun startWatch() {
        context.registerReceiver(mReceiver, mFilter)
    }

    fun stopWatch() {
        context.unregisterReceiver(mReceiver)
    }

    inner class InnerReceiver: BroadcastReceiver() {
        private val systemDialogReasonKey = "reason"
        private val systemDialogReasonHomeKey = "homekey"
        override fun onReceive(context: Context?, intent: Intent?) {
            val action = intent?.action
            if (action == Intent.ACTION_CLOSE_SYSTEM_DIALOGS) {
                val reason = intent.getStringExtra(systemDialogReasonKey)
                if (reason != null && reason == systemDialogReasonHomeKey) {
                    listener.onHomeButtonClick()
                }
            }
        }
    } 
}

Chiave Home Android gestita dal livello del framework non è possibile gestirla a livello del livello dell'applicazione. Perché l'azione del pulsante home è già definita nel livello inferiore. Ma se stai sviluppando la tua ROM personalizzata, potrebbe essere possibile. Google ha limitato le funzioni di override del PULSANTE HOME per motivi di sicurezza.

Questo funziona per me. Puoi sostituire il metodo onUserLeaveHint https://www.tutorialspoint.com/detect-home-button-press-in-android

@Override
    protected void onUserLeaveHint() {
        //
        super.onUserLeaveHint();
    }