Come posso rilevare l'utente premendo il tasto HOME nella mia attività?

Question

Puoi dirmi in che modo la mia attività può rilevare l'utente premendo il tasto HOME?

Grazie.

Answer 1

android.text.method.KeyListener.onKeyDown([view],[text],KEYCODE_HOME,[event]) 

io non sono sicuro di come gli altri parametri si adattano, o anche come implementare quanto sopra, ma le informazioni sono tutti allo keylistner documentation.

Ma menzionano anche allo another page che la chiave di casa SEMPRE va a casa, non è possibile cambiarlo. Quindi se pensi di avere una sorta di dialogo "sei sicuro di voler chiudere", non funzionerebbe.

Answer 2

Non è possibile catturare l'evento HOME e intercettarlo in alcun modo. L'utente verrà sempre portato alla schermata principale del proprio dispositivo quando preme il tasto Home.

Se è necessario sapere quando l'attività viene inviata in background, ad esempio premendo dall'utente i tasti home o back, implementerò il metodo onStop().

Answer 3

È possibile scrivere un ascoltatore Broadcast e impostare il filtro per

<category android:name="android.intent.category.HOME" /> 

dal ricevitore broadcast avviare ur attività/avvisare l'attività.

Answer 4

È possibile rilevare un pulsante HOME premere tramite Activity.onUserLeaveHint(). Questo metodo è chiamato in due situazioni; quando l'utente preme HOME e quando viene avviata una nuova attività. Assicurati di distinguere in qualche modo tra i due.

Answer 5

Non esiste un modo formale per ricevere una pressione tasto "HOME". Ma c'è un lavoro abbastanza semplice da fare per distinguere la tua app tra una pressione di tasto "HOME" e qualsiasi altra azione che causerebbe l'arresto dell'attività.

Per ogni classe che hanno bisogno di eseguire alcune azioni su una "casa" premere il tasto averli estendono da un'attività che contiene questo:

/**************************************** On Home **********************************/ 
private boolean leaveCalled = false; 

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

@Override 
public void onBackPressed() { 
    leaveCalled = true; 
    super.onBackPressed(); 
} 

@Override 
protected void onStop() { 
    super.onStop(); 
    // Home button pressed 
    if(!leaveCalled) { 
     // Do whatever you like. 
    } 

    leaveCalled = false; 
} 

EDIT

Sarà inoltre necessario estendere i tuoi frammenti da una classe genitore che contiene questo. Ciò è dovuto al fatto che i frammenti fornirebbero altrimenti un percorso aggiuntivo per passare da un'attività all'altra dell'app in un modo previsto e non "CASA".

@Override 
public void startActivity(Intent intent) { 
    getActivity().startActivity(intent); 
} 

EDIT 2

mi sto avvicinando a pensare questo non è il modo più semplice per affrontare questo ... è necessario aggiungere anche onConfigurationChange = "orientamento" a tutti i tuoi attività che utilizzano questo metodo. Poi si può aggiungere questo:

@Override 
public void onConfigurationChanged(Configuration newConfig) { 
    super.onConfigurationChanged(newConfig); 
    leaveCalled = true;      
    finish(); 
    startActivity(getIntent()); 
} 

EDIT 3

Urgh

@Override 
public void finish() { 
    leaveCalled = true; 
    super.finish(); 
} 

Answer 6

Si può fare (uptil 2.3 atleast). Testato su HTC WildFire-S Android versione 2.3.5 non-root.Frammento di codice per la cattura/disattivare tutti i tasti di controllo:

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


} 

public boolean onKeyDown(int keyCode, KeyEvent event) {  

    if(keyCode == KeyEvent.KEYCODE_HOME || keyCode == KeyEvent.KEYCODE_POWER || keyCode == KeyEvent.KEYCODE_BACK || keyCode == KeyEvent.KEYCODE_MENU || keyCode == KeyEvent.KEYCODE_SEARCH ) 
    { 

     Toast.makeText(getApplicationContext(),"You pressed a control button with keyCode : " + keyCode, Toast.LENGTH_SHORT).show(); 
     return false; 

    } 
    else 
    { 
     Toast.makeText(getApplicationContext(),"You pressed" + keyCode, Toast.LENGTH_SHORT).show(); 
    } 

    return true; 
} 

public boolean onKeyUp(int keyCode, KeyEvent event) {  

    if(keyCode == KeyEvent.KEYCODE_HOME || keyCode == KeyEvent.KEYCODE_POWER || keyCode == KeyEvent.KEYCODE_BACK || keyCode == KeyEvent.KEYCODE_MENU || keyCode == KeyEvent.KEYCODE_SEARCH ) 
    { 

     return false; 

    } 
    else 
    { 
     // Do nothing 
    } 

    return true; 
} 

Answer 7

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

    if(keyCode == KeyEvent.KEYCODE_HOME) 
    { 

     //The Code Want to Perform. 

    } 
}); 

Answer 8

Aggiornamento [agosto 2015]: Come per il commento di JM Lord, questa risposta potrebbe non funzionare come desiderato per dispositivi Lollipop e superiori. Vedere Alternative to getRunningTasks in Android L

---

Anche se, la sua una vecchia questione, ma la maggior parte delle risposte non ha funzionato per me in livello di API 17 e sopra. Sto rispondendo a cosa ha funzionato alla fine per me. Ho provato molti metodi ma nessuno di loro funziona come oggi. Ho cercato risposte sul

Call method when home button pressed on android,

Detect home button press in android e

Overriding the Home button - how do I get rid of the choice?. L'essenziale era che la casa era come un pulsante di emergenza. Quindi non puoi ignorarlo ma puoi rilevarlo in qualche modo.

