User/purifoypaul/rs5 packaged com activation

dev/PushNotifications/PushNotificationActivationInfo.cpp

@@ -20,11 +20,6 @@ namespace winrt::Microsoft::Windows::PushNotifications::implementation
         THROW_HR_IF(E_NOTIMPL, !::Microsoft::Windows::PushNotifications::Feature_PushNotifications::IsEnabled());
     }
 
-    PushNotificationActivationInfo::PushNotificationActivationInfo(winrt::PushNotificationRegistrationActivators const& activators) : m_activators(activators), m_taskClsid(GUID_NULL)
-    {
-        THROW_HR_IF(E_NOTIMPL, !::Microsoft::Windows::PushNotifications::Feature_PushNotifications::IsEnabled());
-    }
-
     winrt::guid PushNotificationActivationInfo::TaskClsid()
     {
         return m_taskClsid;

dev/PushNotifications/PushNotificationActivationInfo.h

@@ -9,7 +9,6 @@ namespace winrt::Microsoft::Windows::PushNotifications::implementation
     struct PushNotificationActivationInfo : PushNotificationActivationInfoT<PushNotificationActivationInfo>
     {
         PushNotificationActivationInfo(Microsoft::Windows::PushNotifications::PushNotificationRegistrationActivators const& activators, winrt::guid const& taskClsid);
-        PushNotificationActivationInfo(Microsoft::Windows::PushNotifications::PushNotificationRegistrationActivators const& activators);
 
         winrt::guid TaskClsid();
         Microsoft::Windows::PushNotifications::PushNotificationRegistrationActivators Activators();

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,17 @@ 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);
+    if (PushNotificationHelpers::IsPackagedAppScenario())
+    {
+        winrt::PushNotificationReceivedEventArgs activatedEventArgs{ winrt::make<winrt::Microsoft::Windows::PushNotifications::implementation::PushNotificationReceivedEventArgs>(taskInstance) };
+        appProperties.Insert(ACTIVATED_EVENT_ARGS_KEY, activatedEventArgs);
+    }
+    else
+    {
+        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(UNPACKAGED_EVENT_ARGS_KEY, activatedEventArgs);
+    }
 
     SetEvent(GetWaitHandleForArgs().get());
 }

dev/PushNotifications/PushNotificationManager.cpp

@@ -49,6 +49,7 @@ namespace winrt::Microsoft::Windows::PushNotifications::implementation
     static winrt::Windows::ApplicationModel::Background::IBackgroundTaskRegistration s_pushTriggerRegistration{ nullptr };
     static wil::unique_com_class_object_cookie s_comActivatorRegistration;
     static bool s_protocolRegistration{ false };
+    static winrt::guid s_taskClsid{ GUID_NULL };
     static wil::srwlock s_activatorInfoLock;
 
     inline constexpr auto c_maxBackoff{ 5min };
@@ -200,7 +201,7 @@ namespace winrt::Microsoft::Windows::PushNotifications::implementation
 
                         wil::unique_cotaskmem_string processName;
                         THROW_IF_FAILED(GetCurrentProcessPath(processName));
-                        THROW_IF_FAILED(notificationPlatform->RegisterLongRunningActivator(processName.get()));
+                        THROW_IF_FAILED(notificationPlatform->RegisterLongRunningActivator(processName.get(), s_taskClsid));
 
                         std::wstring toastAppId{ RetrieveToastAppId() };
                         THROW_IF_FAILED(notificationPlatform->AddToastRegistrationMapping(processName.get(), toastAppId.c_str()));
@@ -269,9 +270,17 @@ namespace winrt::Microsoft::Windows::PushNotifications::implementation
                     THROW_HR_IF(E_INVALIDARG, s_protocolRegistration);
                 }
 
+                s_taskClsid = details.TaskClsid();
                 wil::unique_cotaskmem_string unpackagedAppUserModelId;
                 RegisterUnpackagedApplicationHelper(GUID_NULL, unpackagedAppUserModelId); // create default registration for app
 
