RS5 Fixes

WindowsAppRuntime.sln

@@ -1353,10 +1353,6 @@ Global
 		{A3FBA80D-5B35-471F-9A45-DB4B29E195B9} = {AC5FFC80-92FE-4933-BED2-EC5519AC4440}
 		{91D03B95-1B0C-4BEB-8441-30DA7D615538} = {448ED2E5-0B37-4D97-9E6B-8C10A507976A}
 		{103C0C23-7BA8-4D44-A63C-83488E2E3A81} = {91D03B95-1B0C-4BEB-8441-30DA7D615538}
-		{5B2D17FE-C371-417F-860C-3D32397C2404} = {AC5FFC80-92FE-4933-BED2-EC5519AC4440}
-		{424A6D96-37EE-4456-8347-08AB425C8DBE} = {AC5FFC80-92FE-4933-BED2-EC5519AC4440}
-		{56A1D696-FEDA-4333-BF37-772EBECECB10} = {AC5FFC80-92FE-4933-BED2-EC5519AC4440}
-		{D012E4BB-F16B-472D-A26D-D449CEFA988E} = {AC5FFC80-92FE-4933-BED2-EC5519AC4440}
 		{0A5FEE93-48B7-40EC-BB9A-B27D11060DA9} = {8630F7AA-2969-4DC9-8700-9B468C1DC21D}
 		{1307DD1B-BBE8-4CD0-B1A0-0DB6D61EEAA0} = {91D03B95-1B0C-4BEB-8441-30DA7D615538}
 		{A1B25DCF-6A54-414D-8E24-F4D24EE9299D} = {8630F7AA-2969-4DC9-8700-9B468C1DC21D}

dev/AppLifecycle/ActivationRegistrationManager.h

@@ -11,7 +11,7 @@ namespace winrt::Microsoft::Windows::AppLifecycle::implementation
     static PCWSTR c_argumentSuffix{ L":" };
     static PCWSTR c_msProtocolArgumentString{ L"ms-protocol" };
     static PCWSTR c_pushProtocolArgumentString{ L"WindowsAppRuntimePushServer" };
-    static PCWSTR c_toastProtocolArgumentString{ L"AppNotificationActivated" };
+    static PCWSTR c_appNotificationProtocolArgumentString{ L"AppNotificationActivated" };
     static PCWSTR c_runKeyPath{ LR"(Software\Microsoft\Windows\CurrentVersion\Run\)" };
 
     struct ActivationRegistrationManager

dev/AppLifecycle/AppInstance.cpp

@@ -68,7 +68,8 @@ namespace winrt::Microsoft::Windows::AppLifecycle::implementation
 
         wil::unique_hlocal_ptr<PWSTR[]> argv{ CommandLineToArgvW(commandLine.c_str(), &argc) };
 
