Détecter la pression du bouton d'accueil dans Android

Cela me rend dingue depuis un moment maintenant.

Existe-t-il un moyen de détecter de manière fiable si le bouton d'accueil a été enfoncé dans une application Android?

À défaut, y a-t-il un moyen fiable de dire ce qui a provoqué la mise en pause d'une activité? ie Peut-on détecter si elle a été causée par le lancement d'une nouvelle activité ou en appuyant sur back / home.

Une suggestion que j'ai vue est de remplacer onPause () et d'appeler isFinishing (), mais cela retournera false lorsque vous appuyez sur le bouton d'accueil, tout comme si une nouvelle activité démarre, cela ne permet pas de faire la distinction entre les deux.

Toute aide très appréciée.

** Mise à jour **: Merci à @ android-hungry pour ce lien: https://nishandroid.blogspot.com/

Remplacer la méthode suivante:

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

Ensuite, l'événement suivant sera déclenché pour les pressions sur le bouton d'accueil:

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

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

Je ne sais pas s'il y a des effets secondaires avec cette ligne:

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

Il semblerait donc que contrairement à la croyance populaire, vous puissiez en fait écouter la clé de la maison. Fait inquiétant, vous pouvez renvoyer false et laisser la clé d'accueil ne rien faire.

Mise à jour : Comme prévu, cela a des effets secondaires - il semble que les vidéos intégrées et les cartes Google ne soient pas visibles avec ce mode activé.

Mise à jour : supposément, ce hack ne fonctionne plus à partir d'Android 4.0

Le code suivant fonctionne pour moi :)

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

C'est une vieille question mais cela pourrait aider quelqu'un.

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

Selon la documentation, la méthode onUserLeaveHint () est appelée lorsque l'utilisateur clique sur le bouton d'accueil OU lorsque quelque chose interrompt votre application (comme un appel téléphonique entrant).

Cela fonctionne pour moi .. :)

Il est impossible de détecter et / ou d'intercepter le bouton HOME à partir d'une application Android. Ceci est intégré au système pour empêcher les applications malveillantes qui ne peuvent pas être quittées.

J'avais besoin de démarrer / arrêter la musique de fond dans mon application lorsque la première activité s'ouvre et se ferme ou lorsqu'une activité est mise en pause par le bouton d'accueil, puis reprise à partir du gestionnaire de tâches. Lecture pure arrêt / reprise Activity.onPause()et Activity.onResume()interruption de la musique pendant un moment, j'ai donc dû écrire le code suivant:

@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
  }
}

qui interrompt la lecture uniquement lorsque l'application (toutes ses activités) est fermée ou lorsque le bouton d'accueil est enfoncé. Malheureusement je n'ai pas réussi à changer l'ordre des appels de la onPause()méthode de l'activité de départ et onResume()de l'activité commencée quand Activity.startActivity()est appelé (ou détecter dans onPause()cette activité le lancement d'une autre activité d'une autre manière) donc ce cas doit être traité spécialement:

private boolean mIsStarting;

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

Un autre inconvénient est que cela nécessite une GET_TASKSautorisation ajoutée à AndroidManifest.xml:

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

Modifier ce code pour qu'il ne réagisse qu'à la pression du bouton d'accueil est simple.

Remplacer onUserLeaveHint()dans l'activité. Il n'y aura jamais de rappel de l'activité lorsqu'une nouvelle activité survient ou que l'utilisateur appuie sur.

onUserLeaveHint ();

écraser cette méthode de classe d'activité. Cela détectera le clic sur la touche d'accueil. Cette méthode est appelée juste avant le rappel onPause () de l'activité, mais elle ne sera pas appelée lorsqu'une activité est interrompue comme une activité en cours d'appel entre au premier plan, à part les interruptions qu'elle appellera lorsque l'utilisateur clique sur la touche d'accueil.

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

Essayez de créer un compteur pour chaque écran. Si l'utilisateur touche HOME, le compteur sera zéro.

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

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

