/**
* MIT License
*
* Copyright
(C
) 2016-2025 W
inToast v1
.3
.2 - Mohammed Boujemaoui <mohabouje@gmail
.com>
*
* Permission is hereby granted, free of charge, to any person obta
ining a copy of
* this software and associated documentation files
(the "Software"
), to deal
in
* the Software
without restriction,
includ
ing
without limitation the rights to
* use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
* the Software, and to permit persons to whom the Software is furnished to do so,
* subject to the follow
ing conditions
:
*
* The above copyright notice and this permission notice shall be
included
in all
* copies or substantial portions of the Software
.
*
* THE SOFTWARE IS PROVIDED "AS IS",
WITHOUT WARRANTY OF ANY K
IND, EXPRESS OR
* IMPLIED,
INCLUD
ING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
* FOR A PARTICULAR PURPOSE AND NON
INFR
INGEMENT
. IN NO EVENT SHALL THE AUTHORS OR
* COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
*
IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARIS
ING FROM, OUT OF OR
IN
* CONNECTION
WITH THE SOFTWARE OR THE USE OR OTHER DEAL
INGS
IN THE SOFTWARE
.
*/
#
include "w
intoastlib
.h"
#
include <memory>
#
include <assert
.h>
#
include <unordered_map>
#
include <array>
#
include <functional>
#pragma comment
(lib, "shlwapi"
)
#pragma comment
(lib, "user32"
)
#def
ine DEFAULT_SHELL_L
INKS_PATH L"\\
Microsoft\\W
indows\\Start Menu\\Programs\\"
#def
ine DEFAULT_L
INK_FORMAT L"
.lnk"
#def
ine STATUS_SUCCESS
(0x00000000
)
#ifdef NDEBUG
static bool DebugOutputEnabled = false;
#else
static bool DebugOutputEnabled = true;
#endif
#def
ine DEBUG_MSG
(str
) \
do { \
if
(DebugOutputEnabled
) { \
std
::wcout << str << std
::endl; \
} \
} while
(false
)
// Quickstart
: Handl
ing toast activations from W
in32 apps
in W
indows 10
// https
://blogs
.msdn
.microsoft.com/tiles_and_toasts/2015/10/16/quickstart-handl
ing-toast-activations-from-w
in32-apps-
in-w
indows-10/
us
ing
namespace W
inToastLib;
void W
inToastLib
::setDebugOutputEnabled
(bool enabled
) {
DebugOutputEnabled = enabled;
}
namespace DllImporter {
// Function load a function from library
template <type
name Function>
HRESULT loadFunctionFromLibrary
(H
INSTANCE library, LPCSTR
name, Function& func
) {
if
(!library
) {
return E_
INVALIDARG;
}
func = re
interpret_cast<Function>
(GetProcAddress
(library,
name));
return
(func != nullptr
) ? S_OK
: E_FAIL;
}
typedef HRESULT
(FAR STDAPICALLTYPE* f_SetCurrentProcessExplicitAppUserModelID
)(__
in PCWSTR AppID
);
typedef HRESULT
(FAR STDAPICALLTYPE* f_PropVariantToStr
ing
)(_
In_ REFPROPVARIANT propvar, _Out_writes_
(cch
) PWSTR psz, _
In_ U
INT cch
);
typedef HRESULT
(FAR STDAPICALLTYPE* f_RoGetActivationFactory
)(_
In_ HSTR
ING activatableClassId, _
In_ REFIID iid,
_COM_Outptr_ void** factory
);
typedef HRESULT
(FAR STDAPICALLTYPE* f_W
indowsCreateStr
ingReference
)(_
In_reads_opt_
(length + 1
) PCWSTR sourceStr
ing, U
INT32 length,
_Out_ HSTR
ING_HEADER* hstr
ingHeader,
_Outptr_result_maybenull_ _Result_nullonfailure_ HSTR
ING* str
ing
);
typedef PCWSTR
(FAR STDAPICALLTYPE* f_W
indowsGetStr
ingRawBuffer
)(_
In_ HSTR
ING str
ing, _Out_opt_ U
INT32* length
);
typedef HRESULT
(FAR STDAPICALLTYPE* f_W
indowsDeleteStr
ing
)(_
In_opt_ HSTR
ING str
ing
);
static f_SetCurrentProcessExplicitAppUserModelID SetCurrentProcessExplicitAppUserModelID;
static f_PropVariantToStr
ing PropVariantToStr
ing;
static f_RoGetActivationFactory RoGetActivationFactory;
static f_W
indowsCreateStr
ingReference W
indowsCreateStr
ingReference;
static f_W
indowsGetStr
ingRawBuffer W
indowsGetStr
ingRawBuffer;
static f_W
indowsDeleteStr
ing W
indowsDeleteStr
ing;
template <class T>
__
inl
ine _Check_return_ HRESULT _1_GetActivationFactory
(_
In_ HSTR
ING activatableClassId, _COM_Outptr_ T** factory
) {
return RoGetActivationFactory
(activatableClassId, IID_
INS_ARGS
(factory
));
}
template <type
name T>
inl
ine HRESULT Wrap_GetActivationFactory
(_
In_ HSTR
ING activatableClassId, _
Inout_ Details
::ComPtrRef<T> factory
) noexcept {
return _1_GetActivationFactory
(activatableClassId, factory
.ReleaseAndGetAddressOf
());
}
inl
ine HRESULT
initialize
() {
H
INSTANCE LibShell32 = LoadLibraryW
(L"SHELL32
.DLL"
);
HRESULT hr =
loadFunctionFromLibrary
(LibShell32, "SetCurrentProcessExplicitAppUserModelID", SetCurrentProcessExplicitAppUserModelID
);
if
(SUCCEEDED
(hr
)) {
H
INSTANCE LibPropSys = LoadLibraryW
(L"PROPSYS
.DLL"
);
hr = loadFunctionFromLibrary
(LibPropSys, "PropVariantToStr
ing", PropVariantToStr
ing
);
if
(SUCCEEDED
(hr
)) {
H
INSTANCE LibComBase = LoadLibraryW
(L"COMBASE
.DLL"
);
bool const succeded =
SUCCEEDED
(loadFunctionFromLibrary
(LibComBase, "RoGetActivationFactory", RoGetActivationFactory
)) &&
SUCCEEDED
(loadFunctionFromLibrary
(LibComBase, "W
indowsCreateStr
ingReference", W
indowsCreateStr
ingReference
)) &&
SUCCEEDED
(loadFunctionFromLibrary
(LibComBase, "W
indowsGetStr
ingRawBuffer", W
indowsGetStr
ingRawBuffer
)) &&
SUCCEEDED
(loadFunctionFromLibrary
(LibComBase, "W
indowsDeleteStr
ing", W
indowsDeleteStr
ing
));
return succeded ? S_OK
: E_FAIL;
}
}
return hr;
}
} //
namespace DllImporter
class W
inToastStr
ingWrapper {
public
:
W
inToastStr
ingWrapper
(_
In_reads_
(length
) PCWSTR str
ingRef, _
In_ U
INT32 length
) {
HRESULT hr = DllImporter
::W
indowsCreateStr
ingReference
(str
ingRef, length, &_header, &_hstr
ing
);
if
(!SUCCEEDED
(hr
)) {
RaiseException
(static_cast<DWORD>
(STATUS_
INVALID_PARAMETER
), 0, 0, nullptr
);
}
}
W
inToastStr
ingWrapper
(_
In_ std
::wstr
ing const& str
ingRef
) {
HRESULT hr =
DllImporter
::W
indowsCreateStr
ingReference
(str
ingRef
.c_str
(), static_cast<U
INT32>
(str
ingRef
.length
()), &_header, &_hstr
ing
);
if
(FAILED
(hr
)) {
RaiseException
(static_cast<DWORD>
(STATUS_
INVALID_PARAMETER
), 0, 0, nullptr
);
}
}
~W
inToastStr
ingWrapper
() {
DllImporter
::W
indowsDeleteStr
ing
(_hstr
ing
);
}
inl
ine HSTR
ING Get
() const noexcept {
return _hstr
ing;
}
private
:
HSTR
ING _hstr
ing;
HSTR
ING_HEADER _header;
};
class
InternalDateTime
: public IReference<DateTime> {
public
:
static
INT64 Now
() {
FILETIME now;
GetSystemTimeAsFileTime
(&now
);
return
((((INT64
) now
.dwHighDateTime
) << 32
) | now
.dwLowDateTime
);
}
InternalDateTime
(DateTime dateTime
) : _dateTime
(dateTime
) {}
InternalDateTime
(INT64 millisecondsFromNow
) {
_dateTime
.UniversalTime = Now
() + millisecondsFromNow * 10000;
}
virtual ~
InternalDateTime
() = default;
operator
INT64
() {
return _dateTime
.UniversalTime;
}
HRESULT STDMETHODCALLTYPE get_Value
(DateTime* dateTime
) {
*dateTime = _dateTime;
return S_OK;
}
HRESULT STDMETHODCALLTYPE Query
Interface
(const IID& riid, void** ppvObject
) {
if
(!ppvObject
) {
return E_PO
INTER;
}
if
(riid == __uuidof
(I
Unknown) || riid == __uuidof
(IReference<DateTime>
)) {
*ppvObject = static_cast<I
Unknown*>
(static_cast<IReference<DateTime>*>
(this
));
return S_OK;
}
return E_NO
INTERFACE;
}
ULONG STDMETHODCALLTYPE Release
() {
return 1;
}
ULONG STDMETHODCALLTYPE AddRef
() {
return 2;
}
HRESULT STDMETHODCALLTYPE GetIids
(ULONG*, IID**
) {
return E_NOTIMPL;
}
HRESULT STDMETHODCALLTYPE GetRuntimeClass
Name(HSTR
ING*
) {
return E_NOTIMPL;
}
HRESULT STDMETHODCALLTYPE GetTrustLevel
(TrustLevel*
) {
return E_NOTIMPL;
}
protected
:
DateTime _dateTime;
};
namespace Util {
typedef LONG NTSTATUS, *PNTSTATUS;
typedef NTSTATUS
(W
INAPI* RtlGetVersionPtr
)(PRTL_OSVERSION
INFOW
);
inl
ine RTL_OSVERSION
INFOW getRealOSVersion
() {
HMODULE hMod =
::GetModuleHandleW
(L"ntdll
.dll"
);
if
(hMod
) {
RtlGetVersionPtr fxPtr =
(RtlGetVersionPtr
)::GetProcAddress
(hMod, "RtlGetVersion"
);
if
(fxPtr != nullptr
) {
RTL_OSVERSION
INFOW rovi = {0};
rovi
.dwOSVersion
InfoSize = sizeof
(rovi
);
if
(STATUS_SUCCESS == fxPtr
(&rovi
)) {
return rovi;
}
}
}
RTL_OSVERSION
INFOW rovi = {0};
return rovi;
}
inl
ine HRESULT defaultExecutablePath
(_
In_ WCHAR* path, _
In_ DWORD nSize = MAX_PATH
) {
DWORD written = GetModuleFile
NameExW
(GetCurrentProcess
(), nullptr, path, nSize
);
DEBUG_MSG
("Default executable path
: " << path
);
return
(written > 0
) ? S_OK
: E_FAIL;
}
inl
ine HRESULT defaultShellL
inksDirectory
(_
In_ WCHAR* path, _
In_ DWORD nSize = MAX_PATH
) {
DWORD written = GetEnvironmentVariableW
(L"APPDATA", path, nSize
);
HRESULT hr = written > 0 ? S_OK
: E_
INVALIDARG;
if
(SUCCEEDED
(hr
)) {
errno_t result = wcscat_s
(path, nSize, DEFAULT_SHELL_L
INKS_PATH
);
hr =
(result == 0
) ? S_OK
: E_
INVALIDARG;
DEBUG_MSG
("Default shell l
ink path
: " << path
);
}
return hr;
}
inl
ine HRESULT defaultShellL
inkPath
(_
In_ std
::wstr
ing const& app
name, _
In_ WCHAR* path, _
In_ DWORD nSize = MAX_PATH
) {
HRESULT hr = defaultShellL
inksDirectory
(path, nSize
);
if
(SUCCEEDED
(hr
)) {
std
::wstr
ing const appL
ink
(app
name + DEFAULT_L
INK_FORMAT
);
errno_t result = wcscat_s
(path, nSize, appL
ink
.c_str
());
hr =
(result == 0
) ? S_OK
: E_
INVALIDARG;
DEBUG_MSG
("Default shell l
ink file path
: " << path
);
}
return hr;
}
inl
ine std
::wstr
ing parentDirectory
(WCHAR* path, DWORD size
) {
size_t lastSeparator = 0;
for
(size_t i = 0; i < size; i++
) {
if
(path[i] == L'\\' || path[i] == L'/'
) {
lastSeparator = i;
}
}
return {path, lastSeparator};
}
inl
ine PCWSTR AsStr
ing
(_
In_ ComPtr<IXmlDocument>& xmlDocument
) {
HSTR
ING xml;
ComPtr<IXmlNodeSerializer> ser;
HRESULT hr = xmlDocument
.As<IXmlNodeSerializer>
(&ser
);
hr = ser->GetXml
(&xml
);
if
(SUCCEEDED
(hr
)) {
return DllImporter
::W
indowsGetStr
ingRawBuffer
(xml, nullptr
);
}
return nullptr;
}
inl
ine PCWSTR AsStr
ing
(_
In_ HSTR
ING hstr
ing
) {
return DllImporter
::W
indowsGetStr
ingRawBuffer
(hstr
ing, nullptr
);
}
inl
ine HRESULT setNodeStr
ingValue
(_
In_ std
::wstr
ing const& str
ing, _Out_opt_ IXmlNode* node, _Out_ IXmlDocument* xml
) {
ComPtr<IXmlText> textNode;
HRESULT hr = xml->CreateTextNode
(W
inToastStr
ingWrapper
(str
ing
).Get
(), &textNode
);
if
(SUCCEEDED
(hr
)) {
ComPtr<IXmlNode> str
ingNode;
hr = textNode
.As
(&str
ingNode
);
if
(SUCCEEDED
(hr
)) {
ComPtr<IXmlNode> appendedChild;
hr = node->AppendChild
(str
ingNode
.Get
(), &appendedChild
);
}
}
return hr;
}
template <type
name FunctorT>
inl
ine HRESULT setEventHandlers
(_
In_ IToastNotification* notification, _
In_ std
::shared_ptr<IW
inToastHandler> eventHandler,
_
In_
INT64 expirationTime, _Out_ EventRegistrationToken& activatedToken,
_Out_ EventRegistrationToken& dismissedToken, _Out_ EventRegistrationToken& failedToken,
_
In_ FunctorT&& markAsReadyForDeletionFunc
) {
HRESULT hr = notification->add_Activated
(
Callback<Implements<RuntimeClassFlags<ClassicCom>, ITypedEventHandler<ToastNotification*, I
Inspectable*>>>
(
[eventHandler, markAsReadyForDeletionFunc]
(IToastNotification* notify, I
Inspectable*
inspectable
) {
ComPtr<IToastActivatedEventArgs> activatedEventArgs;
HRESULT hr =
inspectable->Query
Interface
(activatedEventArgs
.GetAddressOf
());
if
(SUCCEEDED
(hr
)) {
HSTR
ING argumentsHandle;
hr = activatedEventArgs->get_Arguments
(&argumentsHandle
);
if
(SUCCEEDED
(hr
)) {
PCWSTR arguments = Util
::AsStr
ing
(argumentsHandle
);
if
(wcscmp
(arguments, L"action=reply"
) == 0
) {
ComPtr<IToastActivatedEventArgs2>
inputBoxActivatedEventArgs;
HRESULT hr2 =
inspectable->Query
Interface
(inputBoxActivatedEventArgs
.GetAddressOf
());
if
(SUCCEEDED
(hr2
)) {
ComPtr<Collections
::IPropertySet> replyHandle;
inputBoxActivatedEventArgs->get_User
Input
(&replyHandle
);
ComPtr<__FIMap_2_HSTR
ING_I
Inspectable> replyMap;
hr = replyHandle
.As
(&replyMap
);
if
(SUCCEEDED
(hr
)) {
I
Inspectable* propertySet;
hr = replyMap
.Get
()->Lookup
(W
inToastStr
ingWrapper
(L"textBox"
).Get
(), &propertySet
);
if
(SUCCEEDED
(hr
)) {
ComPtr<IPropertyValue> propertyValue;
hr = propertySet->Query
Interface
(IID_PPV_ARGS
(&propertyValue
));
if
(SUCCEEDED
(hr
)) {
// Successfully queried IPropertyValue, now extract the value
HSTR
ING user
Input;
hr = propertyValue->GetStr
ing
(&user
Input
);
if
(SUCCEEDED
(hr
)) {
// Convert the HSTR
ING to a wide str
ing
PCWSTR strValue = Util
::AsStr
ing
(user
Input
);
eventHandler->toastActivated
(std
::wstr
ing
(strValue
));
DllImporter
::W
indowsDeleteStr
ing
(user
Input
);
return S_OK;
}
if
(user
Input != nullptr
) {
DllImporter
::W
indowsDeleteStr
ing
(user
Input
);
}
}
}
}
}
}
if
(arguments && *arguments
) {
eventHandler->toastActivated
(static_cast<long>
(wcstol
(arguments, nullptr, 10
)));
DllImporter
::W
indowsDeleteStr
ing
(argumentsHandle
);
markAsReadyForDeletionFunc
();
return S_OK;
}
DllImporter
::W
indowsDeleteStr
ing
(argumentsHandle
);
}
}
eventHandler->toastActivated
();
markAsReadyForDeletionFunc
();
return S_OK;
}
)
.Get
(),
&activatedToken
);
if
(SUCCEEDED
(hr
)) {
hr = notification->add_Dismissed
(
Callback<Implements<RuntimeClassFlags<ClassicCom>, ITypedEventHandler<ToastNotification*, ToastDismissedEventArgs*>>>
(
[eventHandler, expirationTime, markAsReadyForDeletionFunc]
(IToastNotification* notify, IToastDismissedEventArgs* e
) {
ToastDismissalReason reason;
if
(SUCCEEDED
(e->get_Reason
(&reason
))) {
if
(reason == ToastDismissalReason_UserCanceled && expirationTime &&
InternalDateTime
::Now
() >= expirationTime
) {
reason = ToastDismissalReason_TimedOut;
}
eventHandler->toastDismissed
(static_cast<IW
inToastHandler
::W
inToastDismissalReason>
(reason
));
}
markAsReadyForDeletionFunc
();
return S_OK;
}
)
.Get
(),
&dismissedToken
);
if
(SUCCEEDED
(hr
)) {
hr = notification->add_Failed
(
Callback<Implements<RuntimeClassFlags<ClassicCom>, ITypedEventHandler<ToastNotification*, ToastFailedEventArgs*>>>
(
[eventHandler, markAsReadyForDeletionFunc]
(IToastNotification* notify, IToastFailedEventArgs* e
) {
eventHandler->toastFailed
();
markAsReadyForDeletionFunc
();
return S_OK;
}
)
.Get
(),
&failedToken
);
}
}
return hr;
}
inl
ine HRESULT addAttribute
(_
In_ IXmlDocument* xml, std
::wstr
ing const&
name, IXml
NamedNodeMap* attributeMap
) {
ComPtr<ABI
::W
indows
::Data
::Xml
::Dom
::IXmlAttribute> srcAttribute;
HRESULT hr = xml->CreateAttribute
(W
inToastStr
ingWrapper
(name).Get
(), &srcAttribute
);
if
(SUCCEEDED
(hr
)) {
ComPtr<IXmlNode> node;
hr = srcAttribute
.As
(&node
);
if
(SUCCEEDED
(hr
)) {
ComPtr<IXmlNode> pNode;
hr = attributeMap->Set
NamedItem
(node
.Get
(), &pNode
);
}
}
return hr;
}
inl
ine HRESULT create
Element(_
In_ IXmlDocument* xml, _
In_ std
::wstr
ing const& root_node, _
In_ std
::wstr
ing const&
element_
name,
_
In_ std
::vector<std
::wstr
ing> const& attribute_
names
) {
ComPtr<IXmlNodeList> rootList;
HRESULT hr = xml->Get
ElementsByTag
Name(W
inToastStr
ingWrapper
(root_node
).Get
(), &rootList
);
if
(SUCCEEDED
(hr
)) {
ComPtr<IXmlNode> root;
hr = rootList->Item
(0, &root
);
if
(SUCCEEDED
(hr
)) {
ComPtr<ABI
::W
indows
::Data
::Xml
::Dom
::IXml
Element> audio
Element;
hr = xml->Create
Element(W
inToastStr
ingWrapper
(element_
name).Get
(), &audio
Element);
if
(SUCCEEDED
(hr
)) {
ComPtr<IXmlNode> audioNodeTmp;
hr = audio
Element.As
(&audioNodeTmp
);
if
(SUCCEEDED
(hr
)) {
ComPtr<IXmlNode> audioNode;
hr = root->AppendChild
(audioNodeTmp
.Get
(), &audioNode
);
if
(SUCCEEDED
(hr
)) {
ComPtr<IXml
NamedNodeMap> attributes;
hr = audioNode->get_Attributes
(&attributes
);
if
(SUCCEEDED
(hr
)) {
for
(auto const& it
: attribute_
names
) {
hr = addAttribute
(xml, it, attributes
.Get
());
}
}
}
}
}
}
}
return hr;
}
} //
namespace Util
W
inToast* W
inToast
::instance
() {
thread_local static W
inToast
instance;
return &
instance;
}
W
inToast
::W
inToast
() : _is
Initialized
(false
), _hasCo
Initialized
(false
) {
if
(!isCompatible
()) {
DEBUG_MSG
(L"Warn
ing
: Your system is not compatible
with this library "
);
}
}
W
inToast
::~W
inToast
() {
clear
();
if
(_hasCo
Initialized
) {
CoUn
initialize
();
}
}
void W
inToast
::setApp
Name(_
In_ std
::wstr
ing const& app
Name) {
_app
Name = app
Name;
}
void W
inToast
::setAppUserModelId
(_
In_ std
::wstr
ing const& aumi
) {
_aumi = aumi;
DEBUG_MSG
(L"Default App User Model Id
: " << _aumi
.c_str
());
}
void W
inToast
::setShortcutPolicy
(_
In_ ShortcutPolicy shortcutPolicy
) {
_shortcutPolicy = shortcutPolicy;
}
bool W
inToast
::isCompatible
() {
DllImporter
::initialize
();
return !
((DllImporter
::SetCurrentProcessExplicitAppUserModelID == nullptr
) ||
(DllImporter
::PropVariantToStr
ing == nullptr
) ||
(DllImporter
::RoGetActivationFactory == nullptr
) ||
(DllImporter
::W
indowsCreateStr
ingReference == nullptr
) ||
(DllImporter
::W
indowsDeleteStr
ing == nullptr
));
}
bool W
inToastLib
::W
inToast
::isSupport
ingModernFeatures
() {
constexpr auto M
inimumSupportedVersion = 6;
return Util
::getRealOSVersion
().dwMajorVersion > M
inimumSupportedVersion;
}
bool W
inToastLib
::W
inToast
::isW
in10AnniversaryOrHigher
() {
return Util
::getRealOSVersion
().dwBuildNumber >= 14393;
}
std
::wstr
ing W
inToast
::configureAUMI
(_
In_ std
::wstr
ing const& company
Name, _
In_ std
::wstr
ing const& product
Name,
_
In_ std
::wstr
ing const& subProduct, _
In_ std
::wstr
ing const& version
Information
) {
std
::wstr
ing aumi = company
Name;
aumi += L"
." + product
Name;
if
(subProduct
.length
() > 0
) {
aumi += L"
." + subProduct;
if
(version
Information
.length
() > 0
) {
aumi += L"
." + version
Information;
}
}
if
(aumi
.length
() > SCHAR_MAX
) {
DEBUG_MSG
("
Error: max size allowed for AUMI
: 128 characters
."
);
}
return aumi;
}
std
::wstr
ing const& W
inToast
::str
error(W
inToast
Error error) {
static std
::unordered_map<W
inToast
Error, std
::wstr
ing> const Labels = {
{W
inToast
Error::No
Error, L"No
error. The process was executed correctly" },
{W
inToast
Error::Not
Initialized, L"The library has not been
initialized" },
{W
inToast
Error::SystemNotSupported, L"The OS does not support W
inToast" },
{W
inToast
Error::ShellL
inkNotCreated, L"The library was not able to create a Shell L
ink for the app" },
{W
inToast
Error::InvalidAppUserModelID, L"The AUMI is not a valid one" },
{W
inToast
Error::InvalidParameters, L"
Invalid parameters, please double-check the AUMI or App
Name" },
{W
inToast
Error::NotDisplayed, L"The toast was created correctly but W
inToast was not able to display the toast"},
{W
inToast
Error::UnknownError, L"
Unknown error" }
};
auto const iter = Labels
.f
ind
(error);
assert
(iter != Labels
.end
());
return iter->second;
}
enum W
inToast
::ShortcutResult W
inToast
::createShortcut
() {
if
(_aumi
.empty
() || _app
Name.empty
()) {
DEBUG_MSG
(L"
Error: App User Model Id or App
name is empty!"
);
return SHORTCUT_MISS
ING_PARAMETERS;
}
if
(!isCompatible
()) {
DEBUG_MSG
(L"Your OS is not compatible
with this library! =
("
);
return SHORTCUT_
INCOMPATIBLE_OS;
}
if
(!_hasCo
Initialized
) {
HRESULT
initHr = Co
InitializeEx
(nullptr, CO
INIT
::CO
INIT_MULTITHREADED
);
if
(initHr != RPC_E_CHANGED_MODE
) {
if
(FAILED
(initHr
) &&
initHr != S_FALSE
) {
DEBUG_MSG
(L"
Error on COM library
initialization!"
);
return SHORTCUT_COM_
INIT_FAILURE;
} else {
_hasCo
Initialized = true;
}
}
}
bool wasChanged;
HRESULT hr = validateShellL
inkHelper
(wasChanged
);
if
(SUCCEEDED
(hr
)) {
return wasChanged ? SHORTCUT_WAS_CHANGED
: SHORTCUT_UNCHANGED;
}
hr = createShellL
inkHelper
();
return SUCCEEDED
(hr
) ? SHORTCUT_WAS_CREATED
: SHORTCUT_CREATE_FAILED;
}
bool W
inToast
::initialize
(_Out_opt_ W
inToast
Error*
error) {
_is
Initialized = false;
set
Error(error, W
inToast
Error::No
Error);
if
(!isCompatible
()) {
set
Error(error, W
inToast
Error::SystemNotSupported
);
DEBUG_MSG
(L"
Error: system not supported
."
);
return false;
}
if
(_aumi
.empty
() || _app
Name.empty
()) {
set
Error(error, W
inToast
Error::InvalidParameters
);
DEBUG_MSG
(L"
Error while
initializ
ing, did you set up a valid AUMI and App
name?"
);
return false;
}
if
(_shortcutPolicy != SHORTCUT_POLICY_IGNORE
) {
if
(createShortcut
() < 0
) {
set
Error(error, W
inToast
Error::ShellL
inkNotCreated
);
DEBUG_MSG
(L"
Error while attach
ing the AUMI to the current proccess =
("
);
return false;
}
}
if
(FAILED
(DllImporter
::SetCurrentProcessExplicitAppUserModelID
(_aumi
.c_str
()))) {
set
Error(error, W
inToast
Error::InvalidAppUserModelID
);
DEBUG_MSG
(L"
Error while attach
ing the AUMI to the current proccess =
("
);
return false;
}
_is
Initialized = true;
return _is
Initialized;
}
bool W
inToast
::is
Initialized
() const {
return _is
Initialized;
}
std
::wstr
ing const& W
inToast
::app
Name() const {
return _app
Name;
}
std
::wstr
ing const& W
inToast
::appUserModelId
() const {
return _aumi;
}
HRESULT W
inToast
::validateShellL
inkHelper
(_Out_ bool& wasChanged
) {
WCHAR path[MAX_PATH] = {L'\0'};
Util
::defaultShellL
inkPath
(_app
Name, path
);
// Check if the file exist
DWORD attr = GetFileAttributesW
(path
);
if
(attr >= 0xFFFFFFF
) {
DEBUG_MSG
("
Error, shell l
ink not
found. Try to create a new one
in: " << path
);
return E_FAIL;
}
// Let's load the file as shell l
ink to validate
.
// - Create a shell l
ink
// - Create a persistant file
// - Load the path as data for the persistant file
// - Read the property AUMI and validate
with the current
// - Review if AUMI is equal
.
ComPtr<IShellL
ink> shellL
ink;
HRESULT hr = CoCreate
Instance
(CLSID_ShellL
ink, nullptr, CLSCTX_
INPROC_SERVER, IID_PPV_ARGS
(&shellL
ink
));
if
(SUCCEEDED
(hr
)) {
ComPtr<IPersistFile> persistFile;
hr = shellL
ink
.As
(&persistFile
);
if
(SUCCEEDED
(hr
)) {
hr = persistFile->Load
(path, STGM_READWRITE
);
if
(SUCCEEDED
(hr
)) {
ComPtr<IPropertyStore> propertyStore;
hr = shellL
ink
.As
(&propertyStore
);
if
(SUCCEEDED
(hr
)) {
PROPVARIANT appIdPropVar;
hr = propertyStore->GetValue
(PKEY_AppUserModel_ID, &appIdPropVar
);
if
(SUCCEEDED
(hr
)) {
WCHAR AUMI[MAX_PATH];
hr = DllImporter
::PropVariantToStr
ing
(appIdPropVar, AUMI, MAX_PATH
);
wasChanged = false;
if
(FAILED
(hr
) || _aumi != AUMI
) {
if
(_shortcutPolicy == SHORTCUT_POLICY_REQUIRE_CREATE
) {
// AUMI Changed for the same app, let's update the current value! =
)
wasChanged = true;
PropVariantClear
(&appIdPropVar
);
hr =
InitPropVariantFromStr
ing
(_aumi
.c_str
(), &appIdPropVar
);
if
(SUCCEEDED
(hr
)) {
hr = propertyStore->SetValue
(PKEY_AppUserModel_ID, appIdPropVar
);
if
(SUCCEEDED
(hr
)) {
hr = propertyStore->Commit
();
if
(SUCCEEDED
(hr
) && SUCCEEDED
(persistFile->IsDirty
())) {
hr = persistFile->Save
(path, TRUE
);
}
}
}
} else {
// Not allowed to touch the shortcut to fix the AUMI
hr = E_FAIL;
}
}
PropVariantClear
(&appIdPropVar
);
}
}
}
}
}
return hr;
}
HRESULT W
inToast
::createShellL
inkHelper
() {
if
(_shortcutPolicy != SHORTCUT_POLICY_REQUIRE_CREATE
) {
return E_FAIL;
}
WCHAR exePath[MAX_PATH]{L'\0'};
WCHAR slPath[MAX_PATH]{L'\0'};
Util
::defaultShellL
inkPath
(_app
Name, slPath
);
Util
::defaultExecutablePath
(exePath
);
std
::wstr
ing exeDir = Util
::parentDirectory
(exePath, sizeof
(exePath
) / sizeof
(exePath[0]
));
ComPtr<IShellL
inkW> shellL
ink;
HRESULT hr = CoCreate
Instance
(CLSID_ShellL
ink, nullptr, CLSCTX_
INPROC_SERVER, IID_PPV_ARGS
(&shellL
ink
));
if
(SUCCEEDED
(hr
)) {
hr = shellL
ink->SetPath
(exePath
);
if
(SUCCEEDED
(hr
)) {
hr = shellL
ink->SetArguments
(L""
);
if
(SUCCEEDED
(hr
)) {
hr = shellL
ink->SetWork
ingDirectory
(exeDir
.c_str
());
if
(SUCCEEDED
(hr
)) {
ComPtr<IPropertyStore> propertyStore;
hr = shellL
ink
.As
(&propertyStore
);
if
(SUCCEEDED
(hr
)) {
PROPVARIANT appIdPropVar;
hr =
InitPropVariantFromStr
ing
(_aumi
.c_str
(), &appIdPropVar
);
if
(SUCCEEDED
(hr
)) {
hr = propertyStore->SetValue
(PKEY_AppUserModel_ID, appIdPropVar
);
if
(SUCCEEDED
(hr
)) {
hr = propertyStore->Commit
();
if
(SUCCEEDED
(hr
)) {
ComPtr<IPersistFile> persistFile;
hr = shellL
ink
.As
(&persistFile
);
if
(SUCCEEDED
(hr
)) {
hr = persistFile->Save
(slPath, TRUE
);
}
}
}
PropVariantClear
(&appIdPropVar
);
}
}
}
}
}
}
return hr;
}
INT64 W
inToast
::showToast
(_
In_ W
inToastTemplate const& toast, _
In_ IW
inToastHandler* eventHandler, _Out_ W
inToast
Error*
error) {
std
::shared_ptr<IW
inToastHandler> handler
(eventHandler
);
set
Error(error, W
inToast
Error::No
Error);
INT64 id = -1;
if
(!is
Initialized
()) {
set
Error(error, W
inToast
Error::Not
Initialized
);
DEBUG_MSG
("
Error when launch
ing the toast
. W
inToast is not
initialized
."
);
return id;
}
if
(!handler
) {
set
Error(error, W
inToast
Error::InvalidHandler
);
DEBUG_MSG
("
Error when launch
ing the toast
. Handler cannot be nullptr
."
);
return id;
}
ComPtr<IToastNotificationManagerStatics> notificationManager;
HRESULT hr = DllImporter
::Wrap_GetActivationFactory
(
W
inToastStr
ingWrapper
(RuntimeClass_W
indows_UI_Notifications_ToastNotificationManager
).Get
(), ¬ificationManager
);
if
(SUCCEEDED
(hr
)) {
ComPtr<IToastNotifier> notifier;
hr = notificationManager->CreateToastNotifier
WithId
(W
inToastStr
ingWrapper
(_aumi
).Get
(), ¬ifier
);
if
(SUCCEEDED
(hr
)) {
ComPtr<IToastNotificationFactory> notificationFactory;
hr = DllImporter
::Wrap_GetActivationFactory
(
W
inToastStr
ingWrapper
(RuntimeClass_W
indows_UI_Notifications_ToastNotification
).Get
(), ¬ificationFactory
);
if
(SUCCEEDED
(hr
)) {
ComPtr<IXmlDocument> xmlDocument;
hr = notificationManager->GetTemplateContent
(ToastTemplateType
(toast
.type
()), &xmlDocument
);
if
(SUCCEEDED
(hr
) && toast
.isToastGeneric
()) {
hr = setB
indToastGenericHelper
(xmlDocument
.Get
());
}
if
(SUCCEEDED
(hr
)) {
for
(U
INT32 i = 0, fieldsCount = static_cast<U
INT32>
(toast
.textFieldsCount
()); i < fieldsCount && SUCCEEDED
(hr
); i++
) {
hr = setTextFieldHelper
(xmlDocument
.Get
(), toast
.textField
(W
inToastTemplate
::TextField
(i
)), i
);
}
// Modern feature are supported W
indows > W
indows 10
if
(SUCCEEDED
(hr
) && isSupport
ingModernFeatures
()) {
// Note that we do this *after* us
ing toast
.textFieldsCount
() to
// iterate/fill the template's text fields, s
ince we're add
ing yet another text field
.
if
(SUCCEEDED
(hr
) && !toast
.attributionText
().empty
()) {
hr = setAttributionTextFieldHelper
(xmlDocument
.Get
(), toast
.attributionText
());
}
std
::array<WCHAR, 12> buf;
for
(std
::size_t i = 0, actionsCount = toast
.actionsCount
(); i < actionsCount && SUCCEEDED
(hr
); i++
) {
_snwpr
intf_s
(buf
.data
(), buf
.size
(), _TRUNCATE, L"%zd", i
);
hr = addActionHelper
(xmlDocument
.Get
(), toast
.actionLabel
(i
), buf
.data
());
}
if
(SUCCEEDED
(hr
)) {
hr =
(toast
.audioPath
().empty
() && toast
.audioOption
() == W
inToastTemplate
::AudioOption
::Default
)
? hr
: setAudioFieldHelper
(xmlDocument
.Get
(), toast
.audioPath
(), toast
.audioOption
());
}
if
(SUCCEEDED
(hr
) && toast
.duration
() != W
inToastTemplate
::Duration
::System
) {
hr = addDurationHelper
(xmlDocument
.Get
(),
(toast
.duration
() == W
inToastTemplate
::Duration
::Short
) ? L"short"
: L"long"
);
}
if
(SUCCEEDED
(hr
) && toast
.is
Input
()) {
hr = add
InputHelper
(xmlDocument
.Get
());
}
if
(SUCCEEDED
(hr
)) {
hr = addScenarioHelper
(xmlDocument
.Get
(), toast
.scenario
());
}
} else {
DEBUG_MSG
("Modern features
(Actions/Sounds/Attributes
) not supported
in this os version"
);
}
if
(SUCCEEDED
(hr
)) {
bool isW
in10AnniversaryOrAbove = W
inToast
::isW
in10AnniversaryOrHigher
();
bool isCircleCropH
int = isW
in10AnniversaryOrAbove ? toast
.isCropH
intCircle
() : false;
hr = toast
.hasImage
()
? setImageFieldHelper
(xmlDocument
.Get
(), toast
.imagePath
(), toast
.isToastGeneric
(), isCircleCropH
int
)
: hr;
if
(SUCCEEDED
(hr
) && isW
in10AnniversaryOrAbove && toast
.hasHeroImage
()) {
hr = setHeroImageHelper
(xmlDocument
.Get
(), toast
.heroImagePath
(), toast
.is
Inl
ineHeroImage
());
}
if
(SUCCEEDED
(hr
)) {
ComPtr<IToastNotification> notification;
hr = notificationFactory->CreateToastNotification
(xmlDocument
.Get
(), ¬ification
);
if
(SUCCEEDED
(hr
)) {
INT64 expiration = 0, relativeExpiration = toast
.expiration
();
if
(relativeExpiration > 0
) {
InternalDateTime expirationDateTime
(relativeExpiration
);
expiration = expirationDateTime;
hr = notification->put_ExpirationTime
(&expirationDateTime
);
}
EventRegistrationToken activatedToken, dismissedToken, failedToken;
GUID guid;
HRESULT hrGuid = CoCreateGuid
(&guid
);
id = guid
.Data1;
if
(SUCCEEDED
(hr
) && SUCCEEDED
(hrGuid
)) {
hr = Util
::setEventHandlers
(notification
.Get
(), handler, expiration, activatedToken, dismissedToken,
failedToken, [this, id]
() { markAsReadyForDeletion
(id
); }
);
if
(FAILED
(hr
)) {
set
Error(error, W
inToast
Error::InvalidHandler
);
}
}
if
(SUCCEEDED
(hr
)) {
if
(SUCCEEDED
(hr
)) {
std
::lock_guard<std
::mutex> lock
(m_mutex
);
_buffer
.emplace
(id, NotifyData
(notification, activatedToken, dismissedToken, failedToken
));
DEBUG_MSG
("xml
: " << Util
::AsStr
ing
(xmlDocument
));
hr = notifier->Show
(notification
.Get
());
if
(FAILED
(hr
)) {
set
Error(error, W
inToast
Error::NotDisplayed
);
}
}
}
}
}
}
}
}
}
}
return FAILED
(hr
) ? -1
: id;
}
ComPtr<IToastNotifier> W
inToast
::notifier
(_
In_ bool* succeded
) const {
ComPtr<IToastNotificationManagerStatics> notificationManager;
ComPtr<IToastNotifier> notifier;
HRESULT hr = DllImporter
::Wrap_GetActivationFactory
(
W
inToastStr
ingWrapper
(RuntimeClass_W
indows_UI_Notifications_ToastNotificationManager
).Get
(), ¬ificationManager
);
if
(SUCCEEDED
(hr
)) {
hr = notificationManager->CreateToastNotifier
WithId
(W
inToastStr
ingWrapper
(_aumi
).Get
(), ¬ifier
);
}
*succeded = SUCCEEDED
(hr
);
return notifier;
}
void W
inToast
::markAsReadyForDeletion
(_
In_
INT64 id
) {
std
::lock_guard<std
::mutex> lock
(m_mutex
);
// Flush the buffer by remov
ing all the toasts that are ready for deletion
for
(auto it = _buffer
.beg
in(); it != _buffer
.end
();
) {
if
(it->second
.isReadyForDeletion
()) {
it->second
.RemoveTokens
();
it = _buffer
.erase
(it
);
} else {
++it;
}
}
// Mark the toast as ready for deletion
(if it exists
) so that it will be removed from the buffer
in the next iteration
auto const iter = _buffer
.f
ind
(id
);
if
(iter != _buffer
.end
()) {
_buffer[id]
.markAsReadyForDeletion
();
}
}
bool W
inToast
::hideToast
(_
In_
INT64 id
) {
std
::lock_guard<std
::mutex> lock
(m_mutex
);
if
(!is
Initialized
()) {
DEBUG_MSG
("
Error when hid
ing the toast
. W
inToast is not
initialized
."
);
return false;
}
auto iter = _buffer
.f
ind
(id
);
if
(iter == _buffer
.end
()) {
return false;
}
auto succeded = false;
auto notify = notifier
(&succeded
);
if
(!succeded
) {
return false;
}
auto& notifyData = iter->second;
auto result = notify->Hide
(notifyData
.notification
());
if
(FAILED
(result
)) {
DEBUG_MSG
("
Error when hid
ing the toast
. Error code
: " << result
);
return false;
}
notifyData
.RemoveTokens
();
_buffer
.erase
(iter
);
return SUCCEEDED
(result
);
}
void W
inToast
::clear
() {
auto succeded = false;
auto notify = notifier
(&succeded
);
if
(!succeded
) {
return;
}
std
::lock_guard<std
::mutex> lock
(m_mutex
);
auto safeCopy = _buffer;
for
(auto& data
: safeCopy
) {
auto& notifyData = data
.second;
notify->Hide
(notifyData
.notification
());
notifyData
.RemoveTokens
();
}
_buffer
.clear
();
}
//
// Available as of W
indows 10 Anniversary Update
// Ref
: https
://docs
.microsoft.com/en-us/w
indows/uwp/design/shell/tiles-and-notifications/adaptive-
interactive-toasts
//
// NOTE
: This will add a new text field, so be aware when iterat
ing over
// the toast's text fields or gett
ing a count of them
.
//
HRESULT W
inToast
::setAttributionTextFieldHelper
(_
In_ IXmlDocument* xml, _
In_ std
::wstr
ing const& text
) {
Util
::create
Element(xml, L"b
ind
ing", L"text", {L"placement"}
);
ComPtr<IXmlNodeList> nodeList;
HRESULT hr = xml->Get
ElementsByTag
Name(W
inToastStr
ingWrapper
(L"text"
).Get
(), &nodeList
);
if
(SUCCEEDED
(hr
)) {
U
INT32 nodeListLength;
hr = nodeList->get_Length
(&nodeListLength
);
if
(SUCCEEDED
(hr
)) {
for
(U
INT32 i = 0; i < nodeListLength; i++
) {
ComPtr<IXmlNode> textNode;
hr = nodeList->Item
(i, &textNode
);
if
(SUCCEEDED
(hr
)) {
ComPtr<IXml
NamedNodeMap> attributes;
hr = textNode->get_Attributes
(&attributes
);
if
(SUCCEEDED
(hr
)) {
ComPtr<IXmlNode> editedNode;
if
(SUCCEEDED
(hr
)) {
hr = attributes->Get
NamedItem
(W
inToastStr
ingWrapper
(L"placement"
).Get
(), &editedNode
);
if
(FAILED
(hr
) || !editedNode
) {
cont
inue;
}
hr = Util
::setNodeStr
ingValue
(L"attribution", editedNode
.Get
(), xml
);
if
(SUCCEEDED
(hr
)) {
return setTextFieldHelper
(xml, text, i
);
}
}
}
}
}
}
}
return hr;
}
HRESULT W
inToast
::addDurationHelper
(_
In_ IXmlDocument* xml, _
In_ std
::wstr
ing const& duration
) {
ComPtr<IXmlNodeList> nodeList;
HRESULT hr = xml->Get
ElementsByTag
Name(W
inToastStr
ingWrapper
(L"toast"
).Get
(), &nodeList
);
if
(SUCCEEDED
(hr
)) {
U
INT32 length;
hr = nodeList->get_Length
(&length
);
if
(SUCCEEDED
(hr
)) {
ComPtr<IXmlNode> toastNode;
hr = nodeList->Item
(0, &toastNode
);
if
(SUCCEEDED
(hr
)) {
ComPtr<IXml
Element> toast
Element;
hr = toastNode
.As
(&toast
Element);
if
(SUCCEEDED
(hr
)) {
hr = toast
Element->SetAttribute
(W
inToastStr
ingWrapper
(L"duration"
).Get
(), W
inToastStr
ingWrapper
(duration
).Get
());
}
}
}
}
return hr;
}
HRESULT W
inToast
::addScenarioHelper
(_
In_ IXmlDocument* xml, _
In_ std
::wstr
ing const& scenario
) {
ComPtr<IXmlNodeList> nodeList;
HRESULT hr = xml->Get
ElementsByTag
Name(W
inToastStr
ingWrapper
(L"toast"
).Get
(), &nodeList
);
if
(SUCCEEDED
(hr
)) {
U
INT32 length;
hr = nodeList->get_Length
(&length
);
if
(SUCCEEDED
(hr
)) {
ComPtr<IXmlNode> toastNode;
hr = nodeList->Item
(0, &toastNode
);
if
(SUCCEEDED
(hr
)) {
ComPtr<IXml
Element> toast
Element;
hr = toastNode
.As
(&toast
Element);
if
(SUCCEEDED
(hr
)) {
hr = toast
Element->SetAttribute
(W
inToastStr
ingWrapper
(L"scenario"
).Get
(), W
inToastStr
ingWrapper
(scenario
).Get
());
}
}
}
}
return hr;
}
HRESULT W
inToast
::add
InputHelper
(_
In_ IXmlDocument* xml
) {
std
::vector<std
::wstr
ing> attrbs;
attrbs
.push_back
(L"id"
);
attrbs
.push_back
(L"type"
);
attrbs
.push_back
(L"placeHolderContent"
);
std
::vector<std
::wstr
ing> attrbs2;
attrbs2
.push_back
(L"content"
);
attrbs2
.push_back
(L"arguments"
);
Util
::create
Element(xml, L"toast", L"actions", {}
);
Util
::create
Element(xml, L"actions", L"
input", attrbs
);
Util
::create
Element(xml, L"actions", L"action", attrbs2
);
ComPtr<IXmlNodeList> nodeList;
HRESULT hr = xml->Get
ElementsByTag
Name(W
inToastStr
ingWrapper
(L"
input"
).Get
(), &nodeList
);
if
(SUCCEEDED
(hr
)) {
ComPtr<IXmlNode>
inputNode;
hr = nodeList->Item
(0, &
inputNode
);
if
(SUCCEEDED
(hr
)) {
ComPtr<IXml
Element> toast
Element;
hr =
inputNode
.As
(&toast
Element);
if
(SUCCEEDED
(hr
)) {
toast
Element->SetAttribute
(W
inToastStr
ingWrapper
(L"id"
).Get
(), W
inToastStr
ingWrapper
(L"textBox"
).Get
());
toast
Element->SetAttribute
(W
inToastStr
ingWrapper
(L"type"
).Get
(), W
inToastStr
ingWrapper
(L"text"
).Get
());
hr = toast
Element->SetAttribute
(W
inToastStr
ingWrapper
(L"placeHolderContent"
).Get
(), W
inToastStr
ingWrapper
(L"
..."
).Get
());
}
}
}
ComPtr<IXmlNodeList> nodeList2;
hr = xml->Get
ElementsByTag
Name(W
inToastStr
ingWrapper
(L"action"
).Get
(), &nodeList2
);
if
(SUCCEEDED
(hr
)) {
ComPtr<IXmlNode> actionNode;
hr = nodeList2->Item
(0, &actionNode
);
if
(SUCCEEDED
(hr
)) {
ComPtr<IXml
Element> action
Element;
hr = actionNode
.As
(&action
Element);
if
(SUCCEEDED
(hr
)) {
action
Element->SetAttribute
(W
inToastStr
ingWrapper
(L"content"
).Get
(), W
inToastStr
ingWrapper
(L"Reply"
).Get
());
action
Element->SetAttribute
(W
inToastStr
ingWrapper
(L"arguments"
).Get
(), W
inToastStr
ingWrapper
(L"action=reply"
).Get
());
action
Element->SetAttribute
(W
inToastStr
ingWrapper
(L"h
int-
inputId"
).Get
(), W
inToastStr
ingWrapper
(L"textBox"
).Get
());
}
}
}
return hr;
}
HRESULT W
inToast
::setTextFieldHelper
(_
In_ IXmlDocument* xml, _
In_ std
::wstr
ing const& text, _
In_ U
INT32 pos
) {
ComPtr<IXmlNodeList> nodeList;
HRESULT hr = xml->Get
ElementsByTag
Name(W
inToastStr
ingWrapper
(L"text"
).Get
(), &nodeList
);
if
(SUCCEEDED
(hr
)) {
ComPtr<IXmlNode> node;
hr = nodeList->Item
(pos, &node
);
if
(SUCCEEDED
(hr
)) {
hr = Util
::setNodeStr
ingValue
(text, node
.Get
(), xml
);
}
}
return hr;
}
HRESULT W
inToast
::setB
indToastGenericHelper
(_
In_ IXmlDocument* xml
) {
ComPtr<IXmlNodeList> nodeList;
HRESULT hr = xml->Get
ElementsByTag
Name(W
inToastStr
ingWrapper
(L"b
ind
ing"
).Get
(), &nodeList
);
if
(SUCCEEDED
(hr
)) {
U
INT32 length;
hr = nodeList->get_Length
(&length
);
if
(SUCCEEDED
(hr
)) {
ComPtr<IXmlNode> toastNode;
hr = nodeList->Item
(0, &toastNode
);
if
(SUCCEEDED
(hr
)) {
ComPtr<IXml
Element> toast
Element;
hr = toastNode
.As
(&toast
Element);
if
(SUCCEEDED
(hr
)) {
hr = toast
Element->SetAttribute
(W
inToastStr
ingWrapper
(L"template"
).Get
(), W
inToastStr
ingWrapper
(L"ToastGeneric"
).Get
());
}
}
}
}
return hr;
}
HRESULT W
inToast
::setImageFieldHelper
(_
In_ IXmlDocument* xml, _
In_ std
::wstr
ing const& path, _
In_ bool isToastGeneric,
_
In_ bool isCropH
intCircle
) {
assert
(path
.size
() < MAX_PATH
);
wchar_t imagePath[MAX_PATH] = L"file
:///";
HRESULT hr = Str
ingCchCatW
(imagePath, MAX_PATH, path
.c_str
());
if
(SUCCEEDED
(hr
)) {
ComPtr<IXmlNodeList> nodeList;
HRESULT hr = xml->Get
ElementsByTag
Name(W
inToastStr
ingWrapper
(L"image"
).Get
(), &nodeList
);
if
(SUCCEEDED
(hr
)) {
ComPtr<IXmlNode> node;
hr = nodeList->Item
(0, &node
);
ComPtr<IXml
Element> image
Element;
HRESULT hrImage = node
.As
(&image
Element);
if
(SUCCEEDED
(hr
) && SUCCEEDED
(hrImage
) && isToastGeneric
) {
hr = image
Element->SetAttribute
(W
inToastStr
ingWrapper
(L"placement"
).Get
(), W
inToastStr
ingWrapper
(L"appLogoOverride"
).Get
());
if
(SUCCEEDED
(hr
) && isCropH
intCircle
) {
hr = image
Element->SetAttribute
(W
inToastStr
ingWrapper
(L"h
int-crop"
).Get
(), W
inToastStr
ingWrapper
(L"circle"
).Get
());
}
}
if
(SUCCEEDED
(hr
)) {
ComPtr<IXml
NamedNodeMap> attributes;
hr = node->get_Attributes
(&attributes
);
if
(SUCCEEDED
(hr
)) {
ComPtr<IXmlNode> editedNode;
hr = attributes->Get
NamedItem
(W
inToastStr
ingWrapper
(L"src"
).Get
(), &editedNode
);
if
(SUCCEEDED
(hr
)) {
Util
::setNodeStr
ingValue
(imagePath, editedNode
.Get
(), xml
);
}
}
}
}
}
return hr;
}
HRESULT W
inToast
::setAudioFieldHelper
(_
In_ IXmlDocument* xml, _
In_ std
::wstr
ing const& path,
_
In_opt_ W
inToastTemplate
::AudioOption option
) {
std
::vector<std
::wstr
ing> attrs;
if
(!path
.empty
()) {
attrs
.push_back
(L"src"
);
}
if
(option == W
inToastTemplate
::AudioOption
::Loop
) {
attrs
.push_back
(L"loop"
);
}
if
(option == W
inToastTemplate
::AudioOption
::Silent
) {
attrs
.push_back
(L"silent"
);
}
Util
::create
Element(xml, L"toast", L"audio", attrs
);
ComPtr<IXmlNodeList> nodeList;
HRESULT hr = xml->Get
ElementsByTag
Name(W
inToastStr
ingWrapper
(L"audio"
).Get
(), &nodeList
);
if
(SUCCEEDED
(hr
)) {
ComPtr<IXmlNode> node;
hr = nodeList->Item
(0, &node
);
if
(SUCCEEDED
(hr
)) {
ComPtr<IXml
NamedNodeMap> attributes;
hr = node->get_Attributes
(&attributes
);
if
(SUCCEEDED
(hr
)) {
ComPtr<IXmlNode> editedNode;
if
(!path
.empty
()) {
if
(SUCCEEDED
(hr
)) {
hr = attributes->Get
NamedItem
(W
inToastStr
ingWrapper
(L"src"
).Get
(), &editedNode
);
if
(SUCCEEDED
(hr
)) {
hr = Util
::setNodeStr
ingValue
(path, editedNode
.Get
(), xml
);
}
}
}
if
(SUCCEEDED
(hr
)) {
switch
(option
) {
case W
inToastTemplate
::AudioOption
::Loop
:
hr = attributes->Get
NamedItem
(W
inToastStr
ingWrapper
(L"loop"
).Get
(), &editedNode
);
if
(SUCCEEDED
(hr
)) {
hr = Util
::setNodeStr
ingValue
(L"true", editedNode
.Get
(), xml
);
}
break;
case W
inToastTemplate
::AudioOption
::Silent
:
hr = attributes->Get
NamedItem
(W
inToastStr
ingWrapper
(L"silent"
).Get
(), &editedNode
);
if
(SUCCEEDED
(hr
)) {
hr = Util
::setNodeStr
ingValue
(L"true", editedNode
.Get
(), xml
);
}
default
:
break;
}
}
}
}
}
return hr;
}
HRESULT W
inToast
::addActionHelper
(_
In_ IXmlDocument* xml, _
In_ std
::wstr
ing const& content, _
In_ std
::wstr
ing const& arguments
) {
ComPtr<IXmlNodeList> nodeList;
HRESULT hr = xml->Get
ElementsByTag
Name(W
inToastStr
ingWrapper
(L"actions"
).Get
(), &nodeList
);
if
(SUCCEEDED
(hr
)) {
U
INT32 length;
hr = nodeList->get_Length
(&length
);
if
(SUCCEEDED
(hr
)) {
ComPtr<IXmlNode> actionsNode;
if
(length > 0
) {
hr = nodeList->Item
(0, &actionsNode
);
} else {
hr = xml->Get
ElementsByTag
Name(W
inToastStr
ingWrapper
(L"toast"
).Get
(), &nodeList
);
if
(SUCCEEDED
(hr
)) {
hr = nodeList->get_Length
(&length
);
if
(SUCCEEDED
(hr
)) {
ComPtr<IXmlNode> toastNode;
hr = nodeList->Item
(0, &toastNode
);
if
(SUCCEEDED
(hr
)) {
ComPtr<IXml
Element> toast
Element;
hr = toastNode
.As
(&toast
Element);
if
(SUCCEEDED
(hr
)) {
hr = toast
Element->SetAttribute
(W
inToastStr
ingWrapper
(L"template"
).Get
(),
W
inToastStr
ingWrapper
(L"ToastGeneric"
).Get
());
}
if
(SUCCEEDED
(hr
)) {
hr = toast
Element->SetAttribute
(W
inToastStr
ingWrapper
(L"duration"
).Get
(),
W
inToastStr
ingWrapper
(L"long"
).Get
());
}
if
(SUCCEEDED
(hr
)) {
ComPtr<IXml
Element> actions
Element;
hr = xml->Create
Element(W
inToastStr
ingWrapper
(L"actions"
).Get
(), &actions
Element);
if
(SUCCEEDED
(hr
)) {
hr = actions
Element.As
(&actionsNode
);
if
(SUCCEEDED
(hr
)) {
ComPtr<IXmlNode> appendedChild;
hr = toastNode->AppendChild
(actionsNode
.Get
(), &appendedChild
);
}
}
}
}
}
}
}
if
(SUCCEEDED
(hr
)) {
ComPtr<IXml
Element> action
Element;
hr = xml->Create
Element(W
inToastStr
ingWrapper
(L"action"
).Get
(), &action
Element);
if
(SUCCEEDED
(hr
)) {
hr = action
Element->SetAttribute
(W
inToastStr
ingWrapper
(L"content"
).Get
(), W
inToastStr
ingWrapper
(content
).Get
());
}
if
(SUCCEEDED
(hr
)) {
hr = action
Element->SetAttribute
(W
inToastStr
ingWrapper
(L"arguments"
).Get
(), W
inToastStr
ingWrapper
(arguments
).Get
());
}
if
(SUCCEEDED
(hr
)) {
ComPtr<IXmlNode> actionNode;
hr = action
Element.As
(&actionNode
);
if
(SUCCEEDED
(hr
)) {
ComPtr<IXmlNode> appendedChild;
hr = actionsNode->AppendChild
(actionNode
.Get
(), &appendedChild
);
}
}
}
}
}
return hr;
}
HRESULT W
inToast
::setHeroImageHelper
(_
In_ IXmlDocument* xml, _
In_ std
::wstr
ing const& path, _
In_ bool is
Inl
ineImage
) {
ComPtr<IXmlNodeList> nodeList;
HRESULT hr = xml->Get
ElementsByTag
Name(W
inToastStr
ingWrapper
(L"b
ind
ing"
).Get
(), &nodeList
);
if
(SUCCEEDED
(hr
)) {
U
INT32 length;
hr = nodeList->get_Length
(&length
);
if
(SUCCEEDED
(hr
)) {
ComPtr<IXmlNode> b
ind
ingNode;
if
(length > 0
) {
hr = nodeList->Item
(0, &b
ind
ingNode
);
}
if
(SUCCEEDED
(hr
)) {
ComPtr<IXml
Element> image
Element;
hr = xml->Create
Element(W
inToastStr
ingWrapper
(L"image"
).Get
(), &image
Element);
if
(SUCCEEDED
(hr
) && is
Inl
ineImage == false
) {
hr = image
Element->SetAttribute
(W
inToastStr
ingWrapper
(L"placement"
).Get
(), W
inToastStr
ingWrapper
(L"hero"
).Get
());
}
if
(SUCCEEDED
(hr
)) {
hr = image
Element->SetAttribute
(W
inToastStr
ingWrapper
(L"src"
).Get
(), W
inToastStr
ingWrapper
(path
).Get
());
}
if
(SUCCEEDED
(hr
)) {
ComPtr<IXmlNode> actionNode;
hr = image
Element.As
(&actionNode
);
if
(SUCCEEDED
(hr
)) {
ComPtr<IXmlNode> appendedChild;
hr = b
ind
ingNode->AppendChild
(actionNode
.Get
(), &appendedChild
);
}
}
}
}
}
return hr;
}
void W
inToast
::set
Error(_Out_opt_ W
inToast
Error*
error, _
In_ W
inToast
Error value
) {
if
(error) {
*
error = value;
}
}
W
inToastTemplate
::W
inToastTemplate
(_
In_ W
inToastTemplateType type
) : _type
(type
) {
constexpr static std
::size_t TextFieldsCount[] = {1, 2, 2, 3, 1, 2, 2, 3};
_textFields = std
::vector<std
::wstr
ing>
(TextFieldsCount[type], L""
);
}
W
inToastTemplate
::~W
inToastTemplate
() {
_textFields
.clear
();
}
void W
inToastTemplate
::setTextField
(_
In_ std
::wstr
ing const& txt, _
In_ W
inToastTemplate
::TextField pos
) {
auto const position = static_cast<std
::size_t>
(pos
);
if
(position >= _textFields
.size
()) {
DEBUG_MSG
("The selected template type supports only " << _textFields
.size
() << " text l
ines"
);
return;
}
_textFields[position] = txt;
}
void W
inToastTemplate
::setImagePath
(_
In_ std
::wstr
ing const& imgPath, _
In_ CropH
int cropH
int
) {
_imagePath = imgPath;
_cropH
int = cropH
int;
}
void W
inToastTemplate
::setHeroImagePath
(_
In_ std
::wstr
ing const& imgPath, _
In_ bool
inl
ineImage
) {
_heroImagePath = imgPath;
_
inl
ineHeroImage =
inl
ineImage;
}
void W
inToastTemplate
::setAudioPath
(_
In_ std
::wstr
ing const& audioPath
) {
_audioPath = audioPath;
}
void W
inToastTemplate
::setAudioPath
(_
In_ AudioSystemFile file
) {
static std
::unordered_map<AudioSystemFile, std
::wstr
ing> const Files = {
{AudioSystemFile
::DefaultSound, L"ms-w
insoundevent
:Notification
.Default" },
{AudioSystemFile
::IM, L"ms-w
insoundevent
:Notification
.IM" },
{AudioSystemFile
::Mail, L"ms-w
insoundevent
:Notification
.Mail" },
{AudioSystemFile
::Rem
inder, L"ms-w
insoundevent
:Notification
.Rem
inder" },
{AudioSystemFile
::SMS, L"ms-w
insoundevent
:Notification
.SMS" },
{AudioSystemFile
::Alarm, L"ms-w
insoundevent
:Notification
.Loop
ing
.Alarm" },
{AudioSystemFile
::Alarm2, L"ms-w
insoundevent
:Notification
.Loop
ing
.Alarm2" },
{AudioSystemFile
::Alarm3, L"ms-w
insoundevent
:Notification
.Loop
ing
.Alarm3" },
{AudioSystemFile
::Alarm4, L"ms-w
insoundevent
:Notification
.Loop
ing
.Alarm4" },
{AudioSystemFile
::Alarm5, L"ms-w
insoundevent
:Notification
.Loop
ing
.Alarm5" },
{AudioSystemFile
::Alarm6, L"ms-w
insoundevent
:Notification
.Loop
ing
.Alarm6" },
{AudioSystemFile
::Alarm7, L"ms-w
insoundevent
:Notification
.Loop
ing
.Alarm7" },
{AudioSystemFile
::Alarm8, L"ms-w
insoundevent
:Notification
.Loop
ing
.Alarm8" },
{AudioSystemFile
::Alarm9, L"ms-w
insoundevent
:Notification
.Loop
ing
.Alarm9" },
{AudioSystemFile
::Alarm10, L"ms-w
insoundevent
:Notification
.Loop
ing
.Alarm10"},
{AudioSystemFile
::Call, L"ms-w
insoundevent
:Notification
.Loop
ing
.Call" },
{AudioSystemFile
::Call1, L"ms-w
insoundevent
:Notification
.Loop
ing
.Call1" },
{AudioSystemFile
::Call2, L"ms-w
insoundevent
:Notification
.Loop
ing
.Call2" },
{AudioSystemFile
::Call3, L"ms-w
insoundevent
:Notification
.Loop
ing
.Call3" },
{AudioSystemFile
::Call4, L"ms-w
insoundevent
:Notification
.Loop
ing
.Call4" },
{AudioSystemFile
::Call5, L"ms-w
insoundevent
:Notification
.Loop
ing
.Call5" },
{AudioSystemFile
::Call6, L"ms-w
insoundevent
:Notification
.Loop
ing
.Call6" },
{AudioSystemFile
::Call7, L"ms-w
insoundevent
:Notification
.Loop
ing
.Call7" },
{AudioSystemFile
::Call8, L"ms-w
insoundevent
:Notification
.Loop
ing
.Call8" },
{AudioSystemFile
::Call9, L"ms-w
insoundevent
:Notification
.Loop
ing
.Call9" },
{AudioSystemFile
::Call10, L"ms-w
insoundevent
:Notification
.Loop
ing
.Call10" },
};
auto const iter = Files
.f
ind
(file
);
assert
(iter != Files
.end
());
_audioPath = iter->second;
}
void W
inToastTemplate
::setAudioOption
(_
In_ W
inToastTemplate
::AudioOption audioOption
) {
_audioOption = audioOption;
}
void W
inToastTemplate
::setFirstL
ine
(_
In_ std
::wstr
ing const& text
) {
setTextField
(text, W
inToastTemplate
::FirstL
ine
);
}
void W
inToastTemplate
::setSecondL
ine
(_
In_ std
::wstr
ing const& text
) {
setTextField
(text, W
inToastTemplate
::SecondL
ine
);
}
void W
inToastTemplate
::setThirdL
ine
(_
In_ std
::wstr
ing const& text
) {
setTextField
(text, W
inToastTemplate
::ThirdL
ine
);
}
void W
inToastTemplate
::setDuration
(_
In_ Duration duration
) {
_duration = duration;
}
void W
inToastTemplate
::setExpiration
(_
In_
INT64 millisecondsFromNow
) {
_expiration = millisecondsFromNow;
}
void W
inToastLib
::W
inToastTemplate
::setScenario
(_
In_ Scenario scenario
) {
switch
(scenario
) {
case Scenario
::Default
:
_scenario = L"Default";
break;
case Scenario
::Alarm
:
_scenario = L"Alarm";
break;
case Scenario
::Incom
ingCall
:
_scenario = L"
Incom
ingCall";
break;
case Scenario
::Rem
inder
:
_scenario = L"Rem
inder";
break;
}
}
void W
inToastTemplate
::setAttributionText
(_
In_ std
::wstr
ing const& attributionText
) {
_attributionText = attributionText;
}
void W
inToastTemplate
::addAction
(_
In_ std
::wstr
ing const& label
) {
_actions
.push_back
(label
);
}
void W
inToastTemplate
::add
Input
() {
_has
Input = true;
}
std
::size_t W
inToastTemplate
::textFieldsCount
() const {
return _textFields
.size
();
}
std
::size_t W
inToastTemplate
::actionsCount
() const {
return _actions
.size
();
}
bool W
inToastTemplate
::hasImage
() const {
return _type < W
inToastTemplateType
::Text01;
}
bool W
inToastTemplate
::hasHeroImage
() const {
return hasImage
() && !_heroImagePath
.empty
();
}
std
::vector<std
::wstr
ing> const& W
inToastTemplate
::textFields
() const {
return _textFields;
}
std
::wstr
ing const& W
inToastTemplate
::textField
(_
In_ TextField pos
) const {
auto const position = static_cast<std
::size_t>
(pos
);
assert
(position < _textFields
.size
());
return _textFields[position];
}
std
::wstr
ing const& W
inToastTemplate
::actionLabel
(_
In_ std
::size_t position
) const {
assert
(position < _actions
.size
());
return _actions[position];
}
std
::wstr
ing const& W
inToastTemplate
::imagePath
() const {
return _imagePath;
}
std
::wstr
ing const& W
inToastTemplate
::heroImagePath
() const {
return _heroImagePath;
}
std
::wstr
ing const& W
inToastTemplate
::audioPath
() const {
return _audioPath;
}
std
::wstr
ing const& W
inToastTemplate
::attributionText
() const {
return _attributionText;
}
std
::wstr
ing const& W
inToastLib
::W
inToastTemplate
::scenario
() const {
return _scenario;
}
INT64 W
inToastTemplate
::expiration
() const {
return _expiration;
}
W
inToastTemplate
::W
inToastTemplateType W
inToastTemplate
::type
() const {
return _type;
}
W
inToastTemplate
::AudioOption W
inToastTemplate
::audioOption
() const {
return _audioOption;
}
W
inToastTemplate
::Duration W
inToastTemplate
::duration
() const {
return _duration;
}
bool W
inToastTemplate
::isToastGeneric
() const {
return hasHeroImage
() || _cropH
int == W
inToastTemplate
::Circle;
}
bool W
inToastTemplate
::is
Inl
ineHeroImage
() const {
return _
inl
ineHeroImage;
}
bool W
inToastTemplate
::isCropH
intCircle
() const {
return _cropH
int == CropH
int
::Circle;
}
bool W
inToastTemplate
::is
Input
() const {
return _has
Input;
}
基于上述源码，新增锁屏时系统弹窗不显示在锁屏之上逻辑
博客介绍了Android studio中出现‘Error: unknown element found’错误的解决方法，即在gradle.properties文件中添加相关内容，还给出了参考博客链接。
扫一扫
3278
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
