Exploration des packs d’actifs Android dans .net Maui

.NET pour Android 9 vous permet d’éviter les restrictions de taille de fichier de 200 Mo pour votre application sur Google Play en utilisant des packs d’actifs séparés avec un stockage de 2 Go.

Lors de la publication d’une application sur Google Play, toutes les ressources de votre projet, telles que les graphismes, les vidéos et l’audio, sont emballés dans le Android App Bundle (AAB)le fichier requis pour terminer la publication de l’application.

Ces ressources sont incluses dans le package AAB principal sans problèmes, tant qu’ils ne dépassent pas 200 Mb. Si un fichier dépasse cette limite, il ne peut pas être inclus dans le package principal en raison des restrictions de taille imposées par Google Play.

La bonne nouvelle est que, à commencer par .NET pour Android 9il est désormais possible d’inclure des ressources dans des packages séparés, appelés packs d’actifs. Cela vous permet de télécharger supplémentaire packs d’actifs jusqu’à jusqu’à 2 Goau lieu d’être limité à la limite de 200 Mo pour le package principal.

Quels points clés devez-vous garder à l’esprit de la limite de 2 Go?

• La taille combinée de tous vos packs d’actifs ne peut pas dépasser 2 Go.
• Vous pouvez créer jusqu’à 50 packs d’actifs individuels.

Cela facilite la publication de l’application et offre plus de flexibilité, vous ne surchargez donc pas le package principal tout en vous contenant des restrictions de Google Play.

Fondamentalement, un pack d’actifs est une collection de fichiers contenant les ressources de votre application.

⚠️ Il est crucial de noter que dans .NET pour Android, vous devez toujours définir le Construire une action propriété de chaque ressource à « AndroidAsset«En revanche, lorsque vous travaillez avec .net Maui, vous devriez le définir sur«Maussade.  » Cela définit les ressources pour être correctement reconnus comme des actifs et inclus correctement dans les packs d’actifs.

Comment créer un pack d’actifs

Pour activer l’utilisation de packages d’actifs dans .NET pour les applications Android, le groupe d’articles AndroidAsset comprend désormais deux nouveaux attributs de métadonnées:

➖ Actif: Cet attribut nous permet de spécifier le package d’actif dans lequel l’actif doit être inclus. La valeur par défaut est le package principal, donc si aucune autre valeur n’est spécifiée, la ressource y sera incluse.

Le nom du package d’actifs doit être construit comme suit: $(AndroidPackage).%(AssetPack).

Par exemple, si le nom de votre package est com.mycompany.myproject Et le nom AssetPack est myassetsle nom du package d’actifs résultant sera com.mycompany.myproject.myassets.

➖ Tépard de livraison: Détermine lorsque vos actifs sont installés sur l’appareil. Cette propriété prend en charge les valeurs suivantes:

• INSTALLIME: Les packs seront installés à côté de l’application. Ce type de pack peut avoir une taille jusqu’à 1 Go, mais un seul pack de ce type est autorisé. (Valeur par défaut.)
• Suivre rapidement: Ces packs sont installés peu de temps après la fin de l’application. Gardez à l’esprit que l’application doit être entièrement installée avant que les actifs puissent être utilisés. Ce type de package peut avoir une taille jusqu’à 512 Mo.
• Sur demande: Comme son nom l’indique, ce type gère les téléchargements au besoin, ce qui signifie que les actifs ne seront téléchargés que sur l’appareil lorsque l’application les demande explicitement.

Mettons cela en contexte. Imaginez que vous avez un fichier nommé Démo.mp4 C’est plus de 200 Mb. Comment pouvez-vous le déplacer vers son propre package de ressources? Voici un exemple de la façon de le faire dans le code:

<ItemGroup> 
    <AndroidAsset Update="Assets/Demo.mp4"  AssetPack="myassets" /> 
</ItemGroup>

Passons en revue les détails:

À l’intérieur <ItemGroup> </ItemGroup> Tags, ajouter le AndroidAsset et spécifiez le nom du AssetPack. ItemGroup indique au système de construction Android .NET ce qui suit:

• Créer un nouveau pack d’actifs, dans cet exemple nommé Myassets.
• Inclure le Démo.mp4 fichier à l’intérieur « Myassets”Asset Pack.
• Ce pack d’actifs sera automatiquement inclus dans le Aab (Android App Bundle) Lorsque vous publiez l’application.

Mise à jour: Le Mise à jour l’attribut est utilisé à la place de Inclure. Si une ressource est déjà présente dans le projet et que vous souhaitez uniquement mettre à jour sa configuration (par exemple, affectez-la à un pack d’actifs), utilisez Mise à jour. Si vous ajoutez une nouvelle ressource, utilisez Inclure.

Puis-je choisir quels actifs sont inclus dans le bundle principal de l’application? 🤔

Oui! 🌟 Vous pouvez facilement spécifier quelles ressources restent dans le bundle principal de l’application et qui sont déplacés vers un pack d’actifs. Ceci est particulièrement utile lorsque vous avez un grand nombre de ressources, mais que quelques-uns sont essentiels pour être disponibles immédiatement lors de l’installation de l’application.

Ressources incluses dans le bundle principal de l’application sont livrés lors de l’installation initiale. En revanche, les fichiers packs d’actifs sont téléchargés en fonction de la configuration Tépard de livraison (Par exemple, FastFollow, ondemand, etc.).

Comment faire

Voici un exemple pratique:

<ItemGroup> 
    <AndroidAsset Update="Assets/*" AssetPack="myassets" /> 
    <AndroidAsset Update="Assets/myfile.json" AssetPack="base" /> 
</ItemGroup>

Explication du code:

1. <AndroidAsset Update="Assets/*" AssetPack="myassets" />
   Cela précise que Toutes les ressources dans le dossier Assets sera placé dans un pack d’actifs nommé «MyAssets».

2. <AndroidAsset Update="Assets/myfile.json" AssetPack="base" />
   Cela indique que le fichier myfile.json sera exclu du Myassets emballer et placé dans le bundle principal de l’application. Cela se produit parce que la valeur «Base» fait référence au package principal.

Cette approche vous donne un contrôle précis sur les ressources immédiatement disponibles lors de l’installation et lesquelles sont livrées en fonction des besoins des utilisateurs.

Quelque chose que vous devez savoir sur FastFollow ✍️

Si votre application utilise un Suivre rapidement Asset Pack, vous devez vérifier son statut et que le pack est entièrement installé avant d’essayer d’accéder à son contenu.

Vous pouvez y parvenir facilement:

➖ Ajouter le Xamarin.google.android.play.asset.delivery Package à votre projet via Nuget Package Manager.

Ce package donne accès au AssetpackManager Tapez, vous permettant d’interroger l’emplacement des packs d’actifs dans votre application.

Regardons un exemple de code:

using Xamarin.Google.Android.Play.Core.AssetPacks; 
var assetPackManager = AssetPackManagerFactory.GetInstance(this);

AssetPackLocation assetPackPath = assetPackManager.GetPackLocation("myfastfollowpack"); 
string assetsFolderPath = assetPackPath?.AssetsPath() ?? null; 
if (assetsFolderPath is null) 
{ 
    // FastFollow asset pack isn't installed. 
}

Voici un examen de ce que fait le code:

• Le GetPacklocation La méthode est utilisée pour interroger l’emplacement du pack d’actifs FastFollow.
• Cette méthode renvoie un Atfetpacklocation objet.
• Si la méthode des passures de la mise en place du Atfetpacklocation Renvoie l’objet nulcela signifie que le package n’a pas encore été installé.
• Cependant, s’il renvoie une valeur, il indique l’emplacement d’installation du package.

Téléchargement des packs d’actifs ondemand

Si votre application utilise un pack d’actifs Ondemand, vous devez le télécharger manuellement. Pour ce faire, ajoutez simplement la même chose Xamarin.google.android.play.asset.delivery Package NuGet mentionné dans l’explication précédente.

Déclarer les variables nécessaires:

using Xamarin.Google.Android.Play.Core.AssetPacks; 

IAssetPackManager assetPackManager; 
AssetPackStateUpdateListenerWrapper listener;

Créez le gestionnaire d’événements pour surveiller les progrès du téléchargement:

void Listener_StateUpdate(object? sender, AssetPackStateUpdateListenerWrapper.AssetPackStateEventArgs e) 
{ 
    var status = e.State.Status(); 
    switch (status) 
    { 
	    case AssetPackStatus.Downloading: 
		    long downloaded = e.State.BytesDownloaded(); 
		    long totalSize = e.State.TotalBytesToDownload(); 
		    double percent = 100.0 * downloaded / totalSize; 
		    Android.Util.Log.Info("Download Progress", $"Downloading {percent}%"); 
		    break; 
	    case AssetPackStatus.Completed: 
		    Android.Util.Log.Info("Download Complete", "Asset pack download finished."); 
		    break; 
	    case AssetPackStatus.WaitingForWifi: 
		    assetPackManager.ShowConfirmationDialog(this); 
		    break; 
    } 
}

Enregistrez l’auditeur lors du démarrage et désinscrivez-le lors de la pause de l’application:

protected override void OnResume() 
{ 
    assetPackManager.RegisterListener(listener.Listener); 
    base.OnResume(); 
}
 
protected override void OnPause() 
{ 
    assetPackManager.UnregisterListener(listener.Listener); 
    base.OnPause(); 
}

Avant d’essayer de télécharger le pack d’actifs, vérifiez son emplacement avec GetPackLocation pour déterminer s’il est déjà installé.

var assetPackPath = assetPackManager.GetPackLocation("myondemandpack");

string assetsFolderPath = assetPackPath?.AssetsPath() ?? null;

if (assetsFolderPath is null) 
{ 
    // If it is not installed, start the download 
    await assetPackManager.Fetch(new string[] { "myondemandpack" }).AsAsync<AssetPackStates>(); 
}

Comment tester les packs d’actifs localement

Tester les packs d’actifs localement est simple; Suivez simplement ces étapes et gardez ces points à l’esprit:

1️. Utilisez le format Android App Bundle (AAB). Ceci est important car, par défaut, .NET pour Android utilise le format Android Package (APK) pour le débogage.

2️. Ouvrez votre .cs fichier et ajouter les propriétés de débogage suivantes.

<PropertyGroup Condition="'$(Configuration)' == 'Debug'"> 
    <AndroidPackageFormat>aab</AndroidPackageFormat> 
    <EmbedAssembliesIntoApk>true</EmbedAssembliesIntoApk> 
    <AndroidBundleToolExtraArgs>--local-testing</AndroidBundleToolExtraArgs> 
</PropertyGroup>

Ce code:

• Permet les tests directement sur l’appareil avec –local-testing.
• Informe le Bundletool que tous les packs d’actifs doivent être installés dans un emplacement mis en cache sur l’appareil.
• Configurer IAssetPackManager Pour utiliser un téléchargeur simulé, qui utilise le cache. (Cela vous permet de tester l’installation de packs d’actifs ONDemand et FastFollow dans un environnement de débogage.)

Références

Cet article était basé sur la documentation officielle et comprend des exemples de code de la page principale pour expliquer chaque étape d’implémentation en détail.