questions introduites

Dans le projet, l'activité a été le développement de multiples sauts de problèmes les plus courants, de nombreuses solutions en ligne, mais comment résoudre est le meilleur est souvent un mal de tête, je veux dire comment résoudre vraiment ce question sans laisser une trace de Bug, d'abord introduit plusieurs programmes existants ainsi que les avantages et les inconvénients

AOP Aspect Oriented

AOP ne parle pas ici de l'intégration Pour Baidu s'il vous plaît tourner à gauche, où ils parlent des avantages et des inconvénients

textView.setOnClickListener (nouveau OnClickListener () { @EnableFastOnClick @Override public void onClick (Voir v) { } });

• Avantages: méthodes annoter Voir événement click, il semble relativement simple
• Inconvénients: partout Voir l'événement Click doit être annotés, les coûts de développement élevés, sujettes à des omissions

Activité Mode de démarrage

< activité android: name = "ui.activity.XXXActivity" android: launchMode = "singleTop" / >

L'ensemble de l'activité dans le fichier, le mode démarrage examen ici singleTop

singleTop: mode haut simple, si la pile de tâches à pile l'existence de cette activité ouverte, ne sera pas recréer l'activité, mais la réutilisation activité existante. Assurez-vous en haut de la pile, le cas échéant, ne crée pas un doublon

• Avantages: mode de définition de l'activité directement dans le fichier manifeste, simple et brut
• Inconvénients: Chaque nouvelle activité doit être réglé sur le mode de démarrage, et ne peuvent spécifier singleTop, les coûts de développement plus élevés, sujettes à des omissions

interception startActivity

Tout d'abord, nous devons faire un outil de jugement, double-cliquez sur

