Jetpack Window Manager pour Xamarin

Le Gestionnaire de fenêtres Jetpack fournit une API standard à utiliser avec tous les appareils pliables. Il contient deux classes importantes :

• DisplayFeature : identifie les perturbations de la surface continue de l’écran plat, comme des charnières ou des plis. Le gestionnaire de fenêtres retourne une collection de fonctionnalités d’affichage à partir d’un rappel de modification de disposition.
• FoldingFeature : fournit des informations sur une fonctionnalité spécifique de l’appareil (Surface Duo n’a qu’une seule fonctionnalité de pliage, mais d’autres appareils peuvent en avoir plus). La FoldingFeature classe fournit des informations sur l’état de cette partie de l’appareil, avec des propriétés pour Bounds et IsSeparatingdes méthodes pour , et pour OcclusionType, Orientationet State.

Les exemples utilisant le Gestionnaire de fenêtres Jetpack sont disponibles dans le dépôt surface-duo-sdk-xamarin-samples.

Pour utiliser WindowInfoTracker votre code, suivez les instructions ci-dessous (à partir de Xamarin.Android Exemple d’application Du Gestionnaire de fenêtres :

Ajouter une dépendance

Pour ajouter le NuGet qui fournit les fonctionnalités du Gestionnaire de fenêtres Jetpack :

1. Cliquez avec le bouton droit sur votre Xamarin. Android projet et choisissez Gérer les packages NuGet...

2. Recherchez Xamarin.AndroidX.Window.WindowJava.

3. Choisissez le numéro de version le plus élevé à ajouter à votre projet (1.0.0.7 est la première version stable de l’API).

Utiliser le Gestionnaire de fenêtres Jetpack dans votre code

1. Dans la classe MainActivity , déclarez une variable pour le suivi des informations de fenêtre :

   public class MainActivity : AppCompatActivity, IConsumer
   {
       WindowInfoTrackerCallbackAdapter wit;
   

   Vérifiez que les instructions et using AndroidX.Window.Java.Layout; les corrects using AndroidX.Window.Layout; sont ajoutés au début du fichier.

   Notes

   L’activité implémente IConsumerégalement l’étape 4 ci-dessous pour le code de la Accept méthode requise par cette interface.

2. Initialisez le Gestionnaire de fenêtres dans l’élément OnCreate de votre activité :

       protected override void OnCreate(Bundle savedInstanceState)
       {
           base.OnCreate(savedInstanceState);
           wit = new WindowInfoTrackerCallbackAdapter(WindowInfoTracker.Companion.GetOrCreate(this));
   

3. Créez maintenant une fonction qui retourne une IExecutor implémentation afin que nous la fournissons au rappel en tant que premier paramètre et qu’elle sera appelée à l’aide de celui-ci. Nous allons en créer une qui s’exécute sur le thread d’interface utilisateur, mais vous pouvez en créer une autre qui ne s’exécute pas sur le thread d’interface utilisateur, si nécessaire.

   IExecutor runOnUiThreadExecutor()
   {
       return new MyExecutor();
   }
   class MyExecutor : Java.Lang.Object, IExecutor
   {
       Handler handler = new Handler(Looper.MainLooper);
       public void Execute(IRunnable r)
       {
           handler.Post(r);
       }
   }
   

4. Définissez une classe interne pour gérer le rappel quand la disposition doit être modifiée. L’activité doit avoir un TextView appelé layoutChange pour que cette méthode puisse mettre à jour le texte affiché :

   public void Accept(Java.Lang.Object newLayoutInfo)  // Object will be WindowLayoutInfo
   {
       var newLayoutInfo = (newLayoutInfo as WindowLayoutInfo); // have to cast before use
   
       layoutChange.Text = newLayoutInfo.ToString();
   
       configurationChanged.Text = "One logic/physical display - unspanned";
   
       foreach (var displayFeature in newLayoutInfo.DisplayFeatures)
       {
           var foldingFeature = displayFeature.JavaCast<IFoldingFeature>();
   
           if (foldingFeature != null)
           {
               alignViewToDeviceFeatureBoundaries(newLayoutInfo);
   
               if (foldingFeature.GetOcclusionType() == FoldingFeatureOcclusionType.None)
               {
                   configurationChanged.Text = "App is spanned across a fold";
               }
               if (foldingFeature.GetOcclusionType() == FoldingFeatureOcclusionType.Full)
               {
                   configurationChanged.Text = "App is spanned across a hinge";
               }
               configurationChanged.Text += "\nIsSeparating: " + foldingFeature.IsSeparating
                       + "\nOrientation: " + foldingFeature.Orientation  // FoldingFeatureOrientation.Vertical or Horizontal
                       + "\nState: " + foldingFeature.State; // FoldingFeatureState.Flat or State.HalfOpened
           }
           else
           {
               Log.Info(TAG, "DisplayFeature is not a fold/hinge");
           }
       }
   }
   

   Notes

   Dans la collection d’éléments DisplayFeature de la classe WindowLayoutInfo, un ou plusieurs de ces éléments peuvent être des instances de FoldingFeature. Les instances de fonctionnalités de pliage ont des propriétés et BoundsIsSeparatingdes méthodes pour OcclusionType, Orientationet State que vous pouvez interroger pour prendre des décisions sur la façon d’ajuster votre disposition pour le nouvel état.

5. Dans un OnStart remplacement, inscrivez le AddWindowLayoutInfoListener gestionnaire et transmettez l’exécuteur et une référence à l’activité (car elle implémente IConsumer).

   protected override void OnStart()
   {
       base.OnStart();
       wit.AddWindowLayoutInfoListener(this, runOnUiThreadExecutor(), this);
       // first `this` is the Activity context, second `this` is the IConsumer implementation
   }
   

6. N’oubliez pas de supprimer l’écouteur :

   protected override void OnStop()
   {
       base.OnStop();
       wit.RemoveWindowLayoutInfoListener(this);
   }
   

7. Quand ce code est exécuté, l’activité est mise à jour avec la position de l’appareil et les fonctionnalités d’affichage actuelles (si l’affichage est réparti de part et d’autre du pli ou de la charnière). Ajoutez du code supplémentaire au rappel pour rechercher d’autres informations dans l’objet FoldingFeature.

Exemple

L’exemple Du Gestionnaire de fenêtres affiche des informations sur l’appareil à l’écran, comme illustré dans cette capture d’écran :

Ressources

• Xamarin.AndroidX.Window NuGet
• Documentation du Gestionnaire de fenêtres Kotlin
• Xamarin. exemple Android Window Manager