- Vous êtes ici :
-
Home
-
Android Composants
-
Android de Zéro
- Introduction à android
Introduction à android
Cette partie couvre les recettes suivantes:
► Déclaration d'une activité
► Démarrer une nouvelle activité avec un objet d'intention
► Passer d'une activité à l'autre
► Transmettre des données à une autre activité
► Renvoyer un résultat d'une activité
► Sauvegarde de l'état d'une activité
► Stockage des données d'activité persistante
► Comprendre le cycle de vie de l'activité
Le SDK Android fournit un outil puissant pour programmer des appareils mobiles, et la meilleure façon de maîtriser un tel outil est de sauter droit po Bien que vous puissiez lire ce livre du début à la fin, comme c'est un livre de cuisine, il est spécialement conçu pour permettre vous pouvez sauter à des tâches spécifiques et obtenir les résultats immédiatement.
Les activités constituent le bloc de construction fondamental de la plupart des applications Android car la classe d'activité fournit l'interface entre l'application et l'écran. La plupart des applications Android auront au moins une activité, voire plusieurs (mais elles ne sont pas obligatoires). Une application de service d'arrière-plan n'exigera pas nécessairement une activité s'il n'y a pas d'interface utilisateur.
Ce chapitre explique comment déclarer et lancer des activités au sein d'une application et comment gérer plusieurs activités à la fois en partageant des données entre elles, en leur demandant des résultats et en appelant une activité à partir d'une autre.
Ce chapitre explore également brièvement l'objet de l'intention, qui est souvent utilisé en conjonction avec des activités. Les intentions peuvent être utilisées pour transférer des données entre des activités dans votre propre application, ainsi que dans des applications externes, telles que celles incluses avec le système d'exploitation Android (un exemple courant serait d'utiliser l'intention de lancer le navigateur Web par défaut).
Pour commencer à développer des applications Android, accédez à la page Android Studio pour télécharger le nouvel IDE Android Studio et le kit SDK Android:
http://developer.android.com/sdk/index.html
- Détails
- Écrit par Severin Mbekou
- Catégorie : Introduction à android
- Affichages : 28
L'OS Android est un endroit dangereux pour une activité. La demande de ressources sur une plate-forme à piles est gérée sans pitié par le système. Nos activités peuvent être sauvegardées à partir de la mémoire quand elle est faible, sans même un préavis et avec toutes les données qu'elles contiennent. Par conséquent, il est essentiel de comprendre le cycle de vie de l'activité.
Le diagramme suivant montre les étapes à travers lesquelles une activité passe pendant sa durée de vie:
Avec les étapes, le diagramme montre également les méthodes qui peuvent être surchargées. Comme vous pouvez le voir, nous avons déjà utilisé la plupart de ces méthodes dans les recettes précédentes. Espérons que l'obtention d'une vue d'ensemble aidera votre compréhension.
-d0}
Se préparer
Créez un nouveau projet dans Android Studio avec une activité vierge et appelez-le ActivityLifecycle. Nous utiliserons la méthode Textview (autogénérée) pour afficher les informations d'état.
Comment faire...
Pour voir l'application passer à travers les différentes étapes, nous allons créer des méthodes pour toutes les étapes:
1. Ouvrez activity_main.xml et ajoutez un ID au TextView autogénéré: android: id = "@ + id / textViewState"
2. Les étapes restantes seront dans MainActivity.java. Ajoutez la déclaration globale suivante:
private TextView mTextViewState;
3. Modifiez la méthode onCreate () pour enregistrer TextView et définir le texte initial:
mTextViewState = (TextView) findViewById (R.id.textViewState);
mTextViewState.setText ("onCreate () \ n");
4. Ajoutez les méthodes suivantes pour gérer les événements restants:
@Passer outre
void protégé onStart () {super.onStart ();
mTextViewState.append ("onStart () \ n");
}
@Passer outre
void protégé onResume () {super.onResume ();
mTextViewState.append ("onResume () \ n");
}
@Passer outre
void protégé onPause () {super.onPause ();
mTextViewState.append ("onPause () \ n");
}
@Passer outre
void protégé onStop () {super.onStop ();
mTextViewState.append ("onStop () \ n");
}
@Passer outre
void protégé onRestart () {super.onRestart ();
mTextViewState.append ("onRestart () \ n");
}
@Passer outre
void protégé onDestroy () {super.onDestroy ();
mTextViewState.append ("onDestroy () \ n");
}
5. Exécutez l'application et observez ce qui se passe lorsque l'activité est interrompue en appuyant sur les touches Retour et Accueil. Essayez d'autres actions, telles que le changement de tâche, pour voir leur impact sur votre application.
Comment ça marche...
Notre activité peut exister dans l'un de ces trois états: actif, en pause ou arrêté. Il y a aussi un quatrième état, détruit, mais nous pouvons l'ignorer en toute sécurité:
► Une activité est dans l'état actif lorsque son interface est disponible pour l'utilisateur. Il persiste de onResume () jusqu'à onPause (), ce qui se produit lorsqu'une autre activité vient au premier plan. Si cette nouvelle activité n'obscurcit pas entièrement notre activité, alors la nôtre restera dans l'état de pause jusqu'à ce que la nouvelle activité soit terminée ou rejetée. Il appellera immédiatement onResume () et continuera.
► Lorsqu'une activité nouvellement lancée remplit l'écran ou rend invisible notre activité, alors notre activité passe à l'état arrêté et la reprise appelle toujours un appel à onRestart ().
► Lorsqu'une activité est en état de pause ou d'arrêt, le système d'exploitation peut (et va) le retirer de la mémoire lorsque la mémoire est faible ou lorsque d'autres applications l'exigent.
-cm
► Il est à noter que nous ne voyons jamais réellement les résultats de la méthode onDestroy (), car l'activité est supprimée par ce point. Si vous souhaitez explorer ces méthodes, il vaut la peine d'utiliser Activity.isFinishing () pour voir si l'activité se termine réellement avant l'exécution de onDestroy (), comme le montre l'extrait suivant:
@Passer outre
public void onPause () {super.onPause ();
mTextView.append ("onPause () \ n"); if (isFinishing ()) {
mTextView.append ("... finish");
}
}
Lors de l'implémentation de ces méthodes, appelez toujours la superclasse avant d'effectuer un travail.
Il y a plus...
Arrêt d'une activité
Pour arrêter une activité, appelez directement sa méthode finish (), qui à son tour appelle onDestroy (). Pour effectuer la même action à partir d'une activité enfant, utilisez finishFromChild (Activity child), où child est la sous-activité d'appel.
Il est souvent utile de savoir si une activité est en cours d'arrêt ou simplement en pause, et la méthode isFinishing (boolean) renvoie une valeur qui indique dans lequel de ces deux états se trouve l'activité.
- Détails
- Écrit par Severin Mbekou
- Catégorie : Introduction à android
- Affichages : 28
Android prend en charge SQLite, mais cela pourrait être beaucoup de frais généraux pour des données simples, telles que le nom de l'utilisateur ou un score élevé. Heureusement, Android fournit également une option légère pour ces scénarios, avec SharedPreferences.
- Détails
- Écrit par Severin Mbekou
- Catégorie : Introduction à android
- Affichages : 16
Être capable de démarrer une activité d'une autre est très bien, mais nous aurons souvent besoin de savoir comment l'activité appelée s'est comportée dans sa tâche ou même quelle activité a été appelée. La méthode startActivityForResult () fournit la solution.
Retourner un résultat d'une activité n'est pas très différent de la façon dont nous venons d'appeler l'activité dans les recettes précédentes. Vous pouvez soit utiliser le projet de la recette précédente, soit lancer un nouveau projet et l'appeler GettingResults. De toute façon, une fois que vous avez un projet avec deux activités et le code nécessaire pour appeler la deuxième activité, vous êtes prêt à commencer.
- Détails
- Écrit par Severin Mbekou
- Catégorie : Introduction à android
- Affichages : 18
L'environnement mobile est très dynamique, les utilisateurs changeant de tâches beaucoup plus souvent que sur les ordinateurs de bureau. Avec généralement moins de ressources sur un appareil mobile, il est à prévoir que votre application sera interrompue à un moment donné. Il est également très possible que le système arrête complètement votre application pour donner des ressources supplémentaires à la tâche en cours. C'est la nature des mobiles.
-D ±}
Un utilisateur pourrait commencer à taper quelque chose dans votre application, être interrompu par un appel téléphonique, ou passer à une autre application pour envoyer un message texte, et au moment où ils reviennent à votre application, le système peut l'avoir complètement fermé pour libérer jusqu'à la mémoire. Pour offrir la meilleure expérience utilisateur, vous devez vous attendre à un tel comportement et le rendre plus facile à reprendre par votre utilisateur. La bonne chose est que le système d'exploitation Android rend cela plus facile en fournissant des rappels pour informer votre application des changements d'état.
Si vous faites simplement pivoter votre appareil, le système d'exploitation va détruire et recréer votre activité. Cela peut sembler un peu sévère, mais c'est fait pour de bonnes raisons - il est très courant d'avoir différentes mises en page pour le portrait et le paysage, donc cela garantit que votre application utilise les bonnes ressources.
Dans cette recette, vous verrez comment gérer les rappels onSavelnstanceState () et onRestorelnstanceState () pour sauvegarder l'état de votre application. Nous allons le démontrer en créant une variable de compteur et en l'incrémentant chaque fois que l'on appuie sur le bouton Count. Nous aurons aussi un EditText et un widget TextView pour voir leur comportement par défaut.
Se préparer
Créez un nouveau projet dans Android Studio et nommez-le stateSaver. Nous n'avons besoin que d'une seule activité, donc l'activité principale autogénérée est suffisante. Cependant, nous aurons besoin de quelques widgets, y compris EditText, Button et TextView. Leur mise en page (dans activity_main.xml) ressemblera à ceci:
<EditText
android: id = "@ + id / editText"
android: layout_width = "match_parent"
android: layout_height = "wrap_content"
android: layout_alignParentTop = "vrai"
android: layout_alignParentStart = "vrai" />
<Bouton
android: id = "@ + id / bouton"
android: layout_width = "wrap_content"
android: layout_height = "wrap_content"
android: layout_centerInParent = "vrai"
android: text = "Compte"
android: onClick = "onClickCounter" />
<TextView
android: id = "@ + id / textViewCounter"
OE-
android: layout_width = "wrap_content"
android: layout_height = "wrap_content"
android: layout_below = "@ id / bouton" />
Comment faire...
Effectuez les étapes suivantes:
1. Pour garder une trace du compteur, nous devons ajouter une variable globale au projet, avec une clé pour sauvegarder et restaurer. Ajoutez le code suivant à MainActivity. classe Java:
static final String KEY_COUNTER = "COUNTER"; int int mCounter = 0;
2. Ensuite, ajoutez le code nécessaire pour gérer le bouton; il incrémente le compteur et affiche le résultat dans le widget TextView:
public void onClickCounter (Voir la vue) {mCounter ++;
((TextView) findViewById (R.id.textViewCounter)). SetText ("Compteur:" + Integer.toString (mCounter));
}
3. Pour recevoir des notifications de changement d'état de l'application, nous devons ajouter
Méthodes onSaveInstanceState () et onRestoreInstanceState () à notre application. Ouvrez MainActivity.java et ajoutez ce qui suit:
@Passer outre
void protégé onSaveInstanceState (Bundle outState) {super.onSaveInstanceState (outState); outState.putInt (KEY_COUNTER, mCounter);
}
@Passer outre
void protégé onRestoreInstanceState (Bundle savedInstanceState) {super.onRestoreInstanceState (savedInstanceState); mCounter = savedInstanceState.getInt (KEY_COUNTER);
}
4. Exécutez le programme et essayez de changer l'orientation pour voir comment elle se comporte (si vous utilisez l'émulateur, Ctrl + F11 fera pivoter l'appareil).
Comment ça marche...
Toutes les activités passent par plusieurs états au cours de leur vie. En configurant des rappels pour gérer les événements, notre code peut enregistrer des informations importantes avant que l'activité ne soit détruite.
L'étape 3 est l'endroit où la sauvegarde et la restauration se produisent réellement. Le système envoie un bundle (un objet de données qui utilise également des paires nom / valeur) aux méthodes. Nous utilisons le rappel onSavelnstanceState () pour sauvegarder les données et les retirer dans le
OnRestoreInstanceState () callback.
Mais attendez! Avez-vous essayé de taper du texte dans la vue EditText avant de faire pivoter l'appareil? Si c'est le cas, vous avez remarqué que le texte a également été restauré, mais nous n'avons aucun code pour gérer cette vue. Par défaut, le système sauvegardera automatiquement l'état, à condition qu'il ait un identifiant unique (toutes les vues n'ont pas automatiquement leur état sauvegardé, tel que le Textview, mais nous pouvons le sauvegarder manuellement si nous le voulons).
Notez que si vous voulez qu'Android sauvegarde et restaure automatiquement l'état d'une vue, il doit avoir un identifiant unique (spécifié avec l'attribut android: id = dans la mise en page). Il faut se méfier; Tous les types de vue ne sont pas automatiquement enregistrés et restaurent l'état d'une vue.
Il y a plus...
Le rappel onRestoreInstanceState () n'est pas le seul endroit où l'état peut être restauré. Regardez la signature de onCreate ():
onCreate (Bundle savedInstanceState)
Les deux méthodes reçoivent la même instance de bundle nommée savedInstanceState. Vous pouvez déplacer le code de restauration vers la méthode onCreate () et cela fonctionnera de la même manière.
Mais un attrape est que le bundle savedInstanceState sera nul s'il n'y a pas de données, comme lors de la création initiale de l'activité. Si vous souhaitez déplacer le code depuis le rappel onRestoreInstanceState (), vérifiez que les données ne sont pas nulles, comme suit:
if (savedInstanceState! = null) {
mCounter = savedInstanceState.getInt (KEY_COUNTER);
}
Voir également
► La recette de stockage des données d'activité persistante introduira un stockage persistant.
► Jetez un œil au chapitre 6, Travailler avec des données, pour plus d'exemples sur les activités Android.
► La recette Comprendre le cycle de vie de l'activité explique le cycle de vie de l'activité Android.
m-
- Détails
- Écrit par Severin Mbekou
- Catégorie : Introduction à android
- Affichages : 21
L'objet d'intention est défini en tant qu'objet de messagerie. En tant qu'objet de message, son but est de communiquer avec d'autres composants de l'application. Dans cette recette, nous allons vous montrer comment transmettre des informations avec l'intention et comment les récupérer.
Se préparer
Cette recette reprendra d'où la précédente s'est terminée. Nous appellerons ce projet SendData.
Comment faire...
Puisque cette recette est basée sur la recette précédente, la plupart du travail est déjà fait.
Nous ajouterons un élément EditText à l'activité principale pour que nous ayons quelque chose à envoyer à SecondActivity. Nous allons utiliser la vue TextView (générée automatiquement) pour afficher le message. Voici les étapes complètes:
1. Ouvrez activity_main.xml, supprimez l'élément <TextView> existant et ajoutez l'élément <EditText> suivant:
<EditText
android: id = "@ + id / editTextData"
android: layout_width = "match_parent"
android: layout_height = "wrap_content" />
L'élément <Button> que nous avons créé dans la recette précédente ne change pas.
2. Maintenant, ouvrez le fichier MainActivity.java et modifiez le
Méthode onClickSwitchActivity () comme suit:
public void onClickSwitchActivity (Voir la vue) {
EditText editText = (EditText) findViewById (R.id.editTextData); String texte = editText.getText (). ToString ();
Intention intention = nouvelle intention (this, SecondActivity.class);
intention.putExtra (Intent.EXTRA_TEXT, texte);
startActivity (intention);
}
3. Ensuite, ouvrez le fichier activity_second.xml et modifiez l'élément <TextView> pour inclure l'attribut ID:
<TextView
android: id = "@ + id / textViewText"
android: text = "@ chaîne / hello_world"
android: layout_width = "wrap_content"
android: layout_height = "wrap_content" />
4. La dernière modification consiste à modifier la deuxième activité pour rechercher ces nouvelles données et les afficher à l'écran. Ouvrez SecondActivity.java et éditez onCreate () comme suit:
void protégé onCreate (Bundle savedInstanceState) {super.onCreate (savedInstanceState); setContentView (R.layout.activity_second);
TextView textView = (TextView) findViewById (
R.id.textViewText);
if (getIntent ()! = null && getIntent (). hasExtra (
Intent.EXTRA_TEXT)) {
textView.setText (getIntent (). getStringExtra (
Intent.EXTRA_TEXT));
}
}
5. Maintenant, exécutez le projet. Tapez du texte sur l'activité principale et appuyez sur Lancer la deuxième activité pour la voir envoyer les données.
HD-
Comment ça marche...
Comme prévu, l'objet d'intention fait tout le travail. Nous avons créé une intention comme dans la recette précédente, puis ajouté des données supplémentaires. Avez-vous remarqué l'appel à la méthode putExtra ()? Dans notre exemple, nous avons utilisé l'attribut .exTRA_TEXT déjà défini comme identifiant, mais nous n'avons pas eu à le faire. Nous pouvons utiliser n'importe quelle clé que nous voulons (vous avez déjà vu ce concept si vous connaissez les paires nom / valeur).
Le point clé sur l'utilisation des paires nom / valeur est que vous devez utiliser le même nom pour récupérer les données. C'est pourquoi nous avons utilisé le même identifiant de clé lorsque nous avons lu les données supplémentaires avec
getStringExtra ().
La deuxième activité a été lancée avec l'intention que nous avons créée, il s'agit donc simplement d'obtenir l'intention et de vérifier les données envoyées avec. Nous faisons cela dans onCreate ():
textView.setText (getIntent (). getStringExtra (Intent.EXTRA_TEXT));
Il y a plus...
Nous ne sommes pas limités à simplement envoyer des données String. L'objet d'intention est très flexible et prend déjà en charge les types de données de base. Revenez à Android Studio et cliquez sur la méthode putExtra. Puis appuyez sur Ctrl et la barre d'espace. Android Studio affichera la liste de saisie semi-automatique afin que vous puissiez voir les différents types de données que vous pouvez stocker.