+                THROW_IF_FAILED(::CoRegisterClassObject(
+                    s_taskClsid,
+                    winrt::make<PushNotificationBackgroundTaskFactory>().get(),
+                    CLSCTX_LOCAL_SERVER,
+                    REGCLS_MULTIPLEUSE,
+                    &s_comActivatorRegistration));
+
                 {
                     auto lock = s_activatorInfoLock.lock_exclusive();
                     s_protocolRegistration = true;

dev/PushNotifications/PushNotifications.idl

@@ -39,11 +39,9 @@ namespace Microsoft.Windows.PushNotifications
         // Initialize using a Registration option and optionally defined parameters like manifest defined activatorId
         // 1) If kind = PushTrigger is specified, only the Push Trigger will be Registered with Background Infra
         // 2) If kind = ComActivator is specified, the Background Task component will be Registered as an in-process COM server
+        // 3) If kind = ProtocolActivator is specified, the LRP will CoCreateInstance the application in background scenarios
         PushNotificationActivationInfo(PushNotificationRegistrationActivators activators, Guid taskClsid);
 
-        // Applications that need to use ProtocolActivator will use this constructor
-        PushNotificationActivationInfo(PushNotificationRegistrationActivators activators);
-
         // The CLSID associated with the Client COM server that Windows App SDK will activate
         Guid TaskClsid{ get; };
 

dev/PushNotifications/PushNotificationsLongRunningTask.ProxyStub/NotificationsLongRunningProcess.idl

@@ -19,7 +19,7 @@ interface IWpnForegroundSink : IUnknown
 [pointer_default(unique)]
 interface INotificationsLongRunningPlatform : IUnknown
 {
-    HRESULT RegisterLongRunningActivator([in] LPCWSTR processName);
+    HRESULT RegisterLongRunningActivator([in] LPCWSTR processName, [in] GUID comServerClsid);
 
     HRESULT UnregisterLongRunningActivator([in] LPCWSTR processName);
 

dev/PushNotifications/PushNotificationsLongRunningTask/NotificationListener.cpp

@@ -2,7 +2,10 @@
 
 #include "pch.h"
 #include "../PushNotificationUtility.h"
+#include <winrt/Windows.ApplicationModel.background.h>
+#include "PushBackgroundTaskInstance.h"
 
+using namespace winrt::Windows::ApplicationModel::Background;
 namespace ToastNotifications
 {
     using namespace ABI::Microsoft::Internal::ToastNotifications;
@@ -12,10 +15,12 @@ HRESULT NotificationListener::RuntimeClassInitialize(
     std::shared_ptr<ForegroundSinkManager> foregroundSinkManager,
     std::shared_ptr<ToastRegistrationManager> toastRegistrationManager,
     std::wstring const& appId,
-    std::wstring const& processName) noexcept try
+    std::wstring const& processName,
+    winrt::guid const& comServerClsid) noexcept try
 {
     m_foregroundSinkManager = foregroundSinkManager;
     m_toastRegistrationManager = toastRegistrationManager;
+    m_comServerClsid = comServerClsid;
 
     m_appId = appId;
     m_processName = processName;
@@ -32,7 +37,19 @@ STDMETHODIMP_(HRESULT __stdcall) NotificationListener::OnRawNotificationReceived
 
     if (!m_foregroundSinkManager->InvokeForegroundHandlers(m_appId, payloadArray, payloadLength))
     {
-        THROW_IF_FAILED(winrt::Microsoft::Windows::PushNotifications::Helpers::ProtocolLaunchHelper(m_processName, payloadLength, payload));
+        if (m_comServerClsid == winrt::guid())
+        {
+            THROW_IF_FAILED(winrt::Microsoft::Windows::PushNotifications::Helpers::ProtocolLaunchHelper(m_processName, payloadLength, payload));
+        }
+        else
+        {
+            std::wstring payloadString(payloadArray.begin(), payloadArray.end());
+
+            auto localBackgroundTask = winrt::create_instance<winrt::Windows::ApplicationModel::Background::IBackgroundTask>(m_comServerClsid, CLSCTX_ALL);
+            auto pushBackgroundTaskInstance{ winrt::make_self<PushBackgroundTaskInstance>() };
+            pushBackgroundTaskInstance->SetRawNotificationPayload(payloadString);
+            localBackgroundTask.Run(*pushBackgroundTaskInstance);
+        }
     };
 
     return S_OK;

dev/PushNotifications/PushNotificationsLongRunningTask/NotificationListener.h

@@ -12,7 +12,8 @@ class NotificationListener : public Microsoft::WRL::RuntimeClass<::ABI::Microsof
         std::shared_ptr<ForegroundSinkManager> foregroundSinkManager,
         std::shared_ptr<ToastRegistrationManager> toastRegistrationManager,
         std::wstring const& appId,
-        std::wstring const& processName) noexcept;
+        std::wstring const& processName,
+        winrt::guid const& comServerClsid) noexcept;
 
     STDMETHOD(OnRawNotificationReceived)(unsigned int payloadLength, _In_ byte* payload, _In_ HSTRING correlationVector) noexcept;
     STDMETHOD(OnToastNotificationReceived)(ABI::Microsoft::Internal::ToastNotifications::INotificationProperties* notificationProperties,
@@ -23,6 +24,6 @@ class NotificationListener : public Microsoft::WRL::RuntimeClass<::ABI::Microsof
 
     std::wstring m_appId;
     std::wstring m_processName;
-
+    winrt::guid m_comServerClsid;
     wil::srwlock m_lock;
 };

dev/PushNotifications/PushNotificationsLongRunningTask/NotificationListenerManager.cpp

@@ -9,26 +9,24 @@ void NotificationListenerManager::Initialize(std::shared_ptr<ForegroundSinkManag
     m_toastRegistrationManager = toastRegistrationManager;
 }
 
-void NotificationListenerManager::SetAppIdMapping(std::map<std::wstring, std::wstring>& appIdList)
+void NotificationListenerManager::SetAppIdMapping(std::map<std::wstring, std::pair<std::wstring, winrt::guid>>& appIdList)
 {
     for (auto appData : appIdList)
     {
-        AddListener(appData.first, appData.second);
+        AddListener(appData.first, appData.second.first, appData.second.second);
     }
 }
 
-void NotificationListenerManager::AddListener(std::wstring const& appId, std::wstring const& processName)
+void NotificationListenerManager::AddListener(std::wstring const& appId, std::wstring const& processName, winrt::guid const& comServerClsid)
 {
     THROW_HR_IF(E_INVALIDARG, appId.empty());
-    THROW_HR_IF(E_INVALIDARG, processName.empty());
-
-
+    THROW_HR_IF(E_INVALIDARG, processName.empty());    
 
     // Make sure we keep the long running sink up-to-date with wpncore.
     ComPtr<INotificationListener> newListener;
     {
         auto lock{ m_lock.lock_shared() };
-        THROW_IF_FAILED(MakeAndInitialize<NotificationListener>(&newListener, m_foregroundSinkManager, m_toastRegistrationManager, appId, processName));
+        THROW_IF_FAILED(MakeAndInitialize<NotificationListener>(&newListener, m_foregroundSinkManager, m_toastRegistrationManager, appId, processName, comServerClsid));
     }
 
     THROW_IF_FAILED(PushNotifications_RegisterNotificationSinkForFullTrustApplication(appId.c_str(), newListener.Get()));

dev/PushNotifications/PushNotificationsLongRunningTask/NotificationListenerManager.h

@@ -12,9 +12,9 @@ class NotificationListenerManager
     // This function has to be called after initializing the ForegroundSinkManager during Platform initialization
     void Initialize(std::shared_ptr<ForegroundSinkManager> foregroundSinkManager, std::shared_ptr<ToastRegistrationManager> toastRegistrationManager);
 
-    void SetAppIdMapping(std::map<std::wstring, std::wstring>& appIdList);
+    void SetAppIdMapping(std::map<std::wstring, std::pair<std::wstring, winrt::guid>>& appIdList);
 
-    void AddListener(std::wstring const& appId, std::wstring const& processName);
+    void AddListener(std::wstring const& appId, std::wstring const& processName, winrt::guid const& comServerClsid);
     void RemoveListener(std::wstring appId);
 
     bool IsEmpty();

dev/PushNotifications/PushNotificationsLongRunningTask/PushBackgroundTaskInstance.cpp

@@ -0,0 +1,53 @@
+#pragma once
+
+#include "pch.h"
+
+#include "PushBackgroundTaskInstance.h"
+#include <winrt/base.h>
+
+using namespace winrt::Windows::Networking::PushNotifications;
+
+winrt::guid PushBackgroundTaskInstance::InstanceId()
+{
+    return winrt::guid();
+}
+
+UINT32 PushBackgroundTaskInstance::SuspendedCount()
+{
+    return 0;
+}
+
+UINT32 PushBackgroundTaskInstance::Progress()
+{
+    return 0;
+}
+
+UINT32 PushBackgroundTaskInstance::Progress(UINT32 progress)
+{
+    return 0;
+}
+
+winrt::Windows::ApplicationModel::Background::BackgroundTaskRegistration PushBackgroundTaskInstance::Task()
+{
+    return nullptr;
+}
+
+winrt::event_token PushBackgroundTaskInstance::Canceled(winrt::Windows::ApplicationModel::Background::BackgroundTaskCanceledEventHandler const& handler)
+{
+    return winrt::event_token{};
+}
+
+void PushBackgroundTaskInstance::Canceled(winrt::event_token const& token) noexcept
+{
+    return;
+}
+
+winrt::Windows::ApplicationModel::Background::BackgroundTaskDeferral PushBackgroundTaskInstance::GetDeferral()
+{
+    return nullptr;
+}
+
+winrt::Windows::Foundation::IInspectable PushBackgroundTaskInstance::TriggerDetails()
+{
+    return winrt::box_value(m_payload);
+}

dev/PushNotifications/PushNotificationsLongRunningTask/PushBackgroundTaskInstance.h

@@ -0,0 +1,34 @@
+#include <winrt/Windows.ApplicationModel.background.h>
+
+struct PushBackgroundTaskInstance : winrt::implements<PushBackgroundTaskInstance, winrt::Windows::ApplicationModel::Background::IBackgroundTaskInstance>
+{
+    PushBackgroundTaskInstance() {};
+
+    winrt::guid InstanceId();
+    UINT32 SuspendedCount();
+    UINT32 Progress();
+    UINT32 Progress(UINT32 progress);
+    winrt::Windows::ApplicationModel::Background::BackgroundTaskRegistration Task();
+    winrt::Windows::Foundation::IInspectable TriggerDetails();
+    winrt::event_token Canceled(winrt::Windows::ApplicationModel::Background::BackgroundTaskCanceledEventHandler const& handler);
+    void Canceled(winrt::event_token const& token) noexcept;
+    winrt::Windows::ApplicationModel::Background::BackgroundTaskDeferral GetDeferral();
+
+    void SetRawNotificationPayload(std::wstring const& payload) { m_payload = payload; };
+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/PushNotificationsLongRunningTask/PushNotificationsLongRunningTask.vcxproj

@@ -232,6 +232,7 @@
     <ClCompile Include="platformfactory.cpp" />
     <ClCompile Include="PlatformLifetimeManager.cpp" />
     <ClCompile Include="NotificationListenerManager.cpp" />
+    <ClCompile Include="PushBackgroundTaskInstance.cpp" />
     <ClCompile Include="ToastRegistrationManager.cpp" />
     <ClCompile Include="winmain.cpp" />
   </ItemGroup>
@@ -243,6 +244,7 @@
     <ClInclude Include="platformfactory.h" />
     <ClInclude Include="PlatformLifetimeManager.h" />
     <ClInclude Include="NotificationListenerManager.h" />
+    <ClInclude Include="PushBackgroundTaskInstance.h" />
     <ClInclude Include="ToastRegistrationManager.h" />
   </ItemGroup>
   <ItemGroup>

dev/PushNotifications/PushNotificationsLongRunningTask/PushNotificationsLongRunningTask.vcxproj.filters

@@ -39,6 +39,9 @@
     <ClInclude Include="ToastRegistrationManager.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="PushBackgroundTaskInstance.h">
+      <Filter>Source Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="pch.cpp">
@@ -68,6 +71,9 @@
     <ClCompile Include="ToastRegistrationManager.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="PushBackgroundTaskInstance.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <None Include="packages.config" />

dev/PushNotifications/PushNotificationsLongRunningTask/pch.h

@@ -22,7 +22,9 @@
 
 #include <winrt/Windows.Foundation.h>
 #include <winrt/Windows.Foundation.Collections.h>
-
+#include <winrt/Windows.ApplicationModel.Activation.h>
+#include <winrt/Windows.Storage.Streams.h>
+#include <winrt/Windows.Networking.PushNotifications.h>
 #include <winrt/Windows.Storage.h>
 
 #include <wil/com.h>