Support for Windows 7 (#469)

Author: kennykerr

cppwinrt/component_writers.h

@@ -186,9 +186,7 @@ int32_t __stdcall WINRT_CanUnloadNow() noexcept
 
 int32_t __stdcall WINRT_GetActivationFactory(void* classId, void** factory) noexcept try
 {
-    uint32_t length{};
-    wchar_t const* const buffer = WINRT_WindowsGetStringRawBuffer(classId, &length);
-    std::wstring_view const name{ buffer, length };
+    std::wstring_view const name{ *reinterpret_cast<winrt::hstring*>(&classId) };
     *factory = %_get_activation_factory(name);
 
     if (*factory)

cppwinrt/cppwinrt.vcxproj

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <Import Project="..\packages\Microsoft.Windows.WinMD.1.0.191006.1\build\native\Microsoft.Windows.WinMD.props" Condition="Exists('..\packages\Microsoft.Windows.WinMD.1.0.191006.1\build\native\Microsoft.Windows.WinMD.props')" />
+  <Import Project="..\packages\Microsoft.Windows.WinMD.1.0.191022.1\build\native\Microsoft.Windows.WinMD.props" Condition="Exists('..\packages\Microsoft.Windows.WinMD.1.0.191022.1\build\native\Microsoft.Windows.WinMD.props')" />
   <ItemGroup Label="ProjectConfigurations">
     <ProjectConfiguration Include="Debug|ARM">
       <Configuration>Debug</Configuration>
@@ -351,6 +351,6 @@
     <PropertyGroup>
       <ErrorText>This project references NuGet package(s) that are missing on this computer. Use NuGet Package Restore to download them.  For more information, see http://go.microsoft.com/fwlink/?LinkID=322105. The missing file is {0}.</ErrorText>
     </PropertyGroup>
-    <Error Condition="!Exists('..\packages\Microsoft.Windows.WinMD.1.0.191006.1\build\native\Microsoft.Windows.WinMD.props')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\Microsoft.Windows.WinMD.1.0.191006.1\build\native\Microsoft.Windows.WinMD.props'))" />
+    <Error Condition="!Exists('..\packages\Microsoft.Windows.WinMD.1.0.191022.1\build\native\Microsoft.Windows.WinMD.props')" Text="$([System.String]::Format('$(ErrorText)', '..\packages\Microsoft.Windows.WinMD.1.0.191022.1\build\native\Microsoft.Windows.WinMD.props'))" />
   </Target>
 </Project>

cppwinrt/packages.config

@@ -1,4 +1,4 @@
 <?xml version="1.0" encoding="utf-8"?>
 <packages>
-  <package id="Microsoft.Windows.WinMD" version="1.0.191006.1" targetFramework="native" />
+  <package id="Microsoft.Windows.WinMD" version="1.0.191022.1" targetFramework="native" />
 </packages>

strings/base_abi.h

@@ -50,6 +50,13 @@ namespace winrt::impl
         virtual int32_t __stdcall DisconnectObject(uint32_t dwReserved) noexcept = 0;
     };
 
+    struct __declspec(novtable) IGlobalInterfaceTable : unknown_abi
+    {
+        virtual int32_t __stdcall RegisterInterfaceInGlobal(void* object, guid const& iid, uint32_t* cookie) noexcept = 0;
+        virtual int32_t __stdcall RevokeInterfaceFromGlobal(uint32_t cookie) noexcept = 0;
+        virtual int32_t __stdcall GetInterfaceFromGlobal(uint32_t cookie, guid const& iid, void** object) noexcept = 0;
+    };
+
     struct __declspec(novtable) IStaticLifetime : inspectable_abi
     {
         virtual int32_t __stdcall unused() noexcept = 0;
@@ -134,7 +141,9 @@ namespace winrt::impl
     template <> inline constexpr guid guid_v<Windows::Foundation::IInspectable>{ 0xAF86E2E0, 0xB12D, 0x4C6A, { 0x9C,0x5A,0xD7,0xAA,0x65,0x10,0x1E,0x90 } };
     template <> inline constexpr guid guid_v<Windows::Foundation::IActivationFactory>{ 0x00000035, 0x0000, 0x0000, { 0xc0,0x00,0x00,0x00,0x00,0x00,0x00,0x46 } };
     template <> inline constexpr guid guid_v<IAgileObject>{ 0x94EA2B94, 0xE9CC, 0x49E0, { 0xC0,0xFF,0xEE,0x64,0xCA,0x8F,0x5B,0x90 } };
+    template <> inline constexpr guid guid_v<IAgileReference>{ 0xC03F6A43, 0x65A4, 0x9818, { 0x98,0x7E,0xE0,0xB8,0x10,0xD2,0xA6,0xF2 } };
     template <> inline constexpr guid guid_v<IMarshal>{ 0x00000003, 0x0000, 0x0000, { 0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46 } };
+    template <> inline constexpr guid guid_v<IGlobalInterfaceTable>{ 0x00000146, 0x0000, 0x0000, { 0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46 } };
     template <> inline constexpr guid guid_v<IStaticLifetime>{ 0x17b0e613, 0x942a, 0x422d, { 0x90,0x4c,0xf9,0x0d,0xc7,0x1a,0x7d,0xae } };
     template <> inline constexpr guid guid_v<IStaticLifetimeCollection>{ 0x1b0d3570, 0x0877, 0x5ec2, { 0x8a,0x2c,0x3b,0x95,0x39,0x50,0x6a,0xca } };
     template <> inline constexpr guid guid_v<IWeakReference>{ 0x00000037, 0x0000, 0x0000, { 0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46 } };

strings/base_activation.h

@@ -1,20 +1,102 @@
 
-WINRT_EXPORT namespace winrt
+namespace winrt::impl
 {
-    template <typename Interface = Windows::Foundation::IActivationFactory>
-    impl::com_ref<Interface> get_activation_factory(param::hstring const& name)
+    struct library_traits
     {
-        void* result{};
-        hresult hr = WINRT_RoGetActivationFactory(*(void**)(&name), guid_of<Interface>(), &result);
+        using type = void*;
+
+        static void close(type value) noexcept
+        {
+            WINRT_FreeLibrary(value);
+        }
+
+        static constexpr type invalid() noexcept
+        {
+            return nullptr;
+        }
+    };
+
+    using library_handle = handle_type<library_traits>;
+
+    template <typename Interface>
+    hresult get_runtime_activation_factory(param::hstring const& name, void** result) noexcept
+    {
+        static int32_t(__stdcall * handler)(void* classId, guid const& iid, void** factory) noexcept;
+
+        impl::load_runtime_function("RoGetActivationFactory", handler,
+            [](void*, guid const&, void** factory) noexcept -> int32_t
+            {
+                *factory = nullptr;
+                return error_class_not_available;
+            });
+
+        hresult hr = handler(*(void**)(&name), guid_of<Interface>(), result);
 
         if (hr == impl::error_not_initialized)
         {
             void* cookie;
             WINRT_CoIncrementMTAUsage(&cookie);
-            hr = WINRT_RoGetActivationFactory(*(void**)(&name), guid_of<Interface>(), &result);
+            hr = handler(*(void**)(&name), guid_of<Interface>(), result);
+        }
+
+        if (hr == 0)
+        {
+            return 0;
+        }
+
+        std::wstring path{ static_cast<hstring const&>(name) };
+        std::size_t count{};
+
+        while (-1 != (count = path.rfind('.')))
+        {
+            path.resize(count);
+            path += L".dll";
+            library_handle library(WINRT_LoadLibraryW(path.c_str()));
+            path.resize(path.size() - 4);
+
+            if (!library)
+            {
+                continue;
+            }
+
+            auto library_call = reinterpret_cast<int32_t(__stdcall*)(void* classId, void** factory)>(WINRT_GetProcAddress(library.get(), "DllGetActivationFactory"));
+
+            if (!library_call)
+            {
+                continue;
+            }
+
+            com_ptr<abi_t<Windows::Foundation::IActivationFactory>> library_factory;
+
+            if (0 != library_call(*(void**)(&name), library_factory.put_void()))
+            {
+                continue;
+            }
+
+            if constexpr (std::is_same_v< Interface, Windows::Foundation::IActivationFactory>)
+            {
+                *result = library_factory.detach();
+                library.detach();
+                return 0;
+            }
+            else if (0 == library_factory.as(guid_of<Interface>(), result))
+            {
+                library.detach();
+                return 0;
+            }
         }
 
-        check_hresult(hr);
+        return error_class_not_available;
+    }
+}
+
+WINRT_EXPORT namespace winrt
+{
+    template <typename Interface = Windows::Foundation::IActivationFactory>
+    impl::com_ref<Interface> get_activation_factory(param::hstring const& name)
+    {
+        void* result{};
+        check_hresult(impl::get_runtime_activation_factory<Interface>(name, &result));
         return { result, take_ownership_from_abi };
     }
 }
@@ -304,11 +386,11 @@ namespace winrt::impl
     }
 
     template <typename Class, typename Interface = Windows::Foundation::IActivationFactory>
-    impl::com_ref<Interface> try_get_activation_factory(hresult_error* exception = nullptr) noexcept
+    com_ref<Interface> try_get_activation_factory(hresult_error* exception = nullptr) noexcept
     {
         param::hstring const name{ name_of<Class>() };
         void* result{};
-        hresult const hr = WINRT_RoGetActivationFactory(get_abi(name), guid_of<Interface>(), &result);
+        hresult const hr = get_runtime_activation_factory<Interface>(name, &result);
 
         if (hr < 0)
         {
@@ -342,13 +424,13 @@ WINRT_EXPORT namespace winrt
 {
     enum class apartment_type : int32_t
     {
-        single_threaded,
-        multi_threaded
+        multi_threaded = 0,
+        single_threaded = 2,
     };
 
     inline void init_apartment(apartment_type const type = apartment_type::multi_threaded)
     {
-        hresult const result = WINRT_RoInitialize(static_cast<uint32_t>(type));
+        hresult const result = WINRT_CoInitializeEx(nullptr, static_cast<uint32_t>(type));
 
         if (result < 0)
         {
@@ -358,7 +440,7 @@ WINRT_EXPORT namespace winrt
 
     inline void uninit_apartment() noexcept
     {
-        WINRT_RoUninitialize();
+        WINRT_CoUninitialize();
     }
 
     template <typename Class, typename Interface = Windows::Foundation::IActivationFactory>

strings/base_agile_ref.h

@@ -1,4 +1,158 @@
 
+WINRT_EXPORT namespace winrt
+{
+#if defined (WINRT_NO_MODULE_LOCK)
+
+    // Defining WINRT_NO_MODULE_LOCK is appropriate for apps (executables) that don't implement something like DllCanUnloadNow
+    // and can thus avoid the synchronization overhead imposed by the default module lock.
+
+    constexpr auto get_module_lock() noexcept
+    {
+        struct lock
+        {
+            constexpr uint32_t operator++() noexcept
+            {
+                return 1;
+            }
+
+            constexpr uint32_t operator--() noexcept
+            {
+                return 0;
+            }
+        };
+
+        return lock{};
+    }
+
+#elif defined (WINRT_CUSTOM_MODULE_LOCK)
+
+    // When WINRT_CUSTOM_MODULE_LOCK is defined, you must provide an implementation of winrt::get_module_lock()
+    // that returns an object that implements operator++ and operator--.
+
+#else
+
+    // This is the default implementation for use with DllCanUnloadNow.
+
+    inline impl::atomic_ref_count& get_module_lock() noexcept
+    {
+        static impl::atomic_ref_count s_lock;
+        return s_lock;
+    }
+
+#endif
+}
+
+namespace winrt::impl
+{
+    struct agile_ref_fallback final : IAgileReference
+    {
+        agile_ref_fallback(com_ptr<IGlobalInterfaceTable>&& git, uint32_t cookie) noexcept :
+            m_git(std::move(git)),
+            m_cookie(cookie)
+        {
+            ++get_module_lock();
+        }
+
+        ~agile_ref_fallback() noexcept
+        {
+            m_git->RevokeInterfaceFromGlobal(m_cookie);
+            --get_module_lock();
+        }
+
+        int32_t __stdcall QueryInterface(guid const& id, void** object) noexcept final
+        {
+            if (is_guid_of<IAgileReference>(id) || is_guid_of<Windows::Foundation::IUnknown>(id) || is_guid_of<IAgileObject>(id))
+            {
+                *object = static_cast<IAgileReference*>(this);
+                AddRef();
+                return 0;
+            }
+
+            *object = nullptr;
+            return error_no_interface;
+        }
+
+        uint32_t __stdcall AddRef() noexcept final
+        {
+            return ++m_references;
+        }
+
+        uint32_t __stdcall Release() noexcept final
+        {
+            auto const remaining = --m_references;
+
+            if (remaining == 0)
+            {
+                delete this;
+            }
+
+            return remaining;
+        }
+
+        int32_t __stdcall Resolve(guid const& id, void** object) noexcept final
+        {
+            return m_git->GetInterfaceFromGlobal(m_cookie, id, object);
+        }
+
+    private:
+
+        com_ptr<IGlobalInterfaceTable> m_git;
+        uint32_t m_cookie{};
+        atomic_ref_count m_references{ 1 };
+    };
+
+    template <typename F, typename L>
+    void load_runtime_function(char const* name, F& result, L fallback) noexcept
+    {
+        if (result)
+        {
+            return;
+        }
+
+        result = static_cast<F>(WINRT_GetProcAddress(WINRT_LoadLibraryW(L"combase.dll"), name));
+
+        if (result)
+        {
+            return;
+        }
+
+        result = fallback;
+    }
+
+    inline hresult get_agile_reference(winrt::guid const& iid, void* object, void** result) noexcept
+    {
+        static int32_t(__stdcall * handler)(uint32_t options, winrt::guid const& iid, void* object, void** result) noexcept;
+
+        load_runtime_function("RoGetAgileReference", handler,
+            [](uint32_t, winrt::guid const& iid, void* object, void** result) noexcept -> int32_t
+            {
+                *result = nullptr;
+                static constexpr guid git_clsid{ 0x00000323, 0x0000, 0x0000, { 0xC0,0x00,0x00,0x00,0x00,0x00,0x00,0x46 } };
+
+                com_ptr<IGlobalInterfaceTable> git;
+                hresult hr = WINRT_CoCreateInstance(git_clsid, nullptr, 1 /*CLSCTX_INPROC_SERVER*/, guid_of<IGlobalInterfaceTable>(), git.put_void());
+
+                if (result < 0)
+                {
+                    return hr;
+                }
+
+                uint32_t cookie{};
+                hr = git->RegisterInterfaceInGlobal(object, iid, &cookie);
+
+                if (result < 0)
+                {
+                    return hr;
+                }
+
+                *result = new agile_ref_fallback(std::move(git), cookie);
+                return 0;
+            });
+
+        return handler(0, iid, object, result);
+    }
+}
+
 WINRT_EXPORT namespace winrt
 {
     template <typename T>
@@ -10,7 +164,7 @@ WINRT_EXPORT namespace winrt
         {
             if (object)
             {
-                check_hresult(WINRT_RoGetAgileReference(0, guid_of<T>(), winrt::get_abi(object), m_ref.put_void()));
+                check_hresult(impl::get_agile_reference(guid_of<T>(), winrt::get_abi(object), m_ref.put_void()));
             }
         }