API: Allows Developers to Check for Updated Versions of Their Application in the Store

[xDaijobu]

Hello everyone,
I'm proposing a new API addition to enhance CommunityToolkit.MAUI

In Android, I am using these two libraries for crawling HTML:

• Jurassic
• Html Agility Pack

<PackageReference Include="HtmlAgilityPack" Version="1.11.54" />
<PackageReference Include="Jurassic" Version="3.2.7" />

UpdaterVersionInfo.cs

public class UpdaterVersionInfo(
    string appStoreListingUrl,
    Version? appStoreVersion,
    Version installedVersion,
    Version? minAppVersion,
    string? description,
    string? releaseDate,
    string? lastUpdated,
    string? releaseNotes)
{
    public string AppStoreListingURL { get; init; } = appStoreListingUrl;
    public Version? AppStoreVersion { get; init; } = appStoreVersion;
    public Version InstalledVersion { get; init; } = installedVersion;
    public Version? MinAppVersion { get; init; } = minAppVersion;
    public string? Description { get; init; } = description;
    public string? ReleaseDate { get; init; } = releaseDate;
    public string? LastUpdated { get; init; } = lastUpdated;
    public string? ReleaseNotes { get; set; } = releaseNotes;

    public override string ToString()
    {
        return $"AppStoreListingURL: {AppStoreListingURL}, " +
               $"AppStoreVersion: {AppStoreVersion}, " +
               $"InstalledVersion: {InstalledVersion}, " +
               $"MinAppVersion: {MinAppVersion}, " +
               $"Description: {Description}, " +
               $"LastUpdated: {LastUpdated}, " +
               $"ReleaseDate: {ReleaseDate}, " +
               $"ReleaseNotes: {ReleaseNotes}";
    }
}

IUpdater.cs

public interface IUpdater
{
    Task<UpdaterVersionInfo> GetVersionInfo();
}

Updater.android.cs

using AppUpdater.Models;
using HtmlAgilityPack;

partial class UpdaterImplementation : IUpdater
{
    public async Task<UpdaterVersionInfo> GetVersionInfo()
    {
        //string packageName = AppInfo.Current.PackageName;
        string packageName = "com.e_intidata.MSTR_To";
        var url = $"https://play.google.com/store/apps/details?id={packageName}";

        if (!string.IsNullOrEmpty(UpdaterOptions.CountryCode))
            url += $"&hl={UpdaterOptions.LanguageCode}";

        if (!string.IsNullOrEmpty(UpdaterOptions.LanguageCode))
            url += $"&gl={UpdaterOptions.CountryCode}";

        var htmlDoc = await GetHtmlDocument(url);

        string releaseNotes = GetStoreVersion("[1][2][144][1][1]", packageName, htmlDoc);
        string latestVersion = GetStoreVersion("[1][2][140][0][0][0]", packageName, htmlDoc);
        string lastUpdated = GetStoreVersion("[1][2][145][0][0]", packageName, htmlDoc);
        string releasedDate = GetStoreVersion("[1][2][145][0][0]", packageName, htmlDoc);
        string description = GetStoreVersion("[1][2][72][0][1]", packageName, htmlDoc);

        return new UpdaterVersionInfo(url,
                                      new Version(latestVersion),
                                      AppInfo.Current.Version,
                                      UpdaterOptions.MinAppVersion,
                                      description,
                                      releasedDate,
                                      lastUpdated,
                                      releaseNotes);
    }

    private async Task<HtmlDocument> GetHtmlDocument(string url)
    {
        var htmlWeb = new HtmlWeb();
        var htmlDoc = await htmlWeb.LoadFromWebAsync(url);
        return htmlDoc;
    }

    private string GetStoreVersion(string magicNumber, string packageName, HtmlDocument htmlDoc)
    {
        try
        {
            var script = htmlDoc.DocumentNode.Descendants()
                                            .Where(n => n.Name == "script" && n.InnerText.Contains("AF_initDataCallback({key: 'ds:5'"))
                                            .FirstOrDefault()?.InnerText;
            var engine = new Jurassic.ScriptEngine();
            var eval = "(function() { var AF_initDataCallback = function(p) { return p.data" + magicNumber + "; };  return " + script + " })()";
            var result = engine.Evaluate(eval);

            return result is null ? string.Empty : result.ToString();
        }
        catch (Exception ex)
        {
            throw new Exception($"Error parsing content from the Play Store. Error Message: " + ex.ToString(), ex);
        }
    }
}

Updater.macios.cs

using AppUpdater.Models;
using Foundation;
using System.Text.Json.Nodes;

partial class UpdaterImplementation : IUpdater
{
    record Response(int SchemaVersion, string Label, string Message, string Color);
    record AppiOS(string Version, string Url, string ReleaseNotes, string ReleaseDate, string LastUpdated, string Description);

    private string _bundleIdentifier => NSBundle.MainBundle.ObjectForInfoDictionary("CFBundleIdentifier").ToString();
    private string countryCode => "us";

    public async Task<UpdaterVersionInfo> GetVersionInfo()
    {
        string bundleId = _bundleIdentifier ;
        string url = $"https://itunes.apple.com/lookup?id={bundleId}&country={UpdaterOptions.CountryCode ?? countryCode}";
        var app = await LookupApp(bundleId, url);

        return new UpdaterVersionInfo(app.Url,
                                      string.IsNullOrEmpty(app?.Version) ? null : new Version(app.Version),
                                      AppInfo.Current.Version,
                                      UpdaterOptions.MinAppVersion,
                                      app.Description,
                                      app.ReleaseDate,
                                      app.LastUpdated,
                                      app.ReleaseNotes);
    }

    private async Task<AppiOS?> LookupApp(string bundleId, string url)
    {
        try
        {
            using var http = new HttpClient();

            var response = await http.GetAsync(url);
            var content = response.Content == null ? null : await response.Content.ReadAsStringAsync();

            if (string.IsNullOrEmpty(content))
                return null;

            var appLookup = JsonValue.Parse(content);

            return new AppiOS(appLookup["results"][0]["version"].ToString(),
                              appLookup["results"][0]["trackViewUrl"].ToString(),
                              appLookup["results"][0]["releaseNotes"].ToString(),
                              appLookup["results"][0]["releaseDate"].ToString(),
                              appLookup["results"][0]["currentVersionReleaseDate"].ToString(),
                              appLookup["results"][0]["description"].ToString());
        }
        catch (Exception e)
        {
            throw new Exception($"Error looking up app details in App Store. BundleIdentifier={bundleId}.", e);
        }
    }
}

Updater.windows.cs

    public Task<UpdaterVersionInfo> GetVersionInfo()
    {
        throw new NotImplementedException();
        // StoreContext.GetDefault();
        // var storeContext = StoreContext.GetDefault();
    }

Your feedback on this proposal is appreciated.

Best regards,
Cristover

[bijington]

We have a general rule that we don't bring in dependencies so that we can keep the toolkit lightweight and also avoid being stuck depending on libraries that may not be maintained. Can the Android implementation be done without bringing in those dependencies?