Alcuni di quelli che ho provato (tra cui sopra risposte) e non ha funzionato sono:

1. Utilizzando keyCode==KeyEvent.KEYCODE_HOME in molti modi come di cui sopra. Ora, se leggi la documentazione di KeyEvent.KEYCODE_HOME, dice che This key is handled by the framework and is never delivered to applications. Quindi non è più valido adesso.

2. Ho provato a utilizzare onUserLeaveHint(). La documentazione dice:

   chiamato come parte del ciclo di vita di attività quando un'attività sta per andare in secondo piano come il risultato di una scelta dell'utente. Ad esempio, quando l'utente preme il tasto Home, onUserLeaveHint() sarà chiamato , ma quando una chiamata in arrivo fa in modo che l'attività in chiamata venga automaticamente portata in primo piano.

   Il problema con questo è che il metodo viene chiamato anche quando si avvia un Activity dall'interno l'attività in cui si sta chiamando onUserleaveLint(), come era il mio caso. Vedi la domanda Android onBackPressed/onUserLeaveHint per ulteriori informazioni. Quindi non è sicuro che sarebbe chiamata SOLO premendo il tasto Home.

3. Chiamare onStop(). Può anche essere chiamato quando un'attività si sovrappone all'attività esistente e la copre completamente. Quindi anche questo non funzionerà.

Infine il seguenti lavorato per me:

Vedendo How to check current running applications in Android? si può dire che se il vostro è il compito recente che viene mostrato sul premuto a lungo il tasto home, poi è stato inviare allo sfondo.

Quindi, nel tuo onPause() dell'attività in cui si sta tentando di rilevare il pulsante home premuto, è possibile verificare se l'applicazione è stata inviata in background.

@Override 
public void onPause() { 
    if (isApplicationSentToBackground(this)){ 
     // Do what you want to do on detecting Home Key being Pressed 
    } 
    super.onPause(); 
} 

funzione per controllare se il vostro è l'applicazione che è stato inviato più di recente allo sfondo:

public boolean isApplicationSentToBackground(final Context context) { 
    ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE); 
    List<RunningTaskInfo> tasks = am.getRunningTasks(1); 
    if (!tasks.isEmpty()) { 
     ComponentName topActivity = tasks.get(0).topActivity; 
     if (!topActivity.getPackageName().equals(context.getPackageName())) { 
      return true; 
     } 
    } 
    return false; 
} 

Grazie a @idish per aver ricordato che non dimenticate di includere la seguente autorizzazione il vostro manifesto:

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

non so se ci sono aspetti negativi di questo, ma ha funzionato per me bene. Spero che aiuti qualcuno un giorno.

P.S: Se si utilizza questo metodo in un'attività che è stata avviata con il flag FLAG_ACTIVITY_NO_HISTORY, questo non sarà utile in quanto controlla la cronologia recente per capire se è stato fatto clic sul pulsante Home. Metodo

Answer 9

uso onUserLeaveHint() nella vostra attività

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

http://developer.android.com/reference/android/app/Activity.html#onUserLeaveHint()

Answer 10

public boolean isApplicationSentToBackground(final Context context) { 
     ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE); 
     List<RunningTaskInfo> tasks = am.getRunningTasks(1); 
     if (!tasks.isEmpty()) { 
      ComponentName topActivity = tasks.get(0).topActivity; 
      if (!topActivity.getPackageName().equals(context.getPackageName())) { 
       return true; 
      } 
     } 
     return false; 
    } 



public void onPause() { 
    super.onPause(); 
    if(isApplicationSentToBackground(this)) 
    { 
     Log.i("Home", "Home Pressed..!"); 
    } 
} 

Answer 11

ho trovato questa soluzione basata su suggerimento da @Springfeed. La domanda di essere abbastanza generica, si noti che questa particolare soluzione:

• I lavori per Lollipop così come le versioni di Android più bassi (il mio codice precedente in base alla ActivityManager fallito Lollipop)
• cattura sia i tasti di storia Casa e
• Non acquisisce la casa se l'attività stessa è definita come Casa - Sempre
• Catturerà Casa se l'attività è una tra le molte opzioni di casa o non la Home.

Questo codice è nella mia classe di base Activity (di cui tutte le attività ereditano)

public boolean startingActivity = false; 

    @Override 
    protected void onUserLeaveHint() 
    { 
     if(startingActivity) 
     { 
      // Reset boolean for next time 
      startingActivity = false; 
     } 
     else 
     { 
      // User is exiting to another application, do what you want here 
      Log.i(TAG, "Exiting"); 
      ... 
     } 
    } 

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

    @Override 
    public void startActivityForResult(Intent intent, int requestCode) 
    { 
     startingActivity = true; 
     super.startActivityForResult(intent, requestCode); 
    } 

come alcuni metodi potrebbe anche utilizzare il contesto dell'applicazione per lanciare intenti, ho definito un ContextWrapper tenuto da mia classe Application per cambiare anche il booleano (si noti che ho accesso statico all'attività più alta della mia applicazione attraverso quella classe base).

public class MyContext extends ContextWrapper 
{ 

    public MyContext(Context base) 
    { 
     super(base); 
    } 

    @Override 
    public void startActivity(Intent intent) 
    { 
     BaseActivity activity = BaseActivity.getActivity(); 
     if(activity != null) 
     { 
      activity.startingActivity = true; 
     } 

     super.startActivity(intent); 
    } 

} 

Si potrebbe voler sovrascrivere startActivities (...), se necessario.

Spero che questo aiuti :)