Jetpack Window Manager pour Xamarin bêta

Important

Les fonctionnalités et l’aide décrites dans cet article sont en préversion publique et peuvent faire l’objet de modifications importantes avant leur lancement en disponibilité générale. Microsoft ne donne aucune garantie, expresse ou implicite, concernant les informations fournies ici.

Conseil

les utilisateurs Xamarin. forms doivent faire référence à Xamarin. forms. DualScreen NuGet pour la prise en charge de Surface Duo, avec ses TwoPaneView classes et.

Le gestionnaire de fenêtres est destiné aux développeurs qui travaillent avec des projets Xamarin. Android.

Le Gestionnaire de fenêtres Jetpack (actuellement en bêta) 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 les propriétés Bounds et IsSeparating , ainsi que les méthodes pour OcclusionType , Orientation et State .

Des exemples utilisant la version bêta du gestionnaire de fenêtrage sont disponibles dans le référentiel surface-Duo-SDK-xamarin-Samples.

Notes

le NuGet Xamarin. AndroidX. Window. WindowJava est destiné à remplacer la nécessité d’ajouter Xamarin. DuoSDK NuGet à des applications Xamarin. Android.

Au lieu d’utiliser la classe pour déterminer IsDualMode ou à GetHingeBoundsDip() , vous pouvez utiliser directement les méthodes et les propriétés WindowInfoRepository .

Pour utiliser WindowInfoRepository dans votre code, suivez les instructions ci-dessous (à partir de l' WindowInfoRepository) :

Ajouter une dépendance

Pour ajouter le gestionnaire de fenêtres NuGet :

  1. cliquez avec le bouton droit sur votre projet Xamarin. Android, puis sélectionnez gérer les Packages de NuGet...

  2. Vérifiez que l’option inclure la version préliminaire est cochée et recherchez Xamarin. AndroidX. Window. WindowJava.

  3. Choisissez le numéro de version le plus élevé à ajouter à votre projet (actuellement , 1.0.0.1-BETA01).

Notes

Le nom de la bibliothèque comprend « bêta » : les API du Gestionnaire de fenêtres sont actuellement toujours en préversion.

Utiliser le Gestionnaire de fenêtres dans votre code

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

    public class MainActivity : AppCompatActivity, IConsumer
    {
        WindowInfoRepositoryCallbackAdapter wir;
    

    Assurez-vous que les using AndroidX.Window.Layout;using AndroidX.Window.Java.Layout; instructions et sont ajoutées au début du fichier.

    Notes

    L’activité implémente également IConsumer , consultez l’étape 4 ci-dessous pour obtenir 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);
            wir = new WindowInfoRepositoryCallbackAdapter(WindowInfoRepository.Companion.GetOrCreate(this));
    
  3. Maintenant, créez une fonction qui retourne une IExecutor implémentation, nous la fournissons au rappel comme premier paramètre et elle sera appelée à l’aide de celle-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 pliantes ont des propriétés Bounds et IsSeparating , ainsi que des méthodes pour OcclusionType , et OrientationState que vous pouvez interroger pour prendre des décisions sur la façon d’ajuster la disposition du nouvel État.

  5. Dans une OnStart substitution, inscrivez le AddWindowLayoutInfoListener Gestionnaire et passez l’exécuteur et une référence à l’activité (car elle implémente IConsumer ).

    protected override void OnStart()
    {
        base.OnStart();
        wir.AddWindowLayoutInfoListener(runOnUiThreadExecutor(), this); // `this` is the IConsumer implementation
    }
    
  6. N’oubliez pas de supprimer l’écouteur :

    protected override void OnStop()
    {
        base.OnStop();
        wir.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 de gestionnaire de fenêtres affiche des informations sur l’appareil à l’écran, comme illustré dans cette capture d’écran :

Surface duo qui affiche l’exemple de gestionnaire de fenêtres en cours d’exécution et affiche des informations sur l’appareil à l’écran

Ressources