Vous pourriez envisager une solution d'Andreas Shrade dans son article sur Comment créer un mode kiosque fonctionnel sous Android . C'est un peu piraté, mais étant donné les raisons pour lesquelles l'interception du bouton d'accueil est empêchée, il doit l'être;)

J'ai eu ce problème, et comme le remplacement de la méthode onKeyDown () n'a rien accompli car le système Android sous-jacent n'a pas appelé cette méthode, j'ai résolu le problème en remplaçant onBackPressed (), et j'avais une valeur booléenne définie sur false , parce que j'ai appuyé, laissez-moi vous montrer ce que je veux dire dans le code:

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

Donc, la raison pour laquelle cela a fonctionné est parce que le seul moyen de naviguer en dehors de cette activité est d'appuyer sur retour ou à la maison, donc si retour a été appuyé, je sais que la cause n'était pas à la maison, mais sinon la cause était à la maison, donc je définis le booléen par défaut value for home Pressed pour être vrai. Cependant, cela ne fonctionnera qu'avec une seule instance d'activité dans votre application, car sinon, vous avez plus de possibilités de provoquer l'appel de la méthode onPause ().

Depuis l'API 14, vous pouvez utiliser la fonction onTrimMemory()et vérifier l'indicateur TRIM_MEMORY_UI_HIDDEN. Cela vous indiquera que votre application passe en arrière-plan.

Ainsi, dans votre classe Application personnalisée, vous pouvez écrire quelque chose comme:

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

Pour une étude approfondie de cela, je vous invite à lire cet article: http://www.developerphil.com/no-you-can-not-override-the-home-button-but-you-dont-have -à/

Une option pour votre application serait d'écrire un écran d'accueil de remplacement à l'aide de l'intention android.intent.category.HOME. Je crois que ce type d'intention, vous pouvez voir le bouton d'accueil.

Plus de détails:

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

Étant donné que vous souhaitez uniquement que l'activité racine soit à nouveau affichée lorsque l'application est lancée, vous pouvez peut-être obtenir ce comportement en modifiant les modes de lancement, etc. dans le manifeste?

Par exemple, avez-vous essayé d'appliquer l' attribut android: clearTaskOnLaunch = "true" à votre activité de lancement, peut-être en tandem avec android: launchMode = "singleInstance" ?

Tasks and Back Stack est une excellente ressource pour affiner ce type de comportement.

Changer le comportement de la clé d'accueil est une mauvaise idée. C'est pourquoi Google ne vous permet pas de remplacer la clé d'accueil. Je ne voudrais pas jouer avec la clé de la maison en général. Vous devez donner à l'utilisateur un moyen de sortir de votre application si elle s'enfonce dans les mauvaises herbes pour une raison quelconque.

J'imaginerais que tout travail aura des effets secondaires indésirables.

Récemment, j'essayais de détecter le bouton home press, car j'avais besoin qu'il fasse la même chose que la méthode " onBackPressed () ". Pour ce faire, j'ai dû remplacer la méthode " onSupportNavigateUp () " comme ceci:

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

Cela a parfaitement fonctionné. =)

La réponse de Jack fonctionne parfaitement pour l' clickévénement tout en longClickenvisageant de menucliquer sur un bouton.

Au fait, si quelqu'un se demande comment faire via 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()
                }
            }
        }
    } 
}

Android Home Key géré par la couche de structure, vous ne pouvez pas gérer cela au niveau de la couche d'application. Parce que l'action du bouton d'accueil est déjà définie dans le niveau ci-dessous. Mais si vous développez votre ROM personnalisée, cela pourrait être possible. Google a limité les fonctions de remplacement du BOUTON HOME pour des raisons de sécurité.

Cela fonctionne pour moi. Vous pouvez remplacer la méthode onUserLeaveHint https://www.tutorialspoint.com/detect-home-button-press-in-android

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