-        PCWSTR activationKinds[] = { c_msProtocolArgumentString, c_pushProtocolArgumentString, c_toastProtocolArgumentString };
+        PCWSTR activationKinds[] = { c_msProtocolArgumentString, c_pushProtocolArgumentString, c_appNotificationProtocolArgumentString };
+
         for (auto activationKind : activationKinds)
         {
             auto [ kind, data ] = GetActivationArguments(argv.get(), argc, activationKind);
@@ -488,10 +489,10 @@ namespace winrt::Microsoft::Windows::AppLifecycle::implementation
             // protocol, except the catch-all LaunchActivatedEventArgs case.
             if (!contractArgument.empty())
             {
-                if (contractArgument == c_pushProtocolArgumentString || contractArgument == c_toastProtocolArgumentString)
+                if (contractArgument == c_pushProtocolArgumentString || contractArgument == c_appNotificationProtocolArgumentString)
                 {
                     // Generate a basic encoded launch Uri for Push/Toast activations
-                    PCWSTR contractId = (contractArgument == c_pushProtocolArgumentString) ? c_pushContractId : c_toastContractId;
+                    PCWSTR contractId = (contractArgument == c_pushProtocolArgumentString) ? c_pushContractId : c_appNotificationContractId;
                     std::wstring tempContractData = GenerateEncodedLaunchUri(L"App", contractId);
 
                     contractArgument = c_msProtocolArgumentString;

dev/AppLifecycle/ExtensionContract.h

@@ -26,7 +26,7 @@ namespace winrt::Microsoft::Windows::AppLifecycle::implementation
         { ExtendedActivationKind::Protocol, c_protocolContractId, &ProtocolActivatedEventArgs::Deserialize },
         { ExtendedActivationKind::StartupTask, c_startupTaskContractId, &StartupActivatedEventArgs::Deserialize },
         { ExtendedActivationKind::Push, c_pushContractId, &winrt::Microsoft::Windows::PushNotifications::Deserialize },
-        { ExtendedActivationKind::AppNotification, c_toastContractId, &winrt::Microsoft::Windows::PushNotifications::Deserialize },
+        { ExtendedActivationKind::AppNotification, c_appNotificationContractId, &winrt::Microsoft::Windows::PushNotifications::Deserialize },
     };
 
     inline bool IsEncodedLaunch(winrt::Windows::Foundation::Uri const& uri)

dev/PushNotifications/GetNotificationEventArgs.h

@@ -7,7 +7,7 @@
 #include "externs.h"
 
 constexpr PCWSTR c_pushContractId = L"Windows.Push";
-constexpr PCWSTR c_toastContractId = L"Windows.Toast";
+constexpr PCWSTR c_appNotificationContractId = L"Windows.Toast";
 
 namespace winrt::Microsoft::Windows::PushNotifications
 {

dev/PushNotifications/PushBackgroundTaskInstance.h

@@ -0,0 +1,35 @@
+#include <winrt/Windows.ApplicationModel.background.h>
+
+// Mocks IBackgroundTaskInstance to send raw payloads to packaged apps in
+// PushNotificationBackgroundTask::Run by com activation from PushNotificationsLongRunningProcess
+struct PushBackgroundTaskInstance : winrt::implements<PushBackgroundTaskInstance, winrt::Windows::ApplicationModel::Background::IBackgroundTaskInstance>
+{
+    PushBackgroundTaskInstance() {};
+    PushBackgroundTaskInstance(std::wstring const& payload): m_payload(payload) {};
+
+    winrt::guid InstanceId() { return winrt::guid(); };
+    UINT32 SuspendedCount() { return 0; };
+    UINT32 Progress() { return 0; };
+    UINT32 Progress(UINT32 /* progress */) { return 0; };
+    winrt::Windows::ApplicationModel::Background::BackgroundTaskRegistration Task() { return nullptr; };
+    winrt::Windows::Foundation::IInspectable TriggerDetails() { return winrt::box_value(m_payload); };
+    winrt::event_token Canceled(winrt::Windows::ApplicationModel::Background::BackgroundTaskCanceledEventHandler const& /* handler */) { return winrt::event_token{}; };
+    void Canceled(winrt::event_token const& /* token */) noexcept { return; };
+    winrt::Windows::ApplicationModel::Background::BackgroundTaskDeferral GetDeferral() { return nullptr; };
+private:
+    std::wstring m_payload;
+};
+
+struct PushBackgroundTaskInstanceFactory : winrt::implements<PushBackgroundTaskInstanceFactory, IClassFactory>
+{
+    HRESULT __stdcall CreateInstance(_In_opt_ IUnknown* aggregateInterface, _In_ REFIID interfaceId, _Outptr_ VOID** object) noexcept final
+    {
+        RETURN_HR_IF(CLASS_E_NOAGGREGATION, aggregateInterface != nullptr);
+        return winrt::make<PushBackgroundTaskInstance>().as(interfaceId, object);
+    }
+
+    HRESULT __stdcall LockServer(BOOL) noexcept final
+    {
+        return S_OK;
+    }
+};

dev/PushNotifications/PushNotificationBackgroundTask.cpp

@@ -12,6 +12,12 @@
 
 #include "PushNotificationReceivedEventArgs.h"
 #include "externs.h"
+#include "PushNotificationUtility.h"
+
+namespace PushNotificationHelpers
+{
+    using namespace winrt::Microsoft::Windows::PushNotifications::Helpers;
+}
 
 namespace winrt
 {
@@ -23,8 +29,20 @@ namespace winrt
 void PushNotificationBackgroundTask::Run(winrt::IBackgroundTaskInstance const& taskInstance)
 {
     auto appProperties = winrt::CoreApplication::Properties();
-    winrt::PushNotificationReceivedEventArgs activatedEventArgs = winrt::make<winrt::Microsoft::Windows::PushNotifications::implementation::PushNotificationReceivedEventArgs>(taskInstance);
-    appProperties.Insert(ACTIVATED_EVENT_ARGS_KEY, activatedEventArgs);
+    // This function can be triggered by either OS background infrastructure
+    // or by the PushNotificationsLongRunningProcess.
+    if (PushNotificationHelpers::IsPackagedAppScenario())
+    {
+        winrt::PushNotificationReceivedEventArgs activatedEventArgs{ winrt::make<winrt::Microsoft::Windows::PushNotifications::implementation::PushNotificationReceivedEventArgs>(taskInstance) };
+        appProperties.Insert(ACTIVATED_EVENT_ARGS_KEY, activatedEventArgs);
+    }
+    else
+    {
+        // Need to mock a RawNotification object instead of winrt boxing: https://github.com/microsoft/WindowsAppSDK/issues/2075
+        winrt::hstring payload{ winrt::unbox_value<winrt::hstring>(taskInstance.TriggerDetails()) };
+        winrt::PushNotificationReceivedEventArgs activatedEventArgs{ winrt::make<winrt::Microsoft::Windows::PushNotifications::implementation::PushNotificationReceivedEventArgs>(payload.c_str()) };
+        appProperties.Insert(LRP_ACTIVATED_EVENT_ARGS_KEY, activatedEventArgs);
+    }
 
     SetEvent(GetWaitHandleForArgs().get());
 }

dev/PushNotifications/PushNotificationChannel.cpp

@@ -5,25 +5,16 @@
 #include <winrt/Windows.Foundation.Metadata.h>
 #include "PushNotificationChannel.h"
 #include "Microsoft.Windows.PushNotifications.PushNotificationChannel.g.cpp"
-#include <winrt\Windows.Networking.PushNotifications.h>
 #include <winrt\Windows.Foundation.h>
 #include "PushNotificationReceivedEventArgs.h"
 #include <FrameworkUdk/PushNotifications.h>
 #include "externs.h"
 #include "PushNotificationTelemetry.h"
-#include <TerminalVelocityFeatures-PushNotifications.h>
 #include "PushNotificationUtility.h"
 
-namespace winrt::Windows
-{
-    using namespace winrt::Windows::Networking::PushNotifications;
-    using namespace winrt::Windows::Foundation;
-    using namespace winrt::Windows::Metadata;
-}
-namespace winrt::Microsoft
-{
-    using namespace winrt::Microsoft::Windows::PushNotifications;
-}
+using namespace winrt::Windows::Foundation;
+using namespace winrt::Microsoft::Windows::PushNotifications;
+
 
 namespace PushNotificationHelpers
 {
@@ -32,143 +23,92 @@ namespace PushNotificationHelpers
 
 namespace winrt::Microsoft::Windows::PushNotifications::implementation
 {
-    PushNotificationChannel::PushNotificationChannel(winrt::Windows::PushNotificationChannel const& channel): m_channel(channel) 
+    Uri PushNotificationChannel::Uri()
     {
-        THROW_HR_IF(E_NOTIMPL, !::Microsoft::Windows::PushNotifications::Feature_PushNotifications::IsEnabled());
+        return winrt::Windows::Foundation::Uri{ m_channelInfo.channelUri };
     }
 
-    winrt::Windows::Uri PushNotificationChannel::Uri()
+    DateTime PushNotificationChannel::ExpirationTime()
     {
-        if (m_channel)
-        {
-            return winrt::Windows::Uri{ m_channel.Uri() };
-        }
-        else
-        {
-            return winrt::Windows::Uri{ m_channelInfo.channelUri };
-        }
-    }
-
-    winrt::Windows::DateTime PushNotificationChannel::ExpirationTime()
-    {
-        if (m_channel)
-        {
-            return m_channel.ExpirationTime();
-        }
-        else
-        {
-            return m_channelInfo.channelExpiryTime;
-        }
+        return m_channelInfo.channelExpiryTime;
     }
 
     void PushNotificationChannel::Close()
     {
         try
         {
-            if (m_channel)
-            {
-                m_channel.Close();
-            }
-            else
-            {
-                THROW_IF_FAILED(PushNotifications_CloseChannel(m_channelInfo.appUserModelId.c_str(), m_channelInfo.channelId.c_str()));
-            }
-
+            THROW_IF_FAILED(PushNotifications_CloseChannel(m_channelInfo.appId.c_str(), m_channelInfo.channelId.c_str()));
             PushNotificationTelemetry::ChannelClosedByApi(S_OK);
         }
 
         catch (...)
         {
-            auto channelCloseException = hresult_error(to_hresult());
+            auto channelCloseException { hresult_error(to_hresult()) };
 
             PushNotificationTelemetry::ChannelClosedByApi(channelCloseException.code());
 
             if (channelCloseException.code() != HRESULT_FROM_WIN32(ERROR_NOT_FOUND))
             {
-                throw hresult_error(to_hresult());
+                throw channelCloseException;
             }
         }
     }
 
-    winrt::event_token PushNotificationChannel::PushReceived(winrt::Windows::TypedEventHandler<winrt::Microsoft::Windows::PushNotifications::PushNotificationChannel, winrt::Microsoft::Windows::PushNotifications::PushNotificationReceivedEventArgs> handler)
+    winrt::event_token PushNotificationChannel::PushReceived(TypedEventHandler<winrt::Microsoft::Windows::PushNotifications::PushNotificationChannel, winrt::Microsoft::Windows::PushNotifications::PushNotificationReceivedEventArgs> handler)
     {
-        if (PushNotificationHelpers::IsPackagedAppScenario())
+        bool registeredEvent { false };
         {
-            if (m_channel)
-            {
-                return m_channel.PushNotificationReceived([weak_self = get_weak(), handler](auto&&, auto&& args)
-                {
-                    if (auto strong = weak_self.get())
-                    {
-                        auto pushArgs = winrt::make<winrt::Microsoft::Windows::PushNotifications::implementation::PushNotificationReceivedEventArgs>(args);
-                        pushArgs.Handled(true);
-                        handler(*strong, pushArgs);
-                    };
-                });
-            }
-            else
-            {
-                // The channelUri is directly obtained when we request Channel from UDK using RemoteId
-                auto lock = m_lock.lock_exclusive();
-
-                if (!m_foregroundHandlerCount)
-                {
-                    auto appUserModelId{ winrt::Microsoft::Helpers::GetAppUserModelId() };
-
-                    THROW_IF_FAILED(PushNotifications_RegisterNotificationSinkForFullTrustApplication(appUserModelId.get(), this));
-                }
+            auto lock { m_lock.lock_shared() };
+            registeredEvent = bool(m_foregroundHandlers);
+        }
 
-                ++m_foregroundHandlerCount;
+        if(!registeredEvent)
+        {
+            if(PushNotificationHelpers::IsPackagedAppScenario())
+            {
+                auto appUserModelId{ PushNotificationHelpers::GetAppUserModelId() };
 
-                return m_foregroundHandlers.add(handler);
+                // Register foreground event through the UDK
+                THROW_IF_FAILED(PushNotifications_RegisterNotificationSinkForFullTrustApplication(appUserModelId.get(), this));
             }
-        }
-        else
-        {
-            auto lock = m_lock.lock_exclusive();
-            if (!m_foregroundHandlerCount++)
+            else
             {
-                auto notificationsLongRunningPlatform{ winrt::Microsoft::Helpers::GetNotificationPlatform() };
+                auto notificationsLongRunningPlatform{ PushNotificationHelpers::GetNotificationPlatform() };
 
                 wil::unique_cotaskmem_string processName;
                 THROW_IF_FAILED(GetCurrentProcessPath(processName));
 
-                THROW_IF_FAILED(notificationsLongRunningPlatform->RegisterForegroundActivator(this, processName.get()));             
+                // Register foreground event through the LRP
+                THROW_IF_FAILED(notificationsLongRunningPlatform->RegisterForegroundActivator(this, processName.get()));
             }
-            return m_foregroundHandlers.add(handler);
         }
+
+        auto lock { m_lock.lock_exclusive() };
+        return m_foregroundHandlers.add(handler);
     }
 
     void PushNotificationChannel::PushReceived(winrt::event_token const& token) noexcept
     {
-        if (PushNotificationHelpers::IsPackagedAppScenario())
+        bool registeredEvent { false };
         {
-            if (m_channel)
-            {
-                m_channel.PushNotificationReceived(token);
-            }
-            else
-            {
-                auto lock = m_lock.lock_exclusive();
-
-                if (m_foregroundHandlerCount == 1)
-                {
-                    auto appUserModelId{ winrt::Microsoft::Helpers::GetAppUserModelId() };
+            auto lock { m_lock.lock_exclusive() };
+            m_foregroundHandlers.remove(token);
+            registeredEvent = bool(m_foregroundHandlers);
+        }
 
-                    THROW_IF_FAILED(PushNotifications_UnregisterNotificationSinkForFullTrustApplication(appUserModelId.get()));
-                }
+        if(!registeredEvent)
+        {
+            // Packaged apps with BI available will remove their handlers from the platform.
+            // Unpackaged apps / Packaged apps treated as unpackaged will unregister from Long Running process.
+            if (PushNotificationHelpers::IsPackagedAppScenario())
+            {
+                auto appUserModelId{ PushNotificationHelpers::GetAppUserModelId() };
 
-                m_foregroundHandlers.remove(token);
-                --m_foregroundHandlerCount;
+                THROW_IF_FAILED(PushNotifications_UnregisterNotificationSinkForFullTrustApplication(appUserModelId.get()));
             }
-        }
-        else
-        {
-            auto lock = m_lock.lock_exclusive();
-            m_foregroundHandlers.remove(token);
-            if (!--m_foregroundHandlerCount)
+            else
             {
-                auto notificationsLongRunningPlatform{ winrt::Microsoft::Helpers::GetNotificationPlatform() };
+                auto notificationsLongRunningPlatform{ PushNotificationHelpers::GetNotificationPlatform() };
 
                 wil::unique_cotaskmem_string processName;
                 THROW_IF_FAILED(GetCurrentProcessPath(processName));
@@ -194,9 +134,12 @@ namespace winrt::Microsoft::Windows::PushNotifications::implementation
 
         if (!foregroundHandled)
         {
-            wil::unique_cotaskmem_string processName;
-            THROW_IF_FAILED(GetCurrentProcessPath(processName));
-            THROW_IF_FAILED(winrt::Microsoft::Helpers::ProtocolLaunchHelper(processName.get(), payloadLength, payload));
+            if (!AppModel::Identity::IsPackagedProcess())
+            {
+                wil::unique_cotaskmem_string processName;
+                THROW_IF_FAILED(GetCurrentProcessPath(processName));
+                THROW_IF_FAILED(PushNotificationHelpers::ProtocolLaunchHelper(processName.get(), payloadLength, payload));
+            }
         }
 
         return S_OK;