public final class DoubleClickHelper { finale statique privée de TIME_ARRAY = new long ; // longueur du tableau représente un enregistrement d'opération double clic seulement / ** * Que l'opération double-clic dans un court laps de temps * / public static boolean isOnDoubleClick () { // défaut durée de l'intervalle retourner isOnDoubleClick (1500); } / ** * Que l'opération double-clic dans un court laps de temps * / public static boolean isOnDoubleClick (heure int) { System.arraycopy (TIME_ARRAY, 1, TIME_ARRAY, 0, TIME_ARRAY.length - 1); TIME_ARRAY  = SystemClock.uptimeMillis (); retour TIME_ARRAY > = (SystemClock.uptimeMillis) - (temps); } }

Méthode StartActivity de l'activité de réécriture

BaseActivity classe abstraite publique étend AppCompatActivity { @Override startActivity public void (intention Intent) { si (DoubleClickHelper.isOnDoubleClick (500)) { retour; } super.startActivity (intention); } }

En fait, il y a une échappatoire écrite, penchons-nous sur la méthode saut d'activité

Je pense que la première chose que vous sentez est comme moi, c'est le cheval de Dieu? Tu veux que je Réécrire plus?

Rencontrez ce problème, maintenez la recrue la cuisse processus général:

• Rookie: a rencontré un problème de comment ne pas faire?
• Vieil oiseau: Non Baidu ah! Baidu ne pas?
• Rookie: Baidu comment faire?
• Anciens combattants: Baidu est impossible de changer Google ah!
• Rookie: Google, ni comment faire?
• Vieil oiseau: le code source est le meilleur professeur!

VOici parler d'une pièce, nous allons résoudre ce problème en regardant le code source, regardez le code source startActivity

Voici les différents paramètres de la même méthode d'appel nom, regard

StartActivity finalement avéré être un startActivityForResult de rappel

De là, voir startActivityForResult deux méthodes, les paramètres de la méthode ou méthode de paramètre de longueur d'appel court, ici nous ne devons réécrire les méthodes à long paramétriques, nous ne pouvons pas utiliser juste de cette façon, et le startActivity en startActivityForResult

BaseActivity classe abstraite publique étend AppCompatActivity { @Override startActivityForResult public void (intention Intent, int requestCode, @Nullable Options Bundle) { si (DoubleClickHelper.isOnDoubleClick (500)) { retour; } super.startActivityForResult (intention, requestCode, options); } }

En fait, cela est aussi un problème, si l'interface nécessite plusieurs sauts comment le faire? Tel est pas le BaseActivity mort d'écriture directe pas propice à l'expansion?

Pour résoudre ce problème est très simple, dans BaseActivity réserve une méthode, une sous-classe peut remplacer cette méthode pour décider d'inspecter et de déterminer la question de l'activité multiple de saut

BaseActivity classe abstraite publique étend AppCompatActivity { @Override startActivityForResult public void (intention Intent, int requestCode, @Nullable Options Bundle) { si (isCheckActivityJump () && DoubleClickHelper.isOnDoubleClick (500)) { retour; } // Voir la source qui finira par appeler startActivityForResult startActivity super.startActivityForResult (intention, requestCode, options); } / ** * Vérifiez que le saut de fréquence d'activité, sauter pour éviter les doubles emplois * / isCheckActivityJump booléen protégé () { // jugement par défaut et que vous devez vérifier return true; } }

En fait, ce sont ces deux codes, très simple, puis résumer

• Avantages: traitement de la classe de base, une fois pour toutes, le développement d'un faible coût
• Inconvénients: ne peut pas déterminer avec précision si l'activité de saut est répété, qui est à la fois si saut deux activités différentes, le résultat est que le premier saut réussi, alors que le second n'a pas sauté

optimisation d'interception startActivityForResult

Une solution encore restée Bug, la poursuite de la perfection, comment pouvons-nous tolérer que cela se produise, alors nous allons donner à cette question tirage au sort à la clôture réussie

Tout d'abord veulent savoir l'activité de saut répétition est pas la même chose, nous pouvons être jugés par objet intention, mais avant cela, nous devons d'abord examiner l'activité du mode de démarrage

• L'intention explicite de commencer
• Constructor: nouvelle intention (Contexte packageContext, classe < ? >  CCRS)
• méthodes d'objet: intent.setClass (Contexte packageContext, classe < ? >  CCRS)
• intention implicite de commencer
• Constructeur: nouvelle intention (l'action String)
• méthodes d'objet: intent.setAction (actions String)

Les deux ont été énumérés ici utiliser le mode de démarrage, nous pouvons utiliser l'intention explicite et implicite intention de créer une marque de Tag respectivement, utilisé pour déterminer si le saut est répété activité

// objet marqueur tag String; si (intent.getComponent ()! = null) {// explicite Jump tag = intent.getComponent () getClassName () .; } Else if (intent.getAction ()! = Null) {// saut implicite tag = intent.getAction (); }

En plus de déterminer si oui ou non une répétition, la nécessité d'intervalle de saut est déterminé à nouveau

if (tag.equals (mActivityJumpTag) && mActivityJumpTime > = SystemClock.uptimeMillis () - 500) { // chèque ne passe pas résultat = false; }

Le code complet est le suivant

BaseActivity classe abstraite publique étend AppCompatActivity { @Override startActivityForResult public void (intention Intent, int requestCode, @Nullable Options Bundle) { si (startActivitySelfCheck (intention)) { // Voir la source qui finira par appeler startActivityForResult startActivity super.startActivityForResult (intention, requestCode, options); } } private String mActivityJumpTag; mActivityJumpTime longtemps privé; / ** * Vérifier si l'activité actuelle répéter le saut, ne pas besoin de vérifier et remplacer cette méthode pour renvoyer true * * Intention @param objet Intent est utilisé pour sauter * @Return vérifier en retournant vrai, ne pas vérifier en retournant faux * / protégé booléenne startActivitySelfCheck (intention d'intention) { // vérification par défaut boolean résultat = true; // objet marqueur tag String; si (intent.getComponent ()! = null) {// explicite Jump tag = intent.getComponent () getClassName () .; } Else if (intent.getAction ()! = Null) {// saut implicite tag = intent.getAction (); } Else { résultat retour; } if (tag.equals (mActivityJumpTag) && mActivityJumpTime > = SystemClock.uptimeMillis () - 500) { // chèque ne passe pas résultat = false; } // marque de début et un temps record mActivityJumpTag = étiquette; mActivityJumpTime = SystemClock.uptimeMillis (); résultat retour; } }

Le code ci-dessus a été rigoureusement testé, il n'y a pas de problème, puis résumez

• Avantages: parfait
• Inconvénients: n'existe pas

Cette solution a été ajoutée à mordre le paquet Hong Deluxe: AndroidProject, vous accueillent mentionné question, a accueilli la star

fin

Si vous avez des idées sur la planification de leur carrière future, veulent améliorer leur technique, vous pouvez recevoir notre matériel d'apprentissage libre, la technologie Daniel Qinshou, le contenu de l'information comprennent: l'interface utilisateur avancée, optimisation des performances, haute l'architecture du CIO Android, architectes cours afin de développer des données d'information et d'interview vidéo!

+ + Renvoi concernent la réponse de lettre privée, « données Andrews » accès libre!