02. Maintenant Navigons... UPDATE : SUPPORT DE WINDOWS 10

Pour rappel, voici la liste des articles qui constituent cette série d'articles :

1. Navigation avant

Préambule : afin de simplifier l'appel à la classe de navigation, une propriété NavigationService est définie dans la classe ViewModelServices. Tous les appels dans les exemples utiliseront donc cette propriétés, car tous les ViewModel héritent de cette classe

Nous allons ici détailler les différentes versions de la fonction NavigateTo qui sont utilisées dans l'application exemple.

1.1 Navigation simple
Tout d'abord une version simple qui permet de gérer l'historique de navigation et passer des paramètres. Dans le ViewModel ListClientsViewModel, on va trouver une fonction OpenClient qui va naviguer vers la page du client concerné

/// <summary>
/// Permet de naviguer la page de gestion du client
/// </summary>
private void OpenClient(Client client)
{
    //Navigation vers la page ClientPage
    NavigationService.NavigateTo<clientpageviewmodel>(this, new object[] {client}, true);
}

Détaillons ensemble les différents paramètres de la fonction NavigateTo :

  • this sert à indiquer que le ViewModel actuel (et donc par extension la page) sera ajouté à l'historique de navigation, afin que Navegar puisse savoir qu'il doit revenir vers cette page au Back
  • new object[]{client} permet de passer l'objet client au constructeur du ViewModel ClientPageViewModel
  • true indique que l'on souhaite une nouvelle instance du ViewModel ClientPageViewModel


1.2 Navigation avec fonction
Dans le ViewModel de la page du client on trouve la fonction LoadCommandes qui va permettre de charger la liste des commandes associées au client acutel. Nous allons là encore utiliser la fonction NavigateTo pour naviguer vers la page ListCommandesPage, mais cette fois si, en plus d'un paramétre passé aux constructeur ListCommandesPageViewModel, en associant une fonction du ViewModel qui sera appelé aprés le chargement de l'instance.

/// <summary>
/// Permet de naviguer dans la liste des commandes du client
/// </summary>
private void LoadCommandes()
{
    //Navigation vers la page ListCommandesPage
    NavigationService.NavigateTo<listcommandespageviewmodel>(this, new object[] { ClientCurrent  }, "LoadDatas", new object[] {}, true);
}

Encore une fois détaillons les différents paramètres de la fonction NavigateTo :

  • this sert à indiquer que le ViewModel actuel (et donc par extension la page) sera ajouté à l'historique de navigation, afin que Navegar puisse savoir qu'il doit revenir vers cette page au Back
  • new object[]{ ClientCurrent } indique le paramétre de type client à passer au constucteur
  • "LoadDatas" est une fonction (public ou private) du ViewModel voulu et qui sera donc appelée aprés initialisation de celui-çi
  • new object[]{} représente un tableau de paramétres que l'on peut passer à la fonction, comme pour les constructeurs, ici aucun paramètres
  • true indique que l'on souhaite une nouvelle instance du ViewModel ListCommandesPageViewModel

2. Navigation arriére
Bien entendu Navegar propose en plus des fonctions de navigation avant, la possibilité de pouvoir effectuer une navigation arriére dans nos ViewModel.
Nous allons ici détailler la fonction Cancel qui se trouve dans la classe ViewModelServices (cette fonction est utilisée pour la version Windows App).

/// <summary>
/// Permet de revenir en arriére
/// </summary>
private void Cancel()
{
    if (NavigationService.CanGoBack())
    {
        //Lorsque l'on revient d'une commande on rafraichi la liste des commandes sur la page de liste
        if (NavigationService.GetTypeViewModelToBack() == typeof (ListCommandesPageViewModel))
        {
            //Permet de relancer la fonction LoadDatas aprés la navigation arriére vers la liste des commandes
            NavigationService.GoBack("LoadDatas", new object[] {});
        }
        else
        {
            NavigationService.GoBack();
        }
    }
}

Ici nous pouvons remarquer plusieurs fonctions :

  • CanGoBack() permet de vérifier que l'historique autorise une navigation arriére depuis le ViewModel courant
  • GetTypeViewModelToBack permet de connaitre le type de de ViewModel vers lequel la navigation va revenir, ceci afin de pouvoir appliquer un traitement particulier suivant ce type
  • GoBack() permet de revenir sur le ViewModel précédent, défini dans la pile de navigation
  • GoBack("LoadDatas", new object[]{}) permet de revenir sur le ViewModel précédent, défini dans la pile de navigation. La différence de cette surcharge est qu'elle permet de lancer une fonction du ViewModel précédent aprés le retour arriére, en lui passant éventuellement des paramètres
3. Navigation arriére spécifique pour la version Windows Phone (en 8.1) ou la présence d'un bouton physique ou virtuel intégré au matériel
La fonction vue précédemment pour le retour arriére doit être écrite et associée à une ICommand pour la version Windowss App, car il n'y a pas de bouton de retour sur le matériel embarquant cette version du systéme Windows 8.1.
Concernant les Windows Phone, un bouton physique ou virtuel est présent et permet d'appeler le retour arriére. Navegar défini déja une fonction permettant de gérer la navigation arriére entre les ViewModel, mais si vous avez besoin d'un traitement spécifique comme pour la fonction précédente, vous pouvez redéfinir cette fonction pour la classe de navigation.
Pour cela rendons nous dans la classe App.xaml.cs et ajoutons cela aprés la définition de la navigation dans la fonction OnLaunched

Pour la version Windows 8.1

#if WINDOWS_PHONE_APP
        SimpleIoc.Default.GetInstance<INavigation>().BackButtonPressed += BackButtonPressed;
#endif


Pour la version de Windows 10 mobile, il n'est pas nécessaire de faire de test, Navegra embarque le test de présence du bouton, il suffit donc d'écrire :

SimpleIoc.Default.GetInstance<INavigation>().BackButtonPressed += BackButtonPressed;

Dans l'exemple fourni vous pouvez trouver une implémentation de la fonction BackButtonPressed qui est similaire à la fonction pour la version WINDOWS_APP. Voici la redéfinition pour la version WINDOWS_PHONE_APP.

/// <summary>
/// Permet de surcharger le retour arriére, du bouton physique ou virtuel du téléphone. 
/// Fonction implémentée dans Navegar, cette surcharge n'est pas indispensable, elle vous permet simplement plus de liberté par rapport au métier de votre application
/// </summary>
/// <param name="sender"/>
/// <param name="backPressedEventArgs"/>
private void BackButtonPressed(object sender, BackPressedEventArgs backPressedEventArgs)
{
    if (SimpleIoc.Default.GetInstance<INavigation>().CanGoBack())
    {
        //A ajouter absolument à  partir du moment où l'on sait que l'on peut revenir en arriére
        //Sinon l'application se ferme
        backPressedEventArgs.Handled = true;
        //Lorsque l'on revient d'une commande on rafraichi la liste des commandes sur la page de liste
        if (SimpleIoc.Default.GetInstance<INavigation>().GetTypeViewModelToBack() == typeof (ListCommandesPageViewModel))
        {
            //Permet de relancer la fonction LoadDatas aprés la navigation arriére vers la liste des commandes
            SimpleIoc.Default.GetInstance<INavigation>().GoBack("LoadDatas", new object[] {});
        }
        else
        {
            SimpleIoc.Default.GetInstance<INavigation>().GoBack();
        }
    }
}

On peut voir ici une différence fondamentale avec la version WINDOWS_APP, en effet il faut ajouter à la fonction, la ligne :

backPressedEventArgs.Handled = true;

Ceci permet de capturer le fait que le bouton de retour a été actionné, si cette ligne n'est pas ajoutée aprés une vérification d'historique de navigation arriére l'application se fermera.

Votre application navigue maintenant entre tous ses écrans. Dans le dernier article de cette série nous allons voir quelques fonctions avancées.

// coding with fun

Écrire un commentaire

Votre adresse de messagerie ne sera pas publiée. Les champs obligatoires sont indiqués avec une *

Quelle est la troisième lettre du mot qqij ? :