- Xamarin
- Xamarin.Android
Quand vous développez une application Xamarin.Android, vous avez souvent besoin de passer des paramètres entre les activités.
Android vous offre différentes façons pour le faire, l’une d’entre elles est d’utiliser les Parcelables.
Les Parcelables vous donne la possibilité de passer un modèle entier entre deux activités d’une application Android.
Pour commencer ce tutoriel, vous trouverez un projet de démarrage sur Github.
Ce projet est un simple projet Xamarin.Android avec une library .Net Standard pour le code commun. Le but de ce tutoriel est de passer un modèle entre deux activités.
Dans notre scénario nous avons une première activité : MainActivity pour être original ;) qui nous affiche le nom et le prénom d’un utilisateur.
Nous avons toutes les données de l’utilisateur dans cette activité et nous voulons les passer dans l’autre activité : DetailActivity.
Le modèle que nous allons passer entre les activités est un User :
public class User
{
public int Id { get; set; }
public string FirstName { get; set; }
public string LastName { get; set; }
public int Age { get; set; }
public string Address { get; set; }
public string City { get; set; }
public string Country { get; set; }
}
Si vous lancez l’application maintenant, vous aurez une page simple, avec le nom et prénom affiché ainsi qu’un bouton. Rien d’extraordinaire pour le moment.
Dans notre projet Xamarin.Android nous avons besoin de créer une classe qui sera un parcelable, cela vous permettra de passer un User d’une activité à une autre.
Créons un nouveau dossier que l’on appellera : Parcelables et dans celui-ci créez le fichier : UserParcelable
Tout d’abord nous devons implémenter Java.Lang.Object et IParcelable :
public class UserParcelable : Java.Lang.Object, IParcelable
{
public UserParcelable()
{
}
public int DescribeContents()
{
throw new NotImplementedException();
}
public void WriteToParcel(Parcel dest, [GeneratedEnum] ParcelableWriteFlags flags)
{
throw new NotImplementedException();
}
}
Le constructeur par défaut est obligatoire pour la classe Parcelable Creator que nous verrons plus loin dans ce tutoriel.
Passer un objet en utilisant un Parcelable consiste à le sérialiser et désérialiser. C’est le même concept que l’utilisation de JSON lorsque vous appelez une API.
Tout d’abord ajoutons un objet User à notre classe.
public User User { get; set; }
Pour passer les données dans le Parcelable nous avons besoins d’utiliser un Parcel, il contient les données et références d’objets que nous voulons envoyer.
La méthode WriteToParcel est la partie de sérialisation :
public void WriteToParcel(Parcel dest, [GeneratedEnum] ParcelableWriteFlags flags)
{
dest.WriteLong(User.Id);
dest.WriteString(User.FirstName);
dest.WriteString(User.LastName);
dest.WriteInt(User.Age);
dest.WriteString(User.Address);
dest.WriteString(User.City);
dest.WriteString(User.Country);
}
Comme nous pouvons le voir ci-dessus, nous devons écrire chacun des paramètres dans l’objet Parcel en fonction de leur type (Long, Int, String…)
La méthode DescribeContents décrit le type d’objets complexes contenus dans ce Parcelable.
Dans notre exemple, parce que nous avons seulement des types simples dans notre modèle User, nous avons juste besoin d’écrire return 0.
public int DescribeContents()
{
return 0;
}
Nous avons maintenant besoin de créer le constructeur du Parcelable et assigner de nouveau tous les paramètres de notre modèle User dans
le même ordre que nous l’avions défini dans la méthode WriteToParcel :
private UserParcelable(Parcel parcel)
{
User = new User
{
Id = parcel.ReadLong(),
FirstName = parcel.ReadString(),
LastName = parcel.ReadString(),
Age = parcel.ReadInt(),
Address = parcel.ReadString(),
City = parcel.ReadString(),
Country = parcel.ReadString()
};
}
Maintenant nous avons besoin de créer une autre classe qui créera les instances de notre classe UserParcelable.
Voici une classe générique que vous pouvez ajouter à votre dossier Parcelables. Ainsi, vous pourrez l’utiliser pour chaque nouveau Parcelable que vous allez créer.
public class GenericParcelableCreator<T> : Java.Lang.Object, IParcelableCreator where T : Java.Lang.Object, new()
{
/// <summary>
/// Function for the creation of a parcel.
/// </summary>
private readonly Func<Parcel, T> _createFunc;
/// <summary>
/// Initialize an instance of the GenericParcelableCreator.
/// </summary>
public GenericParcelableCreator(Func<Parcel, T> createFromParcelFunc)
{
_createFunc = createFromParcelFunc;
}
/// <summary>
/// Create a parcelable from a parcel.
/// </summary>
public Java.Lang.Object CreateFromParcel(Parcel parcel)
{
return _createFunc(parcel);
}
/// <summary>
/// Create an array from the parcelable class.
/// </summary>
public Java.Lang.Object[] NewArray(int size)
{
return new T[size];
}
}
Nous pouvons donc utiliser cette classe dans notre classe UserParcelable:
private static readonly GenericParcelableCreator<UserParcelable> _creator
= new GenericParcelableCreator<UserParcelable>((parcel) => new UserParcelable(parcel));
[ExportField("CREATOR")]
public static GenericParcelableCreator<UserParcelable> GetCreator()
{
return _creator;
}
Cela va créer une instance de l’objet Parcelable pour nous.
Maintenant que nous sommes prêts à transmettre des données entre nos deux pages, revenons à la MainActivity et dans le méthode SeeMoreBtn_Click que j’ai déjà préparé
pour vous, nous devons créer un objet Parcelable et l’envoyer au DetailActivity en utilisant le PutExtra:
Intent intent = new Intent(this, typeof(DetailActivity));
UserParcelable parcelable = new UserParcelable();
parcelable.User = _user;
intent.PutExtra(DetailActivity.UserParcelableExtra, parcelable);
StartActivity(intent);
Dans la DetailActivity nous recevons notre objet User, pour cela, ajoutez ces lignes dans la méthode OnCreate:
UserParcelable parcelable = (UserParcelable)Intent.GetParcelableExtra(UserParcelableExtra);
UpdateView(parcelable.User);
Si vous compilez votre projet vous obtiendrez cette erreur :
Error XA4210: You need to add a reference to Mono.Android.Export.dll when you use ExportAttribute or ExportFieldAttribute. (XA4210)
Comme l’erreur l’indique, nous devons éditer les références de notre projet Xamarin.Android et ajouter le Mono.Android.Export.dll pour que cela fonctionne.
Maintenant recompilez votre projet, et vous verrez les données de l’utilisateur dans la DetailActivity.
Félicitations ! Maintenant vous savez comment utiliser les Parcelables dans vos projets Xamarin.Android !
Vous trouverez tout le code source dans la branche final du répertoire Github.
Happy codding !
Vous avez aimé ce tutoriel ? Laissez une étoile sur le répertoire Github associé !