Une Activité est une chose unique et ciblée que l’utilisateur peut faire, selon les documentations officielles d’Android.

Le terme provient clairement du verbe "agir" qui signifie essentiellement effectuer une action ou interagir avec quelque chose.

Même si nous pouvons avoir une activité sans composants visuels, la plupart des activités sont créées pour accueillir des vues et des widgets avec lesquels les utilisateurs peuvent interagir.

Les activités peuvent donc se référer vaguement à l’ensemble de l’écran avec lequel l’utilisateur va interagir.

Publier ses Vidéos en automatique sur 11 réseaux sociaux (TikTok, Instagram, Youtube, Facebook...)

Publier ses Vidéos en automatique ...
Publier ses Vidéos en automatique sur 11 réseaux sociaux (TikTok, Instagram, Youtube, Facebook...)

Avec cette façon de penser, voici quelques-unes des choses que nous pouvons faire à notre activité :

No. Action Description
1. Ouvrir une nouvelle activité Cela remplace alors la activité ou l’écran actuel.
2. Fermer l’activité actuelle Pour qu’elle ne soit plus visible pour nous. Le système Android ne la tuera pas complètement, il la mettra simplement en arrière-plan, de peur que vous n’y reveniez.
3. Faire pivoter l’appareil Disons que vous regardez une vidéo ou jouez à un jeu à partir de cette application et que vous voulez la voir dans une disposition différente. Ce processus entraîne la recréation de l’activité afin de répondre à vos besoins de mise en page.

En faisant des choses comme celles qui précèdent, le système Android déclenche plusieurs rappels du cycle de vie. Il s’agit essentiellement de méthodes qui sont activées de manière événementielle à différentes étapes du cycle de vie d’une "activité". Par exemple, création, pause, reprise, démarrage, redémarrage, arrêt, etc.

Mécanismes de présentation d’une "activité".

Les Activités peuvent être présentées de différentes manières dans android :

No. Mécanisme Description
1. Fenêtre plein écran : La façon la plus commune de présenter une activité, elle couvre tout l’écran.
2. Fenêtres flottantes : Les Activités peuvent être configurées comme des fenêtres flottantes via un thème dont l’attribut windowIsFloating est défini.
3. Embedding : Les activités peuvent également être intégrées à l’intérieur d’une autre activité en utilisant ActivityGroup.

Cependant, notez que l’incorporation n’est plus intéressante car l’ActivityGroup a été déprécié avec l’introduction de Fragments au Niveau 13 de l’API. Les fragments et l’API Fragment Transaction font cela mieux et de manière plus modulaire, les fragments étant en fait des sous-activités avec leur propre cycle de vie.

Définition de la classe Activity.

Voyons aussi une description programmatique d’une activité.

Tout d’abord, il appartient au paquet android.app :

package android.app;

Activity est une classe comme n’importe quelle autre classe mais aussi unique à sa manière aussi. Elle est aussi publique, donc visible et utilisable dans d’autres packages que le sien.

public class Activity..{}

Le fait d’être une classe fait qu’elle a aussi des caractéristiques orientées objet que les autres classes ont comme :

  1. La capacité de dériver d’autres classes et d’en être dérivé.
  2. Capacité à mettre en œuvre des interfaces.
  3. Capacité à avoir ses propres méthodes, champs et classes internes.

En fait, la classe Activity dérive de la classe ContextThemeWrapper.

public class Activity extends ContextThemeWrapper..{}

Le ContextThemeWrapper donne à la classe la capacité de manipuler et de modifier le thème à partir de ce qui est dans le contexte enveloppé.

De plus, une Activité implémente plusieurs interfaces :

public class Activity extends ContextThemeWrapper implements LayoutInflater.Factory2 Window.Callback KeyEvent.Callback View.OnCreateContextMenuListener ComponentCallbacks2{}
Les enfants et les petits-enfants de Activity

Ce sont les sous-classes directes et les sous-classes indirectes de Activity.

Voici les sous-classes directes :

No. Activité Description
1. FragmentActivity La super classe utilisée par les activités qui veulent utiliser les API Fragments et Loader en utilisant la bibliothèque de support.
2. NativeActivity Pour ceux qui veulent une activité pratique à mettre en œuvre purement en code natif.
3. ListActivity Une activité spécialisée dans l’affichage d’une liste d’éléments liés à une source de données.
4. ExpandableListActivity Une activité spécialisée dans l’affichage d’une liste extensible d’éléments liés à une source de données.
5. AliasActivity Fournit un mécanisme de type alias à une activité. Elle le fait en lançant une autre activité puis en se tuant elle-même.
6. AccountAuthenticatorActivity Super classe pour créer des activités qui implémentent AbstractAccountAuthenticator.
7. ~ActivityGroup~ Déprécié dans l’API 13 après l’introduction de Fragments. Avant cela, c’était la façon de créer un écran qui a plusieurs activités intégrées.

Ce sont les enfants de l’activité.

Regardons maintenant les sous-classes des petits-enfants/indirects.

No. Activité Parent principal Description
L’activité AppCompatActivity est la super-classe des activités qui prévoient d’utiliser les fonctions de la barre d’action.
2. ~ActionBarActivity~ AppCompatActivity Déprécié. Avant cela, elle était utilisée pour fournir des fonctionnalités de barre d’action aux activités. Maintenant ce rôle est passé à AppCompatActivity.
3. ~TabActivity~ ActivityGroup Déclassé depuis le niveau 13 de l’API. Avant cela, il était utilisé pour créer des activités à onglets, ce que les fragments peuvent maintenant faire.
4. PreferenceActivity ListActivity La super classe à utiliser pour ceux qui ont l’intention de montrer une hiérarchie de préférences aux utilisateurs.
5. LauncherActivity ListActivity Ceci affichera une liste de toutes les activités qui peuvent être exécutées pour une intention donnée.

Capacités La classe d’activité fournit ses enfants

Nous pouvons, et avons dit que les activités représentent la chose unique qu’un utilisateur peut faire.

Nous savons donc qu’elles nous permettent d’utiliser et de rendre des vues et des widgets avec lesquels les utilisateurs peuvent interagir.

Cependant, venons-en maintenant à l’exploration de fonctionnalités plus détaillées et spécifiques d’un niveau inférieur que la classe Activity donne à ses enfants.

1. Capacités contextuelles
  1. Vérification de diverses permissions : Par exemple : le checkPermission(String permission, int pid, int uid) déterminera si un processus particulier et un ID utilisateur s’exécutant dans le système a la permission passée, le checkUriPermission(Uri uri, int pid, int uid, int modeFlags) déterminera si un processus particulier et un ID utilisateur s’exécutant dans le système a la permission d’accéder à l’Uri passée, etc.
  2. Connexion à ou création d’un service d’application : Le contexte peut être utilisé pour se connecter à un service d’application ou le créer si nécessaire.Cela se fait via l’appel de méthode bindService(Intent service, ServiceConnection conn, int flags).
    3.Créer d’autres Contextes : Par exemple, createConfigurationContext(Configuration overrideConfiguration) créera un nouvel objet Contexte pour le contexte actuel mais avec des ressources ajustées à la configuration passée, createPackageContext(String packageName, int flags) renvoie un nouvel objet Contexte pour le nom d’application donné.
  3. Liste des bases de données et des fichiers associés : databaseList() nous fournira un tableau de chaînes avec les bases de données privées associées au paquet d’application de ce Contexte tandis que fileList() renvoie un tableau de chaînes avec les fichiers privés associés au paquet d’application de ce Contexte.
  4. Supprimer la base de données et le fichier associés : Context fournit deux méthodes : deleteDatabase(String name) pour supprimer la SQLiteDatabase associée au paquetage d’application de ce Contexte et deleteFile(String name) pour supprimer le fichier privé donné associé au paquetage d’application de ce Contexte.
    6.Obtenir le contexte de l’application : La fonction getApplicationContext() du Contexte nous renverra l’unique objet global Application du processus en cours.
    7.Récupérer les informations de l’application : Via la fonction getApplicationInfo(), nous pouvons obtenir les informations complètes sur l’application du paquetage du Contexte actuel.

Exemples d’activités rapides

1. Comment démarrer une Activité ?

Pour démarrer une activité, vous avez besoin d’un objet Intent. Créons une méthode qui peut démarrer pour nous une Activity. Cette méthode prendra un objet contextuel ainsi que le nom de classe de l’activité cible, c’est-à-dire l’activité que nous voulons ouvrir.

    void start(Context c, Class e){
        Intent i = new Intent(,e);
        c.startActivity(i);
        //a.finish();
    }
2. Comment terminer/tuer une Activity ?

Pour terminer une activité, nous utilisons la méthode finish().

    void killIntent(Context c){
        Intent i = new Intent(c,MainActivity.class);
        c.startActivity(i);
        c.finish();
    }
3. Comment déterminer si une activité est au premier plan ?

Cet exemple de méthode peut déterminer pour nous si une activité est au premier plan ou non. Elle retourne une valeur booléenne en fonction du résultat.

    public static boolean isForeground(Context context, String className) {
        if (context == null || TextUtils.isEmpty(className)) {
            returnfalse;
        }
        ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
        List<ActivityManager.RunningTaskInfo> list = am.getRunningTasks(1);
        if (list != null && list.size() > 0) {
            ComponentName cpn = list.get(0).topActivity;
            if (className.equals(cpn.getClassName())) {
                return true;
            }
        }
        returnfalse;
    }

    public static boolean isForeground(Activity activity) {
        return isForeground(activity, activity.getClass().getName());
    }
4. Comment gérer le retour en arrière ?

Disons que vous voulez gérer correctement le backpress dans le sens où vous voulez peut-être montrer à l’utilisateur un dialogue d’alerte avant de simplement quitter l’activité en cours. Dans ce cas, vous créez une méthode handleBackPress().

    public void handleBackPress() {
        mExitDialog = true;
        AlertDialog.Builder builder = new AlertDialog.Builder(getActivity(), R.style
                .AlertDialogStyle);
        builder.setTitle(R.string.leave_chat)
                .setMessage(R.string.leave_chat_desc)
                .setCancelable(false)
                .setNegativeButton(R.string.cancel,
                        new DialogInterface.OnClickListener() {
                            public void onClick(DialogInterface dialog, int id) {
                                mExitDialog = false;
                                dialog.cancel();
                            }
                        })
                .setPositiveButton(R.string.ok, new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialogInterface, int i) {
                        //showSaveHistoryDialog();
                    }
                });
        AlertDialog alert = builder.create();
        alert.show();
        alert.getWindow().setBackgroundDrawable(new ColorDrawable(getResources().getColor(R.color
                .black14)));
    }

Dans le cas ci-dessus, nous montrons un dialogue d’alerte à l’utilisateur lorsqu’il clique sur le bouton retour.

Android AppCompatActivity

AppCompatActivity est une classe qui agit comme la super classe pour les activités qui veulent profiter des fonctionnalités de la barre d’action de la bibliothèque de support.

Les conditions requises pour utiliser la android.support.v7.app.ActionBar dans votre activité sont les suivantes :

  1. Exécuter le Niveau API 7 ou plus.
  2. Puis étendre cette classe.
  3. Définissez votre thème d’activité à android.support.v7.appcompat.R.style#Theme_AppCompat Theme.AppCompat ou un thème similaire.

Les thèmes sont définis dans le AndroidManifest.xml par exemple

<activity
      android_name=".MainActivity"
      android_label="@string/app_name"
      android_theme="@style/AppTheme.NoActionBar">....</activity>

AppCompatActivity est défini à l’intérieur du paquet android.support.v7.app :

package android.support.v7.app;

Il dérive de android.support.v4.app.FragmentActivity :

public class AppCompatActivity extends FragmentActivity{}

Et implémente plusieurs interfaces :

public class AppCompatActivity extends FragmentActivity implements AppCompatCallback,TaskStackBuilder.SupportParentable, ActionBarDrawerToggle.DelegateProvider {}

Voici un exemple de classe dérivant de AppCompatActivity :

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
}

Configuration du thème AppCompatActivity.

AppCompatActivity comme les autres thèmes d’activité peut être défini soit via androidmanifest.

<activity
      android_name=".MainActivity"
      android_label="@string/app_name"
      android_theme="@style/AppTheme.NoActionBar">....</activity>

soit de manière programmatique via la méthode setTheme() :

public void setTheme(@StyleRes final int resid) {}

Nous pouvons créer un thème matériel personnalisé qui sera utilisé par AppCompatActivity :

<resources>

    <!-- Base application theme. -->
    <style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
        <!-- Customize your theme here. -->
        <item name="colorPrimary">@color/colorPrimary</item>
        <item name="colorPrimaryDark">@color/colorPrimaryDark</item>
        <item name="colorAccent">@color/colorAccent</item>
    </style>

</resources>

Ensuite, nous pouvons également définir ce thème globalement à l’ensemble de l’application de cette façon en utilisant l’attribut android:theme="..." :

<application
        android_allowBackup="true"
        android_icon="@mipmap/ic_launcher"
        android_label="@string/app_name"
        android_roundIcon="@mipmap/ic_launcher_round"
        android_supportsRtl="true"
        android_theme="@style/AppTheme">
        <activity android_name=".MainActivity">

        </activity>
    </application>

Récupération de la barre d’action AppCompatActivity.

AppCompatActivity nous donne une méthode pour récupérer une référence à sa barre d’action :

public ActionBar getSupportActionBar(){}

Si elle n’en a pas, alors null est retourné.

Utiliser ToolBar comme barre d’action dans AppCompatActivity

Nous pouvons utiliser android.support.v7.widget.Toolbar au lieu d’une barre d’action. Les barres d’outils ont l’avantage de la flexibilité dans l’utilisation et les personnalisations.

Les barres d’action font normalement partie du décor opaque de la fenêtre de l’activité. Elles sont donc contrôlées par le framework.

En revanche, les barres d’outils peuvent être utilisées dans la mise en page de votre application. Elles sont donc flexibles.

Disons que nous avons une barre d’outils définie comme suit :

...
<android.support.v7.widget.Toolbar
            android_id="@+id/toolbar"
            android_layout_width="match_parent"
            android_layout_height="?attr/actionBarSize"
            android_background="?attr/colorPrimary"
            app_popupTheme="@style/AppTheme.PopupOverlay" />
...

dans notre activity_main.xml.

Nous pouvons l’utiliser comme barre d’action en utilisant la fonction setSupportActionBar() où nous passons la référence toolbar comme paramètre.

public void setSupportActionBar(@Nullable Toolbar toolbar) {}

Exemple :

Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
setSupportActionBar(toolbar);

Pour l’effacer, on passe null.

Android Studio – Création d’un projet d’activité vide

Comment créer une activité vide dans Android Studio.

Comment créer un projet dans android studio avec le modèle Empty Activity. Nous voyons comment utiliser Android studio pour créer une activité vide.

Empty Activity est juste un modèle pour le développement Android. C’est le modèle le plus facile à utiliser pour commencer car il génère pour nous un seul fichier java et un seul fichier de mise en page xml.

Voici le processus.

  1. Tout d’abord créer un projet vide dans android studio. Allez à File –> New Project.
  2. Tapez le nom de l’application et choisissez le nom de l’entreprise.
  3. Choisissez le SDK minimum.
  4. Choisissez Empty activity.
  5. Cliquez sur Terminer.

Cela va générer pour nous un projet avec les éléments suivants :

No. Nom Type Description
1. activity_main.xml XML Layout Sera gonflé dans la vue MainActivity. Vous ajoutez vos vues et widgets ici.
2. MainActivity.java Class Votre activité de lanceur

L’activité sera automatiquement enregistrée dans le android_manifest.xml. Les activités Android sont des composants et doivent normalement être enregistrées en tant que composant d’application.
Si vous avez créé le vôtre manuellement, alors enregistrez-le à l’intérieur de <application>...<application> comme suit, en remplaçant le MainActivity par le nom de votre activité :

        <activity android_name=".MainActivity">
            <intent-filter>
                <action android_name="android.intent.action.MAIN" />
                <category android_name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

Vous pouvez voir qu’une action et une catégorie sont spécifiées comme filtres d’intention. La catégorie fait de notre MainActivity une activité de lancement. Les activités de lancement sont exécutées en premier lorsque l’application Android est lancée.

Android Studio – Création d’un projet d’activité de base

Comment créer un projet dans Android Studio avec le modèle Basic Activity.

Ceci est un tutoriel pour les débutants pour voir comment créer un projet Android basé sur le modèle de base.

Voici le processus :

  1. Tout d’abord, créez un nouveau projet dans android studio. Allez à File –> New Project.
  2. Tapez le nom de l’application et choisissez le nom de l’entreprise.
  3. Choisissez le SDK minimum.
  4. Choisissez l’activité de base.
  5. Cliquez sur Terminer.

L’activité de base aura une barre d’outils et un bouton d’action flottant déjà ajoutés dans la mise en page.

Normalement, deux mises en page sont générées avec cette option :

No. Nom Type Description
1. activity_main.xml XML Layout Sera gonflé dans MainActivity Layout.Typiquement contient appbarlayout avec barre d’outils.a aussi un bouton d’action flottant.
2. content_main.xml XML Layout Sera inclus dans activity_main.xml.Vous ajoutez vos vues et widgets ici.
3. MainActivity.java Classe Activité principale.

Dans cet exemple, j’ai utilisé une activité de base.

L’activité sera automatiquement enregistrée dans le fichier android_manifest.xml. Les activités Android sont des composants et doivent normalement être enregistrées en tant que composant de l’application.

Si vous avez créé le vôtre manuellement, alors enregistrez-le à l’intérieur du <application>...<application> comme suit, en remplaçant le MainActivity par le nom de votre activité :


        <activity android_name=".MainActivity">

            <intent-filter>

                <action android_name="android.intent.action.MAIN" />

                <category android_name="android.intent.category.LAUNCHER" />

            </intent-filter>

        </activity>

Vous pouvez voir qu’une action et une catégorie sont spécifiées comme filtres d’intention. La catégorie fait de notre MainActivity une activité de lancement. Les activités de lancement sont exécutées en premier lorsque l’application androïde est lancée.

Avantage de la création d’un projet d’activité de base

Vous pouvez choisir une activité vide plutôt qu’une activité de base pour ce projet.

Cependant, l’activité de base présente les avantages suivants :

No. Avantage
L’utilisation d’une barre d’outils prête à l’emploi qui nous donne les caractéristiques d’une barre d’action tout en étant facilement personnalisable.
La barre d’outils nous fournit une mise en page qui met en œuvre les concepts de la barre d’outils de conception matérielle.
3. Fournit un FloatinActionButton que nous pouvons facilement utiliser pour lancer des actions rapides, en particulier dans des exemples comme ceux-ci.
4. Découpler nos vues de contenu personnalisé et les widgets des fonctionnalités de modélisation comme la barre d’outils.

Structure du projet généré

AndroidStudio va générer pour vous un projet avec des configurations par défaut via un ensemble de fichiers et de répertoires.

Voici les plus importants d’entre eux :

No. Fichier Responsabilité majeure
1. build/ Un répertoire contenant les ressources qui ont été compilées à partir de la construction de l’application et les classes générées par les outils android. Un tel outil est le fichier R.java. Le fichier R.java contient normalement les références aux ressources de l’application.
2. libs/ Pour contenir les bibliothèques que nous utilisons dans notre projet.
3. src/main/ Pour contenir le code source de notre application, c’est le dossier principal avec lequel vous travaillez.
4. src/main/java/ Contient nos classes java organisées en paquets.
5. src/main/res/ Contient nos dossiers de ressources de projet comme suit.
6. src/main/res/drawable/ Contient nos ressources de dessin.
7. src/main/res/layout/ Contient nos ressources de mise en page.
8. src/main/res/menu/ Contient le code XML de nos ressources de menu.
9. src/main/res/values/ Contient le code XML de nos ressources de valeurs, qui définissent des ensembles de paires nom-valeur et peuvent être des chaînes de caractères, des styles et des couleurs.
10. AndroidManifest.xml Ce fichier est généré automatiquement lors de la création d’un projet android et définit les informations de base nécessaires au système android, comme le nom de l’application, le nom du paquet, les permissions, les activités, les intentions, etc.
11. build.gradle Script Gradle utilisé pour construire l’application android.

Activités Android – Passer des primitives d’une activité à une autre

Voyons comment passer des types de données primitives d’une activité à une autre. Nous passons :

  • Chaînes de caractères
  • Entier
  • Boolean (via CheckBox)

Première activité

Deuxième activité

vers une deuxième activité et les afficher dans la deuxième activité.

Fichiers Gradle

Nous allons ajouter des dépendances dans le fichier build.gradle au niveau de l’application.

1. Build.gradle

Voici notre niveau d’application dans le fichier build.gradle :

    dependencies {
        implementation fileTree(dir: 'libs', include: ['*.jar'])
        testImplementation 'junit:junit:4.12'
        implementation 'com.android.support:appcompat-v7:24.2.1'
        implementation 'com.android.support:design:24.2.1'
    }

`

RESSOURCES DE MISE EN PAGE

Nous avons trois layouts xml ;

  1. activité_main.xml
  2. contenu_main.xml
  3. activité_second.xml

1. activité_main.xml

  • Le modèle de mise en page pour notre activité principale.

    <?xml version="1.0" encoding="utf-8"?>
    <android.support.design.widget.CoordinatorLayout

        android_layout_width="match_parent"
        android_layout_height="match_parent"
        android_fitsSystemWindows="true"
        tools_context="com.tutorials.hp.primitivespassing.MainActivity">

        <android.support.design.widget.AppBarLayout
            android_layout_width="match_parent"
            android_layout_height="wrap_content"
            android_theme="@style/AppTheme.AppBarOverlay">

            <android.support.v7.widget.Toolbar
                android_id="@+id/toolbar"
                android_layout_width="match_parent"
                android_layout_height="?attr/actionBarSize"
                android_background="?attr/colorPrimary"
                app_popupTheme="@style/AppTheme.PopupOverlay" />

        </android.support.design.widget.AppBarLayout>

        <include layout="@layout/content_main" />

        <android.support.design.widget.FloatingActionButton
            android_id="@+id/fab"
            android_layout_width="wrap_content"
            android_layout_height="wrap_content"
            android_layout_gravity="bottom|end"
            android_layout_margin="@dimen/fab_margin"
            android_src="@android:drawable/ic_dialog_email" />

    </android.support.design.widget.CoordinatorLayout>

2. contenu_main.xml

  • Ajoutons ici nos edittexts et notre checkbox.

    <?xml version="1.0" encoding="utf-8"?>
    <RelativeLayout

        android_layout_width="match_parent"
        android_layout_height="match_parent"
        android_paddingBottom="@dimen/activity_vertical_margin"
        android_paddingLeft="@dimen/activity_horizontal_margin"
        android_paddingRight="@dimen/activity_horizontal_margin"
        android_paddingTop="@dimen/activity_vertical_margin"
        app_layout_behavior="@string/appbar_scrolling_view_behavior"
        tools_context="com.tutorials.hp.primitivespassing.MainActivity"
        tools_showIn="@layout/activity_main">

        <LinearLayout
            android_layout_width="match_parent"
            android_layout_height="wrap_content"
            android_orientation="vertical">

            <android.support.design.widget.TextInputEditText
                android_id="@+id/nameTxt"
                android_layout_width="match_parent"
                android_layout_height="wrap_content"
                android_enabled="true"
                android_focusable="true"
                android_hint="Name"
                android_textSize="25dp"
                android_textStyle="bold" />

            <android.support.design.widget.TextInputEditText
                android_id="@+id/txtID"
                android_layout_width="match_parent"
                android_layout_height="wrap_content"
                android_enabled="true"
                android_focusable="true"
                android_hint="ID"
                android_textSize="25dp"
                android_textStyle="bold" />

            <LinearLayout
                android_layout_width="match_parent"
                android_layout_height="wrap_content"
                android_orientation="horizontal"
                android_padding="5dp">

                <TextView
                    android_layout_width="250dp"
                    android_layout_height="wrap_content"
                    android_text="Technology Exists ??"
                    android_textSize="25dp"
                    android_textStyle="bold" />

                <CheckBox
                    android_id="@+id/techExists"
                    android_layout_width="wrap_content"
                    android_layout_height="wrap_content"
                    android_checked="true"
                    android_textSize="25dp" />
            </LinearLayout>
            <Button android_id="@+id/sendBtn"
                android_layout_width="wrap_content"
                android_layout_height="60dp"
                android_text="Send"
                android_clickable="true"
                android_padding="5dp"
                android_background="#009968"
                android_textColor="@android:color/white"
                android_textStyle="bold"
                android_textSize="20dp" />
        </LinearLayout>
    </RelativeLayout>

3. activité_second.xml

  • Voici le code de la deuxième activité.
  • Cette activité va recevoir les données de l’activité principale et les afficher ici.

    <?xml version="1.0" encoding="utf-8"?>
    <RelativeLayout

        android_layout_width="match_parent"
        android_layout_height="match_parent"
        android_paddingBottom="@dimen/activity_vertical_margin"
        android_paddingLeft="@dimen/activity_horizontal_margin"
        android_paddingRight="@dimen/activity_horizontal_margin"
        android_paddingTop="@dimen/activity_vertical_margin"
        tools_context="com.tutorials.hp.primitivespassing.SecondActivity">

        <LinearLayout
            android_layout_width="match_parent"
            android_layout_height="wrap_content"
            android_orientation="vertical">

            <LinearLayout
                android_layout_width="match_parent"
                android_layout_height="wrap_content"
                android_orientation="horizontal"
                android_padding="5dp">

                <TextView
                    android_layout_width="250dp"
                    android_layout_height="wrap_content"
                    android_text="NAME"
                    android_textSize="25dp"
                    android_textStyle="bold" />

                <TextView
                    android_id="@+id/nameTxtSecond"
                    android_layout_width="match_parent"
                    android_layout_height="wrap_content"
                    android_text="value received"
                    android_textSize="25dp" />
            </LinearLayout>

            <LinearLayout
                android_layout_width="match_parent"
                android_layout_height="wrap_content"
                android_orientation="horizontal"
                android_padding="5dp">

                <TextView
                    android_layout_width="250dp"
                    android_layout_height="wrap_content"
                    android_text="ID"
                    android_textSize="25dp"
                    android_textStyle="bold" />

                <TextView
                    android_id="@+id/txtIDSecond"
                    android_layout_width="match_parent"
                    android_layout_height="wrap_content"
                    android_text="value received"
                    android_textSize="25dp" />
            </LinearLayout>

            <LinearLayout
                android_layout_width="match_parent"
                android_layout_height="wrap_content"
                android_orientation="horizontal"
                android_padding="5dp">

                <TextView
                    android_layout_width="250dp"
                    android_layout_height="wrap_content"
                    android_text="Technology Exists ??"
                    android_textSize="25dp"
                    android_textStyle="bold" />

                <CheckBox
                    android_id="@+id/techExistsSecond"
                    android_layout_width="wrap_content"
                    android_layout_height="wrap_content"
                    android_checked="true"
                    android_textSize="25dp" />
            </LinearLayout>
        </LinearLayout>
    </RelativeLayout>

CLASSES JAVA

Nous avons deux classes ou deux activités :

  1. MainActivity.java
  2. DeuxièmeActivité.java

1. Classe MainActivity

  • Notre activité principale.
  • Nous allons passer les données de cette activité à la seconde activité.

    package com.tutorials.hp.primitivespassing;

    import android.content.Intent;
    import android.os.Bundle;
    import android.support.design.widget.FloatingActionButton;
    import android.support.design.widget.TextInputEditText;
    import android.support.v7.app.AppCompatActivity;
    import android.support.v7.widget.Toolbar;
    import android.view.View;
    import android.widget.Button;
    import android.widget.CheckBox;

    public class MainActivity extends AppCompatActivity {

        //DECLARE VIEWS
        private TextInputEditText txtName, txtID;
        private CheckBox chkTechnologyExists;
        private Button sendBtn;

        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
            setSupportActionBar(toolbar);

            this.initializeViews();

            FloatingActionButton fab = (FloatingActionButton) findViewById(R.id.fab);
            fab.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View view) {
                }
            });

            //WHEN SEND BTN IS CLICKED,SEND
            sendBtn.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View view) {
                    sendData();
                }
            });
        }

        /*
        REFERENCE VIEWS WE ARE USING
         */
        private void initializeViews() {
            txtName = (TextInputEditText) findViewById(R.id.nameTxt);
            txtID = (TextInputEditText) findViewById(R.id.txtID);
            chkTechnologyExists = (CheckBox) findViewById(R.id.techExists);
            sendBtn = (Button) findViewById(R.id.sendBtn);

        }

        /*
        SEND DATA TO SECOND ACTIVITY
         */
        private void sendData() {
            //GET PRIMITIVE VALUES TO SEND
            String name = txtName.getText().toString();
            int id = Integer.parseInt(txtID.getText().toString());
            Boolean techExists = chkTechnologyExists.isChecked();

            //PACK THEM IN AN INTENT OBJECT
            Intent i = new Intent(this, SecondActivity.class);
            i.putExtra("NAME_KEY", name);
            i.putExtra("ID_KEY", id);
            i.putExtra("TECHEXISTS_KEY", techExists);

            //LETS LEAVE OUR TXTS CLEARED
            txtName.setText("");
            txtID.setText("");

            //START SECOND ACTIVITY
            this.startActivity(i);
        }
    }

2. Classe de la seconde activité

  • Notre deuxième activité.
  • Recevra les données de l’activité principale et les montrera dans des textviews et checkbox.

    package com.tutorials.hp.primitivespassing;

    import android.support.design.widget.TextInputEditText;
    import android.support.v7.app.AppCompatActivity;
    import android.os.Bundle;
    import android.widget.CheckBox;
    import android.widget.Spinner;
    import android.widget.TextView;
    import android.widget.Toast;

    public class SecondActivity extends AppCompatActivity {

        //DECALRE SECOND ACTIVITY VIEWS
        TextView txtName2;
        TextView txtID2;
        CheckBox chkTechnologyExists2;

        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_second);

            //INITIALIZE THESE VIEWS
            txtName2 = (TextView) findViewById(R.id.nameTxtSecond);
            txtID2 = (TextView) findViewById(R.id.txtIDSecond);
            chkTechnologyExists2 = (CheckBox) findViewById(R.id.techExistsSecond);

            //RECEIVE DATA FROM MAIN ACTIVITY
            String name = getIntent().getStringExtra("NAME_KEY");
            int id = getIntent().getIntExtra("ID_KEY", 0);
            Boolean techExists = getIntent().getBooleanExtra("TECHEXISTS_KEY", false);

            //SHOW A TOAST
            Toast.makeText(SecondActivity.this, name, Toast.LENGTH_LONG).show();

            //SET THE DATA TO OUR LOCAL VIEWS
            txtName2.setText(name);
            txtID2.setText(String.valueOf(id));
            chkTechnologyExists2.setChecked(techExists);
        }
    }

Android ListActivity

Tutoriel et exemples de ListActivity Android.

Une ListActivity est une activité qui affiche une liste d’éléments en se liant à une source de données telle qu’un tableau ou un curseur. ListActivity nous expose également des gestionnaires d’événements lorsque l’utilisateur sélectionne un élément.

Il s’agit d’une classe qui dérive de la classe Activity. ListActivity est destinée à être utilisée lorsque vous prévoyez d’utiliser une [ListView] (https://camposha.info/android/listview). En fait, elle héberge un objet ListView qui peut être lié à différentes sources de données, généralement un tableau ou un curseur contenant les résultats d’une requête.

Définition de l’API ListActivity

ListActivity, comme nous l’avons dit dérive de la classe Activity.

public class ListActivity extends Activity

Voici sa hiérarchie d’héritage :

java.lang.Object
   ↳    android.content.Context
       ↳    android.content.ContextWrapper
           ↳    android.view.ContextThemeWrapper
               ↳    android.app.Activity
                   ↳    android.app.ListActivity

Sous-classes de ListActivity

Voici les classes qui dérivent de ListActivity :

No. Classe Description
Une classe qui affiche une liste de toutes les activités qui peuvent être exécutées pour une intention donnée. Se lance lorsqu’on clique dessus.
2. PreferenceActivity La classe de base pour une activité qui affiche une hiérarchie de préférences à l’utilisateur.

Disposition de l’écran

ListActivity a une disposition par défaut qui consiste en une liste unique, en plein écran, au centre de l’écran. Cependant, si vous le souhaitez, vous pouvez personnaliser la disposition de l’écran en définissant votre propre disposition de vue avec setContentView() dans onCreate(). Pour ce faire, votre propre vue DOIT contenir un objet ListView avec l’id code>&quot;@android:id/list&quot;</code (ou list si c’est dans le code)

En option, votre vue personnalisée peut contenir un autre objet de vue de n’importe quel type à afficher lorsque la vue de la liste est vide. Cet objet de vue "liste vide" doit avoir un id "android:id/empty". Notez que lorsqu’une vue vide est présente, la vue de la liste sera cachée lorsqu’il n’y a pas de données à afficher.

Le code suivant démontre une disposition d’écran personnalisée (laide). Il comporte une liste avec un fond vert, et un message alternatif rouge "pas de données".

 <?xml version="1.0" encoding="utf-8"?>
 <LinearLayout
         android_orientation="vertical"
         android_layout_width="match_parent"
         android_layout_height="match_parent"
         android_paddingLeft="8dp"
         android_paddingRight="8dp">

     <ListView android_id="@android:id/list"
               android_layout_width="match_parent"
               android_layout_height="match_parent"
               android_background="#00FF00"
               android_layout_weight="1"
               android_drawSelectorOnTop="false"/>

     <TextView android_id="@android:id/empty"
               android_layout_width="match_parent"
               android_layout_height="match_parent"
               android_background="#FF0000"
               android_text="No data"/>
 </LinearLayout>

Principaux exemples de ListActivity pour Android

Dans cette section, nous allons examiner plusieurs exemples complets de ListActivity.

1. ListActivity et OnItemClick

Dans ce premier exemple, nous allons voir comment remplir une activité de liste avec des données provenant d’un simple tableau. Nous verrons ensuite comment gérer les événements OnItemClick.

Les API que nous utilisons

Commençons par définir les différentes API que nous allons utiliser dans cet exemple.

(a). ListActivity

Cette classe appartient à android.app. Il s’agit d’une [activité] (https://camposha.info/android/activity) qui affiche une liste d’éléments en se liant à une source de données telle qu’un tableau ou un curseur, et qui expose des gestionnaires d’événements lorsque l’utilisateur sélectionne un élément.

(b). Bundle

Bundle est un mappage de valeurs String vers différents types de Parcelable.

Pour en savoir plus sur les bundles, cliquez ici.

(c). Vue

Cette classe représente le bloc de construction de base des composants de l’interface utilisateur. Une vue occupe une zone rectangulaire sur l’écran et est responsable du dessin et de la gestion des événements.

Pour en savoir plus sur les vues, cliquez ici.

(c). Adaptateur de tableau

Un arrayadapter est un BaseAdapter concret qui est soutenu par un tableau d’objets arbitraires. Par défaut, cette classe s’attend à ce que l’identifiant de ressource fourni fasse référence à un seul TextView.

Pour en savoir plus sur ArrayAdapter, cliquez ici.

(d). ListView

Une ListView est une vue qui affiche des éléments dans une liste à défilement vertical. Les éléments proviennent de l’adaptateur de liste associé à cette vue.

Lisez à propos de ListView [ici] (https://camposha.info/android/listview).

MyListActivity.java

import android.app.ListActivity;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.ArrayAdapter;
import android.widget.ListView;
import android.widget.Toast;

public class MyListActivity extends ListActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //setContentView(R.layout.activity_my_list);

        String[] values = new String[] { "Android", "iPhone", "WindowsMobile",
                "Blackberry", "WebOS", "Ubuntu", "Windows7", "Max OS X",
                "Linux", "OS/2" };
        ArrayAdapter<String> adapter = new ArrayAdapter<String>(this,android.R.layout.simple_list_item_1,values);
        setListAdapter(adapter);

    }
    @Override
    protected  void  onListItemClick(ListView l, View v, int position, long id){

        String item = (String) getListAdapter().getItem(position);
        Toast.makeText(this, item + " selected", Toast.LENGTH_LONG).show();

    }
}

activity_my_list.xml

<?xml version="1.0" encoding="utf-8"?>
<android.support.constraint.ConstraintLayout

    android_layout_width="match_parent"
    android_layout_height="match_parent"
    tools_context="com.codekul.myandroidlistactivity.MyListActivity">

    <TextView
        android_layout_width="wrap_content"
        android_layout_height="wrap_content"
        android_text="Hello World!"
        app_layout_constraintBottom_toBottomOf="parent"
        app_layout_constraintLeft_toLeftOf="parent"
        app_layout_constraintRight_toRightOf="parent"
        app_layout_constraintTop_toTopOf="parent" />

</android.support.constraint.ConstraintLayout>

Télécharger

No. Emplacement Lien
1. GitHub Browse 2. GitHub Original Creator : @1sumit 2.
2. GitHub Créateur original : @1sumit 2.

2. Exemple de ListActivity et ArrayAdapter

Remplissons une ListActivity avec des noms de chat et gérons les événements de clic. Nous n’avons pas besoin de layout pour cela.

MainActivity.java

import android.app.ListActivity;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.ArrayAdapter;
import android.widget.ListView;

public class MainActivity extends ListActivity {

    final String[] catNamesArray = new String[] { "Рыжик", "Барсик", "Мурзик",
            "Мурка", "Васька", "Томасина", "Бобик", "Кристина", "Пушок",
            "Дымка", "Кузя", "Китти", "Барбос", "Масяня", "Симба" };
    private ArrayAdapter<String> mAdapter;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mAdapter = new ArrayAdapter<>(this,
                android.R.layout.simple_list_item_1, catNamesArray);
        setListAdapter(mAdapter);

    }

    @Override
    protected void onListItemClick(ListView l, View v, int position, long id) {
        super.onListItemClick(l, v, position, id);
    }
}

Télécharger

No. Emplacement Lien
1. GitHub Télécharger
2. GitHub Browse 2. GitHub [Original Creator : @ @Checkland.com].
2. GitHub Créateur original : @disiol

3. ListActivity avec AsyncTask

MainActivity.java


import android.app.ListActivity;
import android.content.Intent;
import android.os.AsyncTask;
import android.view.View;
import android.widget.Adapter;
import android.widget.ListView;

import java.util.List;

public final class AppPickerActivity extends ListActivity {

  private AsyncTask<Object,Object,List<AppInfo>> backgroundTask;

  @Override
  protected void onResume() {
    super.onResume();
    backgroundTask = new LoadPackagesAsyncTask(this);
    backgroundTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
  }

  @Override
  protected void onPause() {
    AsyncTask<?,?,?> task = backgroundTask;
    if (task != null) {
      task.cancel(true);
      backgroundTask = null;
    }
    super.onPause();
  }

  @Override
  protected void onListItemClick(ListView l, View view, int position, long id) {
    Adapter adapter = getListAdapter();
    if (position >= 0 && position < adapter.getCount()) {
      String packageName = ((AppInfo) adapter.getItem(position)).getPackageName();
      Intent intent = new Intent();
      intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET);
      intent.putExtra("url", "market://details?id=" + packageName);
      setResult(RESULT_OK, intent);
    } else {
      setResult(RESULT_CANCELED);
    }
    finish();
  }

}

4. ListActivity – Cliquer pour ouvrir une nouvelle activité

C’est un exemple de ListActivity où nous regardons comment afficher des éléments dans une ListActivity. Ensuite, lorsque l’utilisateur clique sur un seul élément, nous ouvrons une nouvelle activité.

MainActivity.java

import android.app.Activity;
import android.app.ListActivity;
import android.content.Intent;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.widget.ArrayAdapter;
import android.widget.ListView;

public class MainActivity extends ListActivity {

    String[] names;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //setContentView(R.layout.activity_main);

        names = getResources().getStringArray(R.array.friends);
        setListAdapter(new ArrayAdapter<String>(this, R.layout.friend_item, names));

    }

    @Override
    protected void onListItemClick(ListView l, View v, int position, long id) {
        super.onListItemClick(l, v, position, id);

        Intent in = new Intent(this, SecondActivity.class);

        in.putExtra("message", getString(R.string.show_greetings)+ " " + names[(int) id] + "!" );

        startActivity(in);

    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.menu_main, menu);

        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        // Handle action bar item clicks here. The action bar will
        // automatically handle clicks on the Home/Up button, so long
        // as you specify a parent activity in AndroidManifest.xml.
        int id = item.getItemId();

        //noinspection SimplifiableIfStatement
        if (id == R.id.action_settings) {
            return true;
        }

        return super.onOptionsItemSelected(item);
    }
}

SecondActivity.java

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;
import android.widget.TextView;

public class SecondActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_second);

        Intent in = getIntent();

        TextView txtName = (TextView) findViewById(R.id.txtGreetingName);
        txtName.setText(in.getStringExtra("message"));
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.menu_second, menu);
        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        // Handle action bar item clicks here. The action bar will
        // automatically handle clicks on the Home/Up button, so long
        // as you specify a parent activity in AndroidManifest.xml.
        int id = item.getItemId();

        //noinspection SimplifiableIfStatement
        if (id == R.id.action_settings) {
            return true;
        }

        return super.onOptionsItemSelected(item);
    }
}

activity_main.xml

<RelativeLayout

    android_layout_width="match_parent"
    android_layout_height="match_parent"
    android_paddingLeft="@dimen/activity_horizontal_margin"
    android_paddingRight="@dimen/activity_horizontal_margin"
    android_paddingTop="@dimen/activity_vertical_margin"
    android_paddingBottom="@dimen/activity_vertical_margin"
    tools_context=".MainActivity">

    <TextView android_text="@string/hello_world"
        android_layout_width="wrap_content"
        android_layout_height="wrap_content"
        android_textSize="24sp"
        android_layout_alignParentTop="true"
        android_layout_centerHorizontal="true"
        android_layout_marginTop="54dp" />

</RelativeLayout>

activity_second.xml

<RelativeLayout
     android_layout_width="match_parent"
    android_layout_height="match_parent" android_paddingLeft="@dimen/activity_horizontal_margin"
    android_paddingRight="@dimen/activity_horizontal_margin"
    android_paddingTop="@dimen/activity_vertical_margin"
    android_paddingBottom="@dimen/activity_vertical_margin"
    tools_context="com.example.paulorogerio.friendgreeting.SecondActivity">

    <TextView android_text="@string/hello_world"
        android_layout_width="wrap_content"
        android_layout_height="wrap_content"
        android_textSize="24sp"
        android_gravity="center_vertical|center_horizontal"
        android_id="@+id/txtGreetingName"
        android_layout_alignParentTop="true"
        android_layout_centerHorizontal="true"
        android_layout_marginTop="55dp" />

</RelativeLayout>

friend_item.xml

<?xml version="1.0" encoding="utf-8"?>
<TextView
    android_layout_width="match_parent" android_layout_height="match_parent"
    android_text="Friend Name"
    android_gravity="center_vertical|center_horizontal"
    android_textSize="24sp"
    android_padding="20dp">

</TextView>

Téléchargement

No. Emplacement Lien
1. GitHub Télécharger
2. GitHub Browse 2. GitHub [Original Creator : @ @Checkland.com].
2. GitHub Original Creator : @paulonova 2. GitHub Original Creator : @paulonova 2.

5. Activité Liste – Remplissage à partir du XML stocké dans les actifs

Dans cet exemple, nous allons voir comment utiliser XmlPullParser pour analyser le document XML stocké dans le répertoire Assets de notre application.
Nous afficherons ensuite les résultats de l’analyse du document XML, qui comprendra des images et du texte, dans notre activité de liste.

Nous allons charger le titre, le lien et les images de notre document XML dans notre ListView. Nous allons ouvrir notre XML depuis le dossier des actifs dans un InputStream. Puis nous aurons une méthode ParseXML() qui analysera notre XML en utilisant le XmlPullParser.

La classe ImagesAdapter adaptera les images et le texte du XML dans une ListView personnalisée. Elle utilise ArrayAdapter comme classe d’adaptateur de base.

ParseXML.java

Ce ParseXML est l’activité principale.

package com.example.parsexml;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;

import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

import org.xml.sax.InputSource;
import org.xml.sax.XMLReader;

import android.app.Activity;
import android.os.Bundle;
import android.view.Menu;
import android.widget.ListView;

public class ParseXML extends Activity {
    InputStream xmlStream;
    ArrayList<ItemData> list;
    XMLHandler handler;
    ListView listView;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_parse_xml);
        try {
            xmlStream = this.getAssets().open("ItemXML.xml");
            ParseXML();
            list = handler.getItemList();
            LoadImagesFromUrl();
            ImageAdapter adapter = new ImageAdapter(ParseXML.this, R.layout.imagelist, list);
            listView = (ListView) findViewById(R.id.imageList);
            listView.setAdapter(adapter);

        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.activity_parse_xml, menu);
        return true;
    }

    public void ParseXML(){

        try {
            SAXParserFactory spf = SAXParserFactory.newInstance();
            SAXParser sp = spf.newSAXParser();
            XMLReader reader = sp.getXMLReader();
            handler = new XMLHandler();
            reader.setContentHandler(handler);
            reader.parse(new InputSource(xmlStream));
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    public void LoadImagesFromUrl(){
        for (int i=0; i<list.size();i++){
            LoadChart loader = new LoadChart(ParseXML.this, list.get(i).link);
            loader.execute();
            list.get(i).bitmap = loader.getBitmap();
        }
    }
}

ItemData.java

Il s’agit de la classe modèle et représente un seul élément XML qui composera notre élément ListView. Nous aurons le titre, le lien ainsi que le bitmap.

package com.example.parsexml;

import android.graphics.Bitmap;

public class ItemData {
    String title;
    String link;
    Bitmap bitmap;
    public Bitmap getBitmap() {
        return bitmap;
    }
    public void setBitmap(Bitmap bitmap) {
        this.bitmap = bitmap;
    }
    public String getTitle() {
        return title;
    }
    public void setTitle(String title) {
        this.title = title;
    }
    public String getLink() {
        return link;
    }
    public void setLink(String link) {
        this.link = link;
    }

}

ImageAdapter.java

C’est la classe d’adaptateur personnalisée, dérivant du ArrayAdapter. Elle utilise le pattern ViewHolder pour contenir les vues à recycler. Ce ViewHolder est juste une simple classe pour contenir les widgets TextView et ImageView à recycler, au lieu qu’ils soient gonflés à chaque fois que la méthode getView() est appelée.

package com.example.parsexml;

import java.util.List;

import android.content.Context;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ArrayAdapter;
import android.widget.ImageView;
import android.widget.TextView;

public class ImageAdapter extends ArrayAdapter{
    ViewHolder holder;
    Context ctx;
    List<ItemData> list;
    LoadChart loader;
    public ImageAdapter(Context context, int textViewResourceId,
            List<ItemData> objects) {
        super(context, textViewResourceId, objects);
        ctx = context;
        list = objects;

        // TODO Auto-generated constructor stub
    }
    private class ViewHolder{
        TextView titleView;
        ImageView img;
    }
    @Override
    public View getView(int position, View convertView, ViewGroup parent) {
        // TODO Auto-generated method stub
        if(convertView == null){
            LayoutInflater inflater = (LayoutInflater) ctx.getSystemService(ctx.LAYOUT_INFLATER_SERVICE);
            convertView = inflater.inflate(R.layout.imagelist, null);
            holder = new ViewHolder();
            holder.img = (ImageView) convertView.findViewById(R.id.linkimage);
            holder.titleView = (TextView) convertView.findViewById(R.id.title);

            convertView.setTag(holder);

        }
        else{
            holder = (ViewHolder) convertView.getTag();
        }
        holder.titleView.setText(list.get(position).title);
        loader = new LoadChart(ctx, holder.img, list.get(position).link);
        loader.execute();

        return convertView;

    }

}

XMLHandler.java

Cette classe dérive de la classe org.xml.sax.helpers.DefaultHandler. DefaultHandler est la classe de base par défaut pour les gestionnaires d’événements SAX2. Dans cette classe, nous surchargeons plusieurs méthodes comme les méthodes startElement(), endElement() et characters().

package com.example.parsexml;

import java.util.ArrayList;

import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

public class XMLHandler extends DefaultHandler{
    private ArrayList<ItemData> itemList = new ArrayList<ItemData>();
    String value = "";
    ItemData item = null;
    Boolean flag = false;

    public ArrayList<ItemData> getItemList() {
        return itemList;
    }

    public void setItemList(ArrayList<ItemData> itemList) {
        this.itemList = itemList;
    }

    @Override
    public void characters(char[] ch, int start, int length)
            throws SAXException {
        // TODO Auto-generated method stub
        if(flag){
            value = new String(ch, start, length);
        }
    }

    @Override
    public void endElement(String uri, String localName, String qName)
            throws SAXException {
        // TODO Auto-generated method stub
        flag = false;

        if(localName.equalsIgnoreCase("title")){
            item.setTitle(value);
        }
        if(localName.equalsIgnoreCase("link")){
            item.setLink(value);
        }
        if(localName.equalsIgnoreCase("item")){
            itemList.add(item);
        }

    }

    @Override
    public void startElement(String uri, String localName, String qName,
            Attributes attributes) throws SAXException {
        // TODO Auto-generated method stub
        flag = true;
        value = "";
        if(localName.equalsIgnoreCase("item")){
            item = new ItemData();

        }
    }

}

LoadChart.java

Cette classe va dériver de la classe abstraite asynctask. Ainsi cela nous permet de charger notre XML dans un thread séparé.

package com.example.parsexml;

import java.io.IOException;
import java.io.InputStream;
import java.net.HttpURLConnection;
import java.net.URL;
import java.net.URLConnection;

import android.app.ProgressDialog;
import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.os.AsyncTask;
import android.util.Log;
import android.widget.ImageView;

public class LoadChart extends AsyncTask<Void, Void, Bitmap> {
    private ImageView img;
    private Context con;
    static String urlString ;
    Bitmap bitmap= null;

    public Bitmap getBitmap() {
        return bitmap;
    }

    public void setBitmap(Bitmap bitmap) {
        this.bitmap = bitmap;
    }

    public LoadChart(Context context, ImageView img1, String url) {
        this.img = img1;
        this.con = context;
        urlString = url;
    }

    public LoadChart(Context context, String url) {
        this.urlString = url;
        this.con = context;
    }

    @Override
    protected void onPreExecute() {

        super.onPreExecute();
    }

    @Override
    protected Bitmap doInBackground(Void... params) {

        Bitmap bitmap = DownloadImage();

        return bitmap;
    }

    @Override
    protected void onPostExecute(Bitmap bitmap) {
        this.bitmap = bitmap;
        //img.setImageBitmap(bitmap);

    }

    private static InputStream OpenHttpConnection(String urlString)
            throws IOException {

        Log.d("palval", "OpenHttpConnection");
        InputStream in = null;
        int response = -1;

        URL url = new URL(urlString);
        URLConnection conn = url.openConnection();

        if (!(conn instanceof HttpURLConnection))
            throw new IOException("Not an HTTP connection");

        try {
            HttpURLConnection httpConn = (HttpURLConnection) conn;
            httpConn.setAllowUserInteraction(false);
            httpConn.setInstanceFollowRedirects(true);
            httpConn.setRequestMethod("GET");
            httpConn.connect();

            response = httpConn.getResponseCode();

            if (response == HttpURLConnection.HTTP_OK) {
                in = httpConn.getInputStream();
            }

            String res = Integer.toString(response);
        } catch (Exception ex) {
            throw new IOException("Error connecting");
        }
        return in;
    }

    public static Bitmap DownloadImage() {
        Log.d("palval", "DownloadImage");
        Bitmap bitmap = null;
        InputStream in = null;
        try {

             //in = OpenHttpConnection("https://chart.googleapis.com/chart?chs=440x220&chd=t:60,40&cht=p3&chl=Hello|World");
            in = OpenHttpConnection(urlString);
            bitmap = BitmapFactory.decodeStream(in);
            in.close();
        } catch (IOException e1) {
            // TODO Auto-generated catch block
            e1.printStackTrace();
        }
        return bitmap;
    }

}

Téléchargement

No. Emplacement Lien
1. GitHub Télécharger
2. GitHub Browse
2. GitHub Créateur original : @bansal2211

Android ListActivity – Avec Images,Texte et OnItemClick ArrayAdapter

*Android ListActivity Images Texte

Ceci est un tutoriel sur les listes personnalisées Android. Comment afficher des images et du texte dans une liste. Nous utilisons arrayadapter comme adaptateur de choix. Nous voyons également comment gérer les clics sur les éléments de la liste personnalisée.

Section 1 : Classe CustomAdapter

Voici notre classe CustomAdapter. Elle sous-classe android.widget.ArrayAdapter. Pour en savoir plus sur ArrayAdapter, cliquez ici.

C’est notre classe d’adaptateur.

    package com.tutorials.customlistviewarrayadapter;

    import android.content.Context;
    import android.view.LayoutInflater;
    import android.view.View;
    import android.view.ViewGroup;
    import android.widget.ArrayAdapter;
    import android.widget.ImageView;
    import android.widget.TextView;

    public class CustomAdapter extends ArrayAdapter<String>{

      final Context c;
      String[] values;

      //CONSTRUCTOR
      public CustomAdapter(Context context, String[] values) {
        super(context,R.layout.activity_main, values);

        this.c=context;
        this.values=values;

      }

      @Override
      public View getView(int position, View convertView, ViewGroup parent) {

        LayoutInflater inflator=(LayoutInflater) c.getSystemService(Context.LAYOUT_INFLATER_SERVICE);

        //INFLATE OUR XML LAYOUT TO ROW
        View row=inflator.inflate(R.layout.activity_main, parent,false);

        //DECLARE FIELDS CONTAINED IN OUR LAYOUR
        TextView tv=(TextView) row.findViewById(R.id.textView1);
        ImageView img=(ImageView) row.findViewById(R.id.imageView1);

        //GET AN ITEM FROM ARRAY
        String item=values[position];

        //DYNAMICALLY SET TEXT AND IMAGES DEPENDING ON ITEM IN ARRAY
        if(item.equals("android"))
        {
          tv.setText(item+" Programming language");
          img.setImageResource(R.drawable.android);
        }else if(item.equals("java"))
        {
          tv.setText(item+" Programming language");
          img.setImageResource(R.drawable.java);
        }else if(item.equals("c#"))
        {
          tv.setText(item+" Programming language");
          img.setImageResource(R.drawable.csharp);
        }else if(item.equals("mysql"))
        {
          tv.setText(item+" Database language");
          img.setImageResource(R.drawable.mysql);
        }else if(item.equals("access"))
        {
          tv.setText(item+" Database language");
          img.setImageResource(R.drawable.access);
        }else if(item.equals("excel"))
        {
          tv.setText(item+" Microsoft");
          img.setImageResource(R.drawable.excel);
        }

        return row;
      }

    }

Section 2 : MainActivity

Notre activité principale. Elle va sous-classer la classe ListActivity.

package com.tutorials.customlistviewarrayadapter;

import android.app.ListActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.ListView;
import android.widget.Toast;

public class MainActivity extends ListActivity {

  String[] languages={"android","java","c#","mysql","access","excel"};

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
      //  setContentView(R.layout.activity_main);

        CustomAdapter adapter=new CustomAdapter(this, languages);
        setListAdapter(adapter);
    }

    @Override
    protected void onListItemClick(ListView l, View v, int position, long id) {
        // TODO Auto-generated method stub
        super.onListItemClick(l, v, position, id);

        String item=(String) getListAdapter().getItem(position);

        Toast.makeText(getApplicationContext(),"Welcome to "+ item+" Programming language", Toast.LENGTH_SHORT).show();
    }
}

Section 3 : Mise en page

ActivityMain.xml

La mise en page de notre activité principale.

    <RelativeLayout

        android_layout_width="match_parent"
        android_layout_height="match_parent"
        android_paddingBottom="@dimen/activity_vertical_margin"
        android_paddingLeft="@dimen/activity_horizontal_margin"
        android_paddingRight="@dimen/activity_horizontal_margin"
        android_paddingTop="@dimen/activity_vertical_margin"
        tools_context=".MainActivity" >

        <ImageView
            android_id="@+id/imageView1"
            android_layout_width="wrap_content"
            android_layout_height="wrap_content"
            android_layout_alignParentLeft="true"
            android_layout_alignParentTop="true"
            android_layout_marginLeft="16dp"
            android_layout_marginTop="17dp"
            android_src="@drawable/ic_launcher" />

        <TextView
            android_id="@+id/textView1"
            android_layout_width="wrap_content"
            android_layout_height="wrap_content"
            android_layout_alignBottom="@+id/imageView1"
            android_layout_alignParentRight="true"
            android_layout_alignTop="@+id/imageView1"
            android_layout_marginLeft="16dp"
            android_layout_toRightOf="@+id/imageView1"
            android_text="TextView" />

    </RelativeLayout>

Bonne journée.