Background Task Samples: Cherry pick from experimental branch (#438)

* Added sample for WinAppSDK BackgroundTaskBuilder (#392)

* Added sample for WinAppSDK BackgroundTaskBuilder

Signed-off-by: Godly Alias <godlyalias@microsoft.com>

* Added comments for improved readability of the sample (#400)

Signed-off-by: godlytalias <godlytalias@yahoo.co.in>

* InProc BackgroundTask Samples (#413)

* Added InProc BackgroundTask Samples

Signed-off-by: godlytalias <godlytalias@yahoo.co.in>

* Support for trimming in BackgroundTask Samples (#421)

Signed-off-by: godlytalias <godlytalias@yahoo.co.in>

---------

Signed-off-by: godlytalias <godlytalias@yahoo.co.in>

Author: godlytalias

Diff for: README.md

@@ -23,7 +23,10 @@ This repository hosts samples for the [Windows App SDK](https://github.com/micro
     - [Restart](Samples/AppLifecycle/Restart): These samples demonstrate synchronously restarting an app with command-line restart arguments.
     - [Share Target](Samples\AppLifecycle\ShareTarget\WinUI-CS-ShareTargetSampleApp): This sample demonstrates an app that can be activated as a share target.
 
-### Data and Files
+#### Background Task
+- [Background Task](Samples/BackgroundTask): These samples demonstrates usage of Background Task feature in WinAppSDK apps leveraging the WinAppSDK Background Task API.
+
+#### Data and Files
 - [Resource Management](Samples/ResourceManagement): These samples demonstrates app resource management using the MRT Core APIs.
 
 ### Deployment

Diff for: Samples/BackgroundTask/InProc BackgroundTask/cpp-winui/BackgroundTaskBuilder/App.xaml

@@ -0,0 +1,18 @@
+<!-- Copyright (c) Microsoft Corporation and Contributors. -->
+<!-- Licensed under the MIT License. -->
+
+<Application
+    x:Class="BackgroundTaskBuilder.App"
+    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
+    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
+    xmlns:local="using:BackgroundTaskBuilder">
+    <Application.Resources>
+        <ResourceDictionary>
+            <ResourceDictionary.MergedDictionaries>
+                <XamlControlsResources xmlns="using:Microsoft.UI.Xaml.Controls" />
+                <!-- Other merged dictionaries here -->
+            </ResourceDictionary.MergedDictionaries>
+            <!-- Other app resources here -->
+        </ResourceDictionary>
+    </Application.Resources>
+</Application>

Diff for: Samples/BackgroundTask/InProc BackgroundTask/cpp-winui/BackgroundTaskBuilder/App.xaml.cpp

@@ -0,0 +1,55 @@
+// Copyright (c) Microsoft Corporation and Contributors.
+// Licensed under the MIT License.
+
+#include "pch.h"
+#include "App.xaml.h"
+#include "MainWindow.xaml.h"
+
+using namespace winrt;
+using namespace Microsoft::UI::Xaml;
+using namespace BackgroundTaskBuilder;
+
+// To learn more about WinUI, the WinUI project structure,
+// and more about our project templates, see: http://aka.ms/winui-project-info.
+
+namespace winrt::BackgroundTaskBuilder::implementation
+{
+    Microsoft::UI::Xaml::Window App::window{ nullptr };
+    /// <summary>
+    /// Initializes the singleton application object.  This is the first line of authored code
+    /// executed, and as such is the logical equivalent of main() or WinMain().
+    /// </summary>
+    App::App()
+    {
+        // Xaml objects should not call InitializeComponent during construction.
+        // See https://github.com/microsoft/cppwinrt/tree/master/nuget#initializecomponent
+
+#if defined _DEBUG && !defined DISABLE_XAML_GENERATED_BREAK_ON_UNHANDLED_EXCEPTION
+        UnhandledException([](IInspectable const&, UnhandledExceptionEventArgs const& e)
+        {
+            if (IsDebuggerPresent())
+            {
+                auto errorMessage = e.Message();
+                __debugbreak();
+            }
+        });
+#endif
+    }
+
+    /// <summary>
+    /// Invoked when the application is launched.
+    /// </summary>
+    /// <param name="e">Details about the launch request and process.</param>
+    void App::OnLaunched([[maybe_unused]] LaunchActivatedEventArgs const& e)
+    {
+        window = make<MainWindow>();
+        window.Activate();
+        // Start COM server for the COM calls to complete
+        comRegister.RegisterBackgroundTaskFactory();
+    }
+
+    winrt::Microsoft::UI::Xaml::Window App::Window()
+    {
+        return window;
+    }
+}

Diff for: Samples/BackgroundTask/InProc BackgroundTask/cpp-winui/BackgroundTaskBuilder/App.xaml.h

@@ -0,0 +1,22 @@
+// Copyright (c) Microsoft Corporation and Contributors.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "App.xaml.g.h"
+#include "RegisterForCOM.h"
+
+namespace winrt::BackgroundTaskBuilder::implementation
+{
+    struct App : AppT<App>
+    {
+        App();
+
+        void OnLaunched(Microsoft::UI::Xaml::LaunchActivatedEventArgs const&);
+        static winrt::Microsoft::UI::Xaml::Window Window();
+
+    private:
+        static winrt::Microsoft::UI::Xaml::Window window;
+        RegisterForCom comRegister;
+    };
+}

Diff for: Samples/BackgroundTask/InProc BackgroundTask/cpp-winui/BackgroundTaskBuilder/Assets/LockScreenLogo.scale-200.png

@@ -0,0 +1,55 @@
+// Copyright (c) Microsoft Corporation and Contributors.
+// Licensed under the MIT License.
+
+#include "pch.h"
+#include "BackgroundTask.h"
+#include "RegisterForCOM.h"
+#include "winrt/Windows.Data.Xml.Dom.h"
+#include "winrt/Windows.UI.Notifications.h"
+#include "App.xaml.h"
+
+using namespace winrt;
+namespace winrt
+{
+    using namespace winrt::Windows::ApplicationModel::Background;
+    using namespace Windows::Data::Xml::Dom;
+    using namespace Windows::UI::Notifications;
+}
+
+namespace winrt::BackgroundTaskBuilder
+{
+    void BackgroundTask::Run(_In_ IBackgroundTaskInstance taskInstance)
+    {
+        // Get deferral to indicate not to kill the background task process as soon as the Run method returns
+        m_deferral = taskInstance.GetDeferral();
+        m_progress = 0;
+        taskInstance.Canceled({ this, &BackgroundTask::OnCanceled });
+
+        // Calling a method on the Window to inform that the background task is executed
+        winrt::Microsoft::UI::Xaml::Window window = winrt::BackgroundTaskBuilder::implementation::App::Window();
+        m_mainWindow = window.as<winrt::BackgroundTaskBuilder::IMainWindow>();
+
+        Windows::Foundation::TimeSpan period{ std::chrono::seconds{2} };
+        m_periodicTimer = Windows::System::Threading::ThreadPoolTimer::CreatePeriodicTimer([this, lifetime = get_strong()](Windows::System::Threading::ThreadPoolTimer timer)
+            {
+                if (!m_cancelRequested && m_progress < 100)
+                {
+                    m_progress += 10;
+                }
+                else
+                {
+                    m_periodicTimer.Cancel();
+
+                    // Indicate that the background task has completed.
+                    m_deferral.Complete();
+                    if (m_cancelRequested) m_progress = -1;
+                }
+                m_mainWindow.BackgroundTaskExecuted(m_progress);
+            }, period);
+    }
+
+    void BackgroundTask::OnCanceled(_In_ IBackgroundTaskInstance /* taskInstance */, _In_ BackgroundTaskCancellationReason /* cancelReason */)
+    {
+        m_cancelRequested = true;
+    }
+}

Diff for: Samples/BackgroundTask/InProc BackgroundTask/cpp-winui/BackgroundTaskBuilder/Assets/SplashScreen.scale-200.png

@@ -0,0 +1,45 @@
+// Copyright (c) Microsoft Corporation and Contributors.
+// Licensed under the MIT License.
+
+#pragma once
+
+#include "pch.h"
+#include "MainWindow.g.h"
+
+#define CLSID_BackgroundTask "12345678-1234-1234-1234-1234567890CD"
+namespace winrt::BackgroundTaskBuilder
+{
+    struct __declspec(uuid(CLSID_BackgroundTask))
+    BackgroundTask : implements<BackgroundTask, winrt::Windows::ApplicationModel::Background::IBackgroundTask>
+    {
+        void Run(_In_ winrt::Windows::ApplicationModel::Background::IBackgroundTaskInstance taskInstance);
+    private:
+        void OnCanceled(_In_ winrt::Windows::ApplicationModel::Background::IBackgroundTaskInstance /* taskInstance */, _In_ winrt::Windows::ApplicationModel::Background::BackgroundTaskCancellationReason /* cancelReason */);
+        volatile bool m_cancelRequested = false;
+        winrt::Windows::ApplicationModel::Background::BackgroundTaskDeferral m_deferral = nullptr;
+        Windows::System::Threading::ThreadPoolTimer m_periodicTimer = nullptr;
+        winrt::BackgroundTaskBuilder::IMainWindow m_mainWindow = nullptr;
+        int m_progress{ 0 };
+    };
+
+    struct BackgroundTaskFactory : implements<BackgroundTaskFactory, IClassFactory>
+    {
+        HRESULT __stdcall CreateInstance(_In_opt_ IUnknown* aggregateInterface, _In_ REFIID interfaceId, _Outptr_ VOID** object) noexcept final try
+        {
+            if (aggregateInterface != NULL) {
+                return CLASS_E_NOAGGREGATION;
+            }
+
+            return make<BackgroundTask>().as(interfaceId, object);
+        }
+        CATCH_RETURN();
+
+        HRESULT __stdcall LockServer(BOOL lock) noexcept final try
+        {
+            UNREFERENCED_PARAMETER(lock);
+            return S_OK;
+        }
+        CATCH_RETURN();
+    };
+}
+