Dans l’article précédent, nous avons vu comment utiliser des services dans notre application Xamarin et plus particulièrement dans notre Portable Class Library, ce qui implique que le code présent dans notre service doit impérativement être portable, mais que se passe-t-il lorsque l’on doit utiliser du code spécifique à la plateforme ?

Il suffit dans ce cas d’implémenter chacune de nos interfaces dans chacun des projets spécifiques.

Dans notre cas nous allons déclencher l’ouverture d’une boite de dialogue lors de la sélection d’une série, pour cela nous allons créer une interface IDialogService composée de la méthode ShowMessage permettant l’ouverture de la Popup.

MyWatchlist.Core/Interfaces/IDialogService.cs

namespace MyWatchlist.Core.Interfaces
{
    public interface IDialogService
    {
        void ShowMessage(string message);
    }
}

Nous allons ensuite implémenter notre interface sur la plateforme cible, Android dans notre cas.

MyWatchlist.Droid/Services/DialogService.cs

using Android.App;
using Android.Widget;
using MyWatchlist.Core.Interfaces;

namespace MyWatchlist.Droid.Services
{
    public class DialogService : IDialogService
    {
        void IDialogService.ShowMessage(string message)
        {
            Toast.MakeText(Application.Context, message, ToastLength.Short).Show(); // permet l'ouverture d'un toast
        }
    }
}

Une fois le service crée, il faut l’intégrer à notre ViewModel afin de pouvoir l’utiliser lors de la sélection d’une série dans la commande SerieEntitySelectedCommand.

MyWatchlist.Droid/ViewModels/FirstViewModel.cs

using Cirrious.MvvmCross.ViewModels;
using MyWatchlist.Core.Common;
using MyWatchlist.Core.Entities;
using MyWatchlist.Core.Interfaces;
using System.Collections.ObjectModel;
using System.Threading.Tasks;
using System.Windows.Input;

namespace MyWatchlist.Core.ViewModels
{
    public partial class FirstViewModel : MvxViewModel
    {
        #region ATTRIBUTES

        #region ATTRIBUTES MVVM

        private string _login;

        private ObservableCollection<SerieEntity> _series = new ObservableCollection<SerieEntity>();

        public string Login
        {
            get { return _login; }
            set { _login = value; RaisePropertyChanged(() => Login); }
        }

        public ObservableCollection<SerieEntity> Series
        {
            get { return _series; }
            set { _series = value; }
        }

        #endregion ATTRIBUTES MVVM

        #region ATTRIBUTES SERVICES

        private readonly IDialogService _dialogService;

        private readonly IUserService _userService;

        #endregion ATTRIBUTES SERVICES

        #endregion ATTRIBUTES

        #region CONSTRUCT

        public FirstViewModel(IDialogService dialogService, IUserService userService)
        {
            _dialogService = dialogService;
            _userService = userService;
        }

        #endregion CONSTRUCT

        #region METHODS

        // mise à jour des informations du ViewModel
        public async Task UpdateAsync()
        {
            await _userService.LoginAsync(Globals.Login, Globals.Password);
            var user = await _userService.GetInfosAsync();
            Login = user.Login;

            Series.Clear();
            foreach (var serie in (await _userService.GetSeriesAsync()))
            {
                Series.Add(serie);
            }
        }

        #endregion METHODS

        #region COMMANDS

        public ICommand SerieEntitySelectedCommand { get { return new MvxCommand<SerieEntity>(OnSerieEntitySelectedCommand); } }

        private void OnSerieEntitySelectedCommand(SerieEntity entity)
        {
            _userService.OnSerieEntitySelectedCommand(entity);
            _dialogService.ShowMessage(entity.Title);
        }

        #endregion COMMANDS
    }
}

Il ne nous reste plus qu’à effectuer l’injection de dépendances, dans le projet Android cette fois-ci puisque l’implémentation de notre service ne se trouve pas dans notre PCL.

MyWatchlist.Droid/Setup.cs

using Android.Content;
using Cirrious.CrossCore.IoC;
using Cirrious.CrossCore.Platform;
using Cirrious.MvvmCross.Droid.Platform;
using Cirrious.MvvmCross.ViewModels;

namespace MyWatchlist.Droid
{
    public class Setup : MvxAndroidSetup
    {
        public Setup(Context applicationContext) : base(applicationContext)
        {
        }

        protected override IMvxApplication CreateApp()
        {
            CreatableTypes()
                .EndingWith("Service")
                .AsInterfaces()
                .RegisterAsLazySingleton(); // l'injection de dépendances se fait ici
            return new Core.App();
        }
        
        protected override IMvxTrace CreateDebugTrace()
        {
            return new DebugTrace();
        }
    }
}

Et voilà le résultat :

Nous sommes maintenant capable d’utiliser nos différents services depuis les ViewModels de notre PCL et le tout avec une implémentation spécifique à la plateforme.

Enjoy :)