Windows Platform Integration

using System.Runtime.InteropServices;

namespace Bookshelf.Desktop.Platform;

/// <summary>Answers "does this process have package identity?" without touching WinRT.</summary>
public static partial class PackageIdentity
{
    private const int AppModelErrorNoPackage = 15700; // APPMODEL_ERROR_NO_PACKAGE

    [LibraryImport("kernel32.dll")]
    private static partial int GetCurrentPackageFullName(ref uint length, Span<char> name);

    public static bool HasIdentity { get; } = Probe();

    private static bool Probe()
    {
        uint length = 0;
        int result = GetCurrentPackageFullName(ref length, Span<char>.Empty);
        return result != AppModelErrorNoPackage;
    }
}

<?xml version="1.0" encoding="utf-8"?>
<Package IgnorableNamespaces="uap uap10"
  xmlns="http://schemas.microsoft.com/appx/manifest/foundation/windows10"
  xmlns:uap="http://schemas.microsoft.com/appx/manifest/uap/windows10"
  xmlns:uap10="http://schemas.microsoft.com/appx/manifest/uap/windows10/10"
  xmlns:rescap="http://schemas.microsoft.com/appx/manifest/foundation/windows10/restrictedcapabilities">
  <Identity Name="BookshelfDesktop" Publisher="CN=Bookshelf Dev" Version="1.0.0.0"
            ProcessorArchitecture="neutral" />
  <Properties>
    <DisplayName>Bookshelf Desktop</DisplayName>
    <PublisherDisplayName>Bookshelf</PublisherDisplayName>
    <Logo>Assets\storelogo.png</Logo>
    <uap10:AllowExternalContent>true</uap10:AllowExternalContent>
  </Properties>
  <Resources>
    <Resource Language="en-us" />
  </Resources>
  <Dependencies>
    <TargetDeviceFamily Name="Windows.Desktop" MinVersion="10.0.19041.0" MaxVersionTested="10.0.26100.0" />
  </Dependencies>
  <Capabilities>
    <rescap:Capability Name="runFullTrust" />
    <rescap:Capability Name="unvirtualizedResources" />
  </Capabilities>
  <Applications>
    <Application Id="BookshelfDesktop" Executable="Bookshelf.Desktop.exe"
                 uap10:TrustLevel="mediumIL" uap10:RuntimeBehavior="win32App">
      <uap:VisualElements AppListEntry="none" DisplayName="Bookshelf Desktop"
                          Description="Bookshelf Desktop" BackgroundColor="transparent"
                          Square150x150Logo="Assets\Square150x150Logo.png"
                          Square44x44Logo="Assets\Square44x44Logo.png" />
    </Application>
  </Applications>
</Package>

<?xml version="1.0" encoding="utf-8"?>
<assembly manifestVersion="1.0" xmlns="urn:schemas-microsoft-com:asm.v1">
  <assemblyIdentity version="0.0.0.0" name="BookshelfDesktop"/>
  <msix xmlns="urn:schemas-microsoft-com:msix.v1"
        publisher="CN=Bookshelf Dev"
        packageName="BookshelfDesktop"
        applicationId="BookshelfDesktop" />
</assembly>

# Pack the identity package. /nv skips validation of the file paths named in the manifest.
MakeAppx.exe pack /o /d .\identity /nv /p .\artifacts\BookshelfIdentity.msix

# Sign it. The certificate file and its password come from CI secrets or the developer's environment.
SignTool.exe sign /fd SHA256 /a /f $env:BOOKSHELF_PFX_PATH /p $env:BOOKSHELF_PFX_PASSWORD .\artifacts\BookshelfIdentity.msix

# Register it for the current user, pointing at the folder that holds Bookshelf.Desktop.exe.
Add-AppxPackage -Path .\artifacts\BookshelfIdentity.msix -ExternalLocation "C:\Program Files\Bookshelf"

# Unregister on uninstall.
Get-AppxPackage BookshelfDesktop | Remove-AppxPackage

using Windows.Management.Deployment;

namespace Bookshelf.Installer;

public static class IdentityRegistration
{
    public static async Task RegisterAsync(string packagePath, string installFolder)
    {
        var options = new AddPackageOptions
        {
            // new Uri(absolutePath) produces the file:/// URI the API requires.
            ExternalLocationUri = new Uri(installFolder),
        };

        var manager = new PackageManager();
        var result = await manager.AddPackageByUriAsync(new Uri(packagePath), options);
        if (result.ExtendedErrorCode is not null)
        {
            throw new InvalidOperationException(
                $"Identity package registration failed: {result.ErrorText}");
        }
    }
}

using Microsoft.Windows.Storage;

namespace Bookshelf.Desktop.Services;

/// <summary>User preferences for Bookshelf Desktop, stored through the Windows App SDK data API.</summary>
public sealed class WindowsAppDataSettings
{
    // Publisher and product name identify this app's data store; ApplicationData is IDisposable.
    private readonly ApplicationData _data = ApplicationData.GetForUnpackaged("Irurueta", "Bookshelf");

    public string? LastSearch
    {
        get => _data.LocalSettings.Values["LastSearch"] as string;
        set => _data.LocalSettings.Values["LastSearch"] = value;
    }
}

<!-- App.xaml: StartupUri is replaced by a Startup handler so notifications register first -->
<Application x:Class="Bookshelf.Desktop.App"
             xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
             xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
             Startup="OnStartup" />

using System.Windows;
using Microsoft.Windows.AppNotifications;
using Microsoft.Windows.AppNotifications.Builder;

namespace Bookshelf.Desktop;

public partial class App : Application
{
    private void OnStartup(object sender, StartupEventArgs e)
    {
        // The handler must be attached before Register is called.
        AppNotificationManager.Default.NotificationInvoked += OnNotificationInvoked;
        AppNotificationManager.Default.Register();

        new MainWindow().Show();
    }

    private void OnNotificationInvoked(AppNotificationManager sender, AppNotificationActivatedEventArgs args)
    {
        // Raised on a background thread: marshal to the UI thread before touching view models.
        Current.Dispatcher.Invoke(() =>
        {
            // args.Argument holds "action=openBook&bookId=42" style key/value pairs.
            if (args.Arguments.TryGetValue("bookId", out string? bookId))
            {
                ((MainWindow)MainWindow).ShowBook(int.Parse(bookId));
            }
        });
    }

    protected override void OnExit(ExitEventArgs e)
    {
        AppNotificationManager.Default.Unregister();
        base.OnExit(e);
    }
}

public static class ExportNotifications
{
    public static void ExportFinished(int bookId, string title)
    {
        AppNotification notification = new AppNotificationBuilder()
            .AddArgument("action", "openBook")
            .AddArgument("bookId", bookId.ToString())
            .AddText("Export finished")
            .AddText($"\"{title}\" was exported to your documents folder.")
            .BuildNotification();

        AppNotificationManager.Default.Show(notification);
    }
}

<Package
  xmlns:com="http://schemas.microsoft.com/appx/manifest/com/windows10"
  xmlns:desktop="http://schemas.microsoft.com/appx/manifest/desktop/windows10"
  IgnorableNamespaces="com desktop">
  <Applications>
    <Application>
      <Extensions>
        <!-- Which CLSID to activate when the notification is clicked. Generate your own GUID. -->
        <desktop:Extension Category="windows.toastNotificationActivation">
          <desktop:ToastNotificationActivation ToastActivatorCLSID="00000000-0000-0000-0000-000000000000" />
        </desktop:Extension>

        <!-- Register that CLSID as a COM server that launches the app. -->
        <com:Extension Category="windows.comServer">
          <com:ComServer>
            <com:ExeServer Executable="Bookshelf.Desktop.exe" DisplayName="Bookshelf Desktop"
                           Arguments="----AppNotificationActivated:">
              <com:Class Id="00000000-0000-0000-0000-000000000000" />
            </com:ExeServer>
          </com:ComServer>
        </com:Extension>
      </Extensions>
    </Application>
  </Applications>
</Package>

using System.Windows;
using System.Windows.Shell;

namespace Bookshelf.Desktop.Platform;

public static class BookshelfJumpList
{
    public static void Apply()
    {
        string exe = Environment.ProcessPath!;

        var addBook = new JumpTask
        {
            Title = "Add a book",
            Description = "Open Bookshelf Desktop on the Add Book dialog",
            ApplicationPath = exe,
            IconResourcePath = exe,
            Arguments = "--add",
            CustomCategory = "Bookshelf",
        };

        var jumpList = new JumpList { ShowRecentCategory = false, ShowFrequentCategory = false };
        jumpList.JumpItems.Add(addBook);

        // Attaches the list to the application and applies it to the shell.
        JumpList.SetJumpList(Application.Current, jumpList);
    }
}

using Windows.UI.StartScreen;

namespace Bookshelf.WinUI.Platform;

public static class BookshelfJumpList
{
    public static async Task ApplyAsync()
    {
        if (!JumpList.IsSupported())
        {
            return;
        }

        var jumpList = await JumpList.LoadCurrentAsync();
        jumpList.Items.Clear(); // only removes the app's own items; Recent and Frequent stay

        var addBook = JumpListItem.CreateWithArguments("--add", "Add a book");
        addBook.Description = "Open Bookshelf with a new book form";
        jumpList.Items.Add(addBook);

        await jumpList.SaveAsync();
    }
}

<PropertyGroup>
  <TargetFramework>net10.0-windows</TargetFramework>
  <UseWPF>true</UseWPF>
  <UseWindowsForms>true</UseWindowsForms>
  <Nullable>enable</Nullable>
</PropertyGroup>

using System.Drawing;
using System.Windows.Forms;

namespace Bookshelf.Desktop.Platform;

/// <summary>Owns the tray icon for the lifetime of the app. Dispose it on exit.</summary>
public sealed class TrayIconService : IDisposable
{
    private readonly NotifyIcon _icon;

    public TrayIconService(Action showMainWindow, Action exitApplication)
    {
        var menu = new ContextMenuStrip();
        menu.Items.Add("Open Bookshelf", null, (_, _) => showMainWindow());
        menu.Items.Add("Exit", null, (_, _) => exitApplication());

        _icon = new NotifyIcon
        {
            Icon = new Icon(Path.Combine(AppContext.BaseDirectory, "Assets", "bookshelf.ico")),
            Text = "Bookshelf Desktop",
            ContextMenuStrip = menu,
            Visible = true,
        };
        _icon.DoubleClick += (_, _) => showMainWindow();
    }

    public void Dispose()
    {
        _icon.Visible = false; // removes the icon immediately instead of leaving a ghost
        _icon.Dispose();
    }
}

<Window x:Class="Bookshelf.Desktop.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml">
  <Window.TaskbarItemInfo>
    <TaskbarItemInfo x:Name="TaskbarInfo" Description="Bookshelf Desktop" />
  </Window.TaskbarItemInfo>
  <!-- window content -->
</Window>

using System.Windows;
using System.Windows.Shell;

namespace Bookshelf.Desktop;

public partial class MainWindow : Window
{
    /// <summary>Shows export progress on the taskbar button; call on the UI thread.</summary>
    public void ReportExportProgress(int done, int total)
    {
        TaskbarInfo.ProgressState = done < total ? TaskbarItemProgressState.Normal : TaskbarItemProgressState.None;
        TaskbarInfo.ProgressValue = total == 0 ? 0 : (double)done / total;
    }
}

<Extensions>
  <uap:Extension Category="windows.shareTarget">
    <uap:ShareTarget Description="Add to Bookshelf">
      <uap:SupportedFileTypes>
        <uap:FileType>.bookshelf</uap:FileType>
        <uap:FileType>.csv</uap:FileType>
      </uap:SupportedFileTypes>
      <uap:DataFormat>StorageItems</uap:DataFormat>
    </uap:ShareTarget>
  </uap:Extension>
</Extensions>

using Microsoft.Windows.AppLifecycle;
using Windows.ApplicationModel.Activation;
using Windows.ApplicationModel.DataTransfer;
using Windows.ApplicationModel.DataTransfer.ShareTarget;
using Windows.Storage;

namespace Bookshelf.Desktop.Platform;

public static class ShareTargetHandler
{
    /// <summary>Returns true when this launch was a share; the caller then imports and exits.</summary>
    public static async Task<bool> TryHandleAsync(Func<IReadOnlyList<IStorageItem>, Task> importFiles)
    {
        AppActivationArguments activation = AppInstance.GetCurrent().GetActivatedEventArgs();
        if (activation.Kind != ExtendedActivationKind.ShareTarget
            || activation.Data is not ShareTargetActivatedEventArgs share)
        {
            return false;
        }

        ShareOperation operation = share.ShareOperation;
        operation.ReportStarted();
        try
        {
            if (operation.Data.Contains(StandardDataFormats.StorageItems))
            {
                IReadOnlyList<IStorageItem> items = await operation.Data.GetStorageItemsAsync();
                operation.ReportDataRetrieved();
                await importFiles(items); // validate count, type and size before importing
            }

            operation.ReportCompleted();
        }
        catch (Exception ex)
        {
            operation.ReportError($"Bookshelf could not import the shared content: {ex.Message}");
        }

        return true;
    }
}

using Microsoft.Windows.Widgets.Providers;

namespace Bookshelf.Desktop.Widgets;

/// <summary>"Now reading" widget. Exposed through a COM class factory, as in the official walkthrough.</summary>
internal sealed class NowReadingWidgetProvider : IWidgetProvider
{
    private const string Template = """
        { "type": "AdaptiveCard", "version": "1.5",
          "body": [ { "type": "TextBlock", "text": "${title}", "wrap": true } ] }
        """;

    public void CreateWidget(WidgetContext widgetContext) => Update(widgetContext.Id);

    public void DeleteWidget(string widgetId, string customState) { }

    public void OnActionInvoked(WidgetActionInvokedArgs actionInvokedArgs) =>
        Update(actionInvokedArgs.WidgetContext.Id);

    public void OnWidgetContextChanged(WidgetContextChangedArgs contextChangedArgs) =>
        Update(contextChangedArgs.WidgetContext.Id);

    public void Activate(WidgetContext widgetContext) => Update(widgetContext.Id);

    public void Deactivate(string widgetId) { }

    private static void Update(string widgetId)
    {
        var options = new WidgetUpdateRequestOptions(widgetId)
        {
            Template = Template,
            Data = """{ "title": "The Pragmatic Programmer" }""", // the real app reads IBookRepository
        };
        WidgetManager.GetDefault().UpdateWidget(options);
    }
}

<Extensions>
  <com:Extension Category="windows.comServer">
    <com:ComServer>
      <com:ExeServer Executable="Bookshelf.Desktop.exe" DisplayName="Bookshelf widget provider">
        <com:Class Id="00000000-0000-0000-0000-000000000000" DisplayName="NowReadingWidgetProvider" />
      </com:ExeServer>
    </com:ComServer>
  </com:Extension>
  <uap3:Extension Category="windows.appExtension">
    <uap3:AppExtension Name="com.microsoft.windows.widgets" DisplayName="Bookshelf" Id="BookshelfWidgets" PublicFolder="Public">
      <uap3:Properties>
        <WidgetProvider>
          <Activation>
            <CreateInstance ClassId="00000000-0000-0000-0000-000000000000" />
          </Activation>
          <Definitions>
            <Definition Id="Now_Reading" DisplayName="Now reading" Description="The book you are reading">
              <Capabilities>
                <Capability><Size Name="medium" /></Capability>
              </Capabilities>
            </Definition>
          </Definitions>
        </WidgetProvider>
      </uap3:Properties>
    </uap3:AppExtension>
  </uap3:Extension>
</Extensions>

<!-- Package.appxmanifest -->
<Package
  xmlns:systemai="http://schemas.microsoft.com/appx/manifest/systemai/windows10"
  IgnorableNamespaces="uap rescap systemai">
  <Dependencies>
    <TargetDeviceFamily Name="Windows.Desktop" MinVersion="10.0.17763.0" MaxVersionTested="10.0.26226.0" />
  </Dependencies>
  <Capabilities>
    <systemai:Capability Name="systemAIModels" />
  </Capabilities>
</Package>

<!-- Bookshelf.Desktop.csproj: stop Visual Studio from overwriting the manifest versions -->
<PropertyGroup>
  <AppxOSMinVersionReplaceManifestVersion>false</AppxOSMinVersionReplaceManifestVersion>
  <AppxOSMaxVersionTestedReplaceManifestVersion>false</AppxOSMaxVersionTestedReplaceManifestVersion>
</PropertyGroup>
<ItemGroup>
  <PackageReference Include="Microsoft.WindowsAppSDK" Version="2.5.1" />
</ItemGroup>

using Microsoft.Windows.AI;
using Microsoft.Windows.AI.Text;

namespace Bookshelf.Desktop.Services;

public interface IBookSummarizer
{
    bool IsAvailable { get; }
    Task<string?> SummarizeAsync(string description, CancellationToken cancellationToken = default);
}

public sealed class WindowsAiBookSummarizer : IBookSummarizer
{
    public bool IsAvailable => LanguageModel.GetReadyState() == AIFeatureReadyState.Ready;

    public async Task<string?> SummarizeAsync(string description, CancellationToken cancellationToken = default)
    {
        AIFeatureReadyState state = LanguageModel.GetReadyState();

        if (state == AIFeatureReadyState.NotReady)
        {
            // In the real app, ask the user first (several GB download in the background).
            var ensure = await LanguageModel.EnsureReadyAsync();
            if (ensure.Status != AIFeatureReadyResultState.Success)
            {
                return null;
            }
            state = LanguageModel.GetReadyState();
        }

        if (state != AIFeatureReadyState.Ready)
        {
            return null; // DisabledByUser or NotSupportedOnCurrentSystem: caller hides the button
        }

        using LanguageModel model = await LanguageModel.CreateAsync();
        var summarizer = new TextSummarizer(model);
        var result = await summarizer.SummarizeAsync(description);
        return result.Text;
    }
}

using Windows.ApplicationModel;

namespace Bookshelf.Desktop.Services;

public static class LimitedAccess
{
    /// <summary>Unlocks a Limited Access Feature. The id, token and attestation come from Microsoft.</summary>
    public static bool TryUnlock()
    {
        // Read from CI secrets or configuration. Never hard-code them or commit them.
        string? featureId = Environment.GetEnvironmentVariable("BOOKSHELF_LAF_FEATURE_ID");
        string? token = Environment.GetEnvironmentVariable("BOOKSHELF_LAF_TOKEN");
        string? attestation = Environment.GetEnvironmentVariable("BOOKSHELF_LAF_ATTESTATION");

        if (featureId is null || token is null || attestation is null)
        {
            return false;
        }

        var result = LimitedAccessFeatures.TryUnlockFeature(featureId, token, attestation);
        return result.Status is LimitedAccessFeatureStatus.Available
            or LimitedAccessFeatureStatus.AvailableWithoutToken;
    }
}