mirrors/electron
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages 1 Wiki Activity Actions 2

Windows Toasts: Icons, Events, Cleanup, Documentation

Browse source 
- Enable documentations
- Add a small usage example to the header
- Final cleanups
This commit is contained in:
Felix Rieseberg 2015-11-07 19:41:29 -08:00
parent 498bff9e5a
commit 86ea0759d8
4 changed files with 107 additions and 304 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

24
brightray/browser/win/notification_presenter_win.cc
View file

@ -1,30 +1,26 @@
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Copyright (c) 2013 Patrick Reynolds <piki@github.com>. All rights reserved.
// Copyright (c) 2015 Felix Rieseberg <feriese@microsoft.com> and Jason Poon <jpoon@microsoft.com>. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE-CHROMIUM file.
#include "browser/win/notification_presenter_win.h"
#include "base/bind.h"
#include "base/logging.h"
#include "base/files/file_enumerator.h"
#include "base/strings/string_util.h"
#include "base/strings/utf_string_conversions.h"
#include "base/win/windows_version.h"
#include "content/public/browser/desktop_notification_delegate.h"
#include "content/public/common/platform_notification_data.h"
#include "third_party/skia/include/core/SkBitmap.h"
#include "common/application_info.h"
#include <stdlib.h>
#include <stdio.h>
#include <vector>
#include "third_party/skia/include/core/SkBitmap.h"
#include "base/win/windows_version.h"
// Windows Header
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#include <wrl/client.h>
#include <windows.ui.notifications.h>
#include <wrl/client.h>
#include <wrl/implements.h>
#include <winstring.h>
#include "windows_toast_notification.h"
@ -58,18 +54,20 @@ void NotificationPresenterWin::ShowNotification(
base::Closure* cancel_callback) {
std::wstring title = data.title;
std::wstring body = data.body;
std::wstring body = data.body;
std::string iconPath = data.icon.spec();
std::string appName = GetApplicationName();
char* img = NULL;
WinToasts::WindowsToastNotification* wtn = new WinToasts::WindowsToastNotification(appName.c_str());
wtn->ShowNotification(title.c_str(), body.c_str(), img);
WinToasts::WindowsToastNotification* wtn = new WinToasts::WindowsToastNotification(appName.c_str(), delegate_ptr.release());
wtn->ShowNotification(title.c_str(), body.c_str(), iconPath);
}
void NotificationPresenterWin::CancelNotification() {
// No can do.
}
void NotificationPresenterWin::DeleteNotification() {
// No can do.
}
} // namespace brightray

13
brightray/browser/win/notification_presenter_win.h
View file

@ -1,8 +1,19 @@
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Copyright (c) 2013 Patrick Reynolds <piki@github.com>. All rights reserved.
// Copyright (c) 2015 Felix Rieseberg <feriese@microsoft.com> and Jason Poon <jpoon@microsoft.com>. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE-CHROMIUM file.
// Usage Example (JavaScript:
// var windowsNotification = new Notification("Test Title", {
// body: "Hi, I'm an example body. How are you?",
// icon: "file:///C:/Path/To/Your/Image.png"
// });
// windowsNotification.onshow = function () { console.log("Notification shown") };
// windowsNotification.onclick = function () { console.log("Notification clicked") };
// windowsNotification.onclose = function () { console.log("Notification dismissed") };
#ifndef BRIGHTRAY_BROWSER_NOTIFICATION_PRESENTER_WIN_H_
#define BRIGHTRAY_BROWSER_NOTIFICATION_PRESENTER_WIN_H_

340
brightray/browser/win/windows_toast_notification.cc
View file

@ -1,53 +1,47 @@
// Copyright (c) 2015 Felix Rieseberg <feriese@microsoft.com>. All rights reserved.
// Copyright (c) 2015 Felix Rieseberg <feriese@microsoft.com> and Jason Poon <jpoon@microsoft.com>. All rights reserved.
// Copyright (c) 2015 Ryan McShane <rmcshane@bandwidth.com> and Brandon Smith <bsmith@bandwidth.com>
// Thanks to both of those folks mentioned above who first thought up a bunch of this code
// and released it as MIT to the world.
#include "windows_toast_notification.h"
#include "content/public/browser/desktop_notification_delegate.h"
#include <Psapi.h>
#include <stdio.h>
#include <ShObjidl.h>
#include <propvarutil.h>
#include <propkey.h>
#include <wincrypt.h>
#include <string>
using namespace WinToasts;
using namespace Windows::Foundation;
#define BREAK_IF_BAD(hr) if(!SUCCEEDED(hr)) break;
#define SHORTCUT_FORMAT "\\Microsoft\\Windows\\Start Menu\\Programs\\%s.lnk"
char WindowsToastNotification::s_appName[MAX_PATH] = {};
char WindowsToastNotification::s_tempDirPath[MAX_PATH] = {};
namespace WinToasts {
WindowsToastNotification::WindowsToastNotification(const char* appName)
WindowsToastNotification::WindowsToastNotification(const char* appName, content::DesktopNotificationDelegate* delegate)
{
sprintf_s(s_appName, ARRAYSIZE(s_appName), "%s", appName);
m_eventHandler = NULL;
m_tempFilePath = NULL;
n_delegate = delegate;
}
WindowsToastNotification::~WindowsToastNotification()
{
if (m_eventHandler){
if (m_eventHandler) {
delete m_eventHandler;
}
if (m_tempFilePath){
DeleteTempImageFile();
delete m_tempFilePath;
if (n_delegate) {
delete n_delegate;
}
}
/*static*/ void WindowsToastNotification::InitSystemProps(char* appName, char* tempDirPath)
{
sprintf_s(s_tempDirPath, ARRAYSIZE(s_tempDirPath), "%s", tempDirPath);
}
void WindowsToastNotification::ShowNotification(const WCHAR* title, const WCHAR* msg, const char* img)
void WindowsToastNotification::ShowNotification(const WCHAR* title, const WCHAR* msg, std::string iconPath)
{
// Init using WRL
Windows::Foundation::Initialize(RO_INIT_MULTITHREADED);
@ -55,14 +49,10 @@ void WindowsToastNotification::ShowNotification(const WCHAR* title, const WCHAR*
HSTRING toastNotifMgrStr = NULL;
HSTRING appId = NULL;
HSTRING toastNotifStr = NULL;
// Create a shortcut in the user's app data folder
// (requirement for Windows 8 to show notifications - Windows 10 is fine without it)
// TODO: This shoudl be cleaned up
// HRESULT hr = EnsureShortcut();
HRESULT hr;
do{
HRESULT hr = CreateHString(RuntimeClass_Windows_UI_Notifications_ToastNotificationManager, &toastNotifMgrStr);
do {
hr = CreateHString(RuntimeClass_Windows_UI_Notifications_ToastNotificationManager, &toastNotifMgrStr);
BREAK_IF_BAD(hr);
ComPtr<IToastNotificationManagerStatics> toastMgr;
@ -70,7 +60,7 @@ void WindowsToastNotification::ShowNotification(const WCHAR* title, const WCHAR*
BREAK_IF_BAD(hr);
ComPtr<IXmlDocument> toastXml;
hr = GetToastXml(toastMgr.Get(), title, msg, img, &toastXml);
hr = GetToastXml(toastMgr.Get(), title, msg, iconPath, &toastXml);
BREAK_IF_BAD(hr);
WCHAR wAppName[MAX_PATH];
@ -99,52 +89,48 @@ void WindowsToastNotification::ShowNotification(const WCHAR* title, const WCHAR*
hr = notifier->Show(toast.Get());
BREAK_IF_BAD(hr);
//m_cbFn.Reset(Isolate::GetCurrent(), cbFn);
//todo:
//cbPtr->NotificationDisplayed();
n_delegate->NotificationDisplayed();
} while (FALSE);
if (toastNotifMgrStr != NULL){
if (toastNotifMgrStr != NULL) {
WindowsDeleteString(toastNotifMgrStr);
}
if (appId != NULL){
if (appId != NULL) {
WindowsDeleteString(appId);
}
if (toastNotifStr != NULL){
if (toastNotifStr != NULL) {
WindowsDeleteString(toastNotifStr);
}
// if (!SUCCEEDED(hr)){
// delete this;
// }
if (!SUCCEEDED(hr)) {
delete this;
}
}
void WindowsToastNotification::NotificationClicked()
{
// Local<Function> fn = Local<Function>::New(Isolate::GetCurrent(), m_cbFn);
// Handle<Value> args[1];
// fn->Call(Isolate::GetCurrent()->GetCurrentContext()->Global(), 0, args);
// delete this;
delete this;
}
void WindowsToastNotification::NotificationDismissed()
{
delete this;
}
HRESULT WindowsToastNotification::GetToastXml(IToastNotificationManagerStatics* toastMgr, const WCHAR* title, const WCHAR* msg, const char* img, IXmlDocument** toastXml)
{
HRESULT WindowsToastNotification::GetToastXml(
IToastNotificationManagerStatics* toastMgr,
const WCHAR* title,
const WCHAR* msg,
std::string iconPath,
IXmlDocument** toastXml) {
HRESULT hr;
ToastTemplateType templateType;
if (title == NULL || msg == NULL){
if (title == NULL || msg == NULL) {
// Single line toast
templateType = img == NULL ? ToastTemplateType_ToastText01 : ToastTemplateType_ToastImageAndText01;
templateType = iconPath.length() == 0 ? ToastTemplateType_ToastText01 : ToastTemplateType_ToastImageAndText01;
hr = toastMgr->GetTemplateContent(templateType, toastXml);
if (SUCCEEDED(hr)) {
const WCHAR* text = title != NULL ? title : msg;
@ -152,18 +138,17 @@ HRESULT WindowsToastNotification::GetToastXml(IToastNotificationManagerStatics*
}
} else {
// Title and body toast
templateType = img == NULL ? ToastTemplateType_ToastText02 : ToastTemplateType_ToastImageAndText02;
templateType = iconPath.length() == 0 ? ToastTemplateType_ToastText02 : ToastTemplateType_ToastImageAndText02;
hr = toastMgr->GetTemplateContent(templateType, toastXml);
if (SUCCEEDED(hr)) {
hr = SetXmlText(*toastXml, title, msg);
}
}
if (img != NULL && SUCCEEDED(hr)){
if (iconPath.length() != 0 && SUCCEEDED(hr)) {
// Toast has image
hr = CreateTempImageFile(img);
if (SUCCEEDED(hr)){
hr = SetXmlImage(*toastXml);
if (SUCCEEDED(hr)) {
hr = SetXmlImage(*toastXml, iconPath);
}
// Don't stop a notification from showing just because an image couldn't be displayed. By default the app icon will be shown.
@ -173,7 +158,6 @@ HRESULT WindowsToastNotification::GetToastXml(IToastNotificationManagerStatics*
return hr;
}
HRESULT WindowsToastNotification::SetXmlText(IXmlDocument* doc, const WCHAR* text)
{
HSTRING tag = NULL;
@ -190,14 +174,13 @@ HRESULT WindowsToastNotification::SetXmlText(IXmlDocument* doc, const WCHAR* tex
hr = AppendTextToXml(doc, node.Get(), text);
} while (FALSE);
if (tag != NULL){
if (tag != NULL) {
WindowsDeleteString(tag);
}
return hr;
}
HRESULT WindowsToastNotification::SetXmlText(IXmlDocument* doc, const WCHAR* title, const WCHAR* body)
{
HSTRING tag = NULL;
@ -219,21 +202,21 @@ HRESULT WindowsToastNotification::SetXmlText(IXmlDocument* doc, const WCHAR* tit
hr = AppendTextToXml(doc, node.Get(), body);
} while (FALSE);
if (tag != NULL){
if (tag != NULL) {
WindowsDeleteString(tag);
}
return hr;
}
HRESULT WindowsToastNotification::SetXmlImage(IXmlDocument* doc)
HRESULT WindowsToastNotification::SetXmlImage(IXmlDocument* doc, std::string iconPath)
{
HSTRING tag = NULL;
HSTRING src = NULL;
HSTRING imgPath = NULL;
HRESULT hr = CreateHString(L"image", &tag);
do{
do {
BREAK_IF_BAD(hr);
ComPtr<IXmlNodeList> nodeList;
@ -256,7 +239,7 @@ HRESULT WindowsToastNotification::SetXmlImage(IXmlDocument* doc)
BREAK_IF_BAD(hr);
WCHAR xmlPath[MAX_PATH];
swprintf(xmlPath, ARRAYSIZE(xmlPath), L"file:///%S", m_tempFilePath);
swprintf(xmlPath, ARRAYSIZE(xmlPath), L"%S", iconPath);
hr = CreateHString(xmlPath, &imgPath);
BREAK_IF_BAD(hr);
@ -272,20 +255,19 @@ HRESULT WindowsToastNotification::SetXmlImage(IXmlDocument* doc)
hr = srcAttr->AppendChild(srcNode.Get(), &childNode);
} while (FALSE);
if (tag != NULL){
if (tag != NULL) {
WindowsDeleteString(tag);
}
if (src != NULL){
if (src != NULL) {
WindowsDeleteString(src);
}
if (imgPath != NULL){
if (imgPath != NULL) {
WindowsDeleteString(imgPath);
}
return hr;
}
HRESULT WindowsToastNotification::GetTextNodeList(HSTRING* tag, IXmlDocument* doc, IXmlNodeList** nodeList, UINT32 reqLength)
{
HRESULT hr = CreateHString(L"text", tag);
@ -304,7 +286,7 @@ HRESULT WindowsToastNotification::GetTextNodeList(HSTRING* tag, IXmlDocument* do
}
} while (FALSE);
if (!SUCCEEDED(hr)){
if (!SUCCEEDED(hr)) {
// Allow the caller to delete this string on success
WindowsDeleteString(*tag);
}
@ -312,12 +294,11 @@ HRESULT WindowsToastNotification::GetTextNodeList(HSTRING* tag, IXmlDocument* do
return hr;
}
HRESULT WindowsToastNotification::AppendTextToXml(IXmlDocument* doc, IXmlNode* node, const WCHAR* text)
{
HSTRING str = NULL;
HRESULT hr = CreateHString(text, &str);
do{
do {
BREAK_IF_BAD(hr);
ComPtr<IXmlText> xmlText;
@ -332,20 +313,20 @@ HRESULT WindowsToastNotification::AppendTextToXml(IXmlDocument* doc, IXmlNode* n
hr = node->AppendChild(textNode.Get(), &appendNode);
} while (FALSE);
if (str != NULL){
if (str != NULL) {
WindowsDeleteString(str);
}
return hr;
}
HRESULT WindowsToastNotification::SetupCallbacks(IToastNotification* toast)
{
EventRegistrationToken activatedToken, dismissedToken;
m_eventHandler = new ToastEventHandler(this);
m_eventHandler = new ToastEventHandler(this, n_delegate);
ComPtr<ToastEventHandler> eventHandler(m_eventHandler);
HRESULT hr = toast->add_Activated(eventHandler.Get(), &activatedToken);
if (SUCCEEDED(hr)) {
hr = toast->add_Dismissed(eventHandler.Get(), &dismissedToken);
}
@ -353,7 +334,6 @@ HRESULT WindowsToastNotification::SetupCallbacks(IToastNotification* toast)
return hr;
}
HRESULT WindowsToastNotification::CreateHString(const WCHAR* source, HSTRING* dest)
{
if (source == NULL || dest == NULL) {
@ -364,229 +344,43 @@ HRESULT WindowsToastNotification::CreateHString(const WCHAR* source, HSTRING* de
return hr;
}
HRESULT WindowsToastNotification::CreateTempImageFile(const char* base64)
{
BYTE* buff = NULL;
HRESULT hr = EnsureTempDir();
do{
BREAK_IF_BAD(hr);
DWORD buffLen;
hr = ConvertBase64DataToImage(base64, &buff, &buffLen);
BREAK_IF_BAD(hr);
hr = WriteToFile(buff, buffLen);
} while (FALSE);
if (buff != NULL){
delete buff;
}
return hr;
}
HRESULT WindowsToastNotification::ConvertBase64DataToImage(const char* base64, BYTE** buff, DWORD* buffLen)
{
HRESULT hr = E_FAIL;
*buffLen = 0;
DWORD reqSize;
if (CryptStringToBinary((LPCWSTR)base64, 0, CRYPT_STRING_BASE64, NULL, &reqSize, NULL, NULL)){
*buff = new BYTE[reqSize];
if (CryptStringToBinary((LPCWSTR)base64, 0, CRYPT_STRING_BASE64, *buff, &reqSize, NULL, NULL)){
*buffLen = reqSize;
hr = S_OK;
}
}
return hr;
}
HRESULT WindowsToastNotification::WriteToFile(BYTE* buff, DWORD buffLen)
{
HRESULT hr = E_FAIL;
GUID guid;
hr = CoCreateGuid(&guid);
if (SUCCEEDED(hr)){
WCHAR randomName[MAX_PATH];
StringFromGUID2(guid, randomName, ARRAYSIZE(randomName));
m_tempFilePath = new char[MAX_PATH];
sprintf(m_tempFilePath, "%s\\%S", s_tempDirPath, randomName);
HANDLE file = CreateFile((LPCWSTR)m_tempFilePath, GENERIC_WRITE, 0, NULL, CREATE_NEW, FILE_ATTRIBUTE_NORMAL, NULL);
if (file != INVALID_HANDLE_VALUE){
DWORD bytesWritten;
if (WriteFile(file, buff, buffLen, &bytesWritten, NULL)){
hr = S_OK;
}
else{
DeleteTempImageFile();
}
CloseHandle(file);
}
}
if (!SUCCEEDED(hr) && m_tempFilePath){
delete m_tempFilePath;
m_tempFilePath = NULL;
}
return hr;
}
HRESULT WindowsToastNotification::EnsureTempDir()
{
// Check for the Dir already existing or easy creation
HRESULT hr = E_FAIL;
if (CreateDirectory((LPCWSTR)s_tempDirPath, NULL) || GetLastError() == ERROR_ALREADY_EXISTS){
hr = S_OK;
} else {
// NOTE: This makes an assumption that the path is a FULL LENGTH PATH. Therefore the first folder starts at the
// 4th character. ie. "c:\path\to\temp\dir"
// It's possible that multiple directories need to be created.
for (int i = 3; i < ARRAYSIZE(s_tempDirPath); i++) {
char c = s_tempDirPath[i];
if (c == '\\'){
//Substring until this char
char* temp = new char[i + 1];
strncpy(temp, s_tempDirPath, i);
temp[i] = 0;
if (!CreateDirectory((LPCWSTR)temp, NULL) && GetLastError() != ERROR_ALREADY_EXISTS){
delete temp;
return hr;
}
delete temp;
}
}
//Try to create the full path one more time. This will take care of paths that don't end with a slash
if (CreateDirectory((LPCWSTR)s_tempDirPath, NULL) || GetLastError() == ERROR_ALREADY_EXISTS){
hr = S_OK;
}
}
return hr;
}
HRESULT WindowsToastNotification::DeleteTempImageFile()
{
if (DeleteFile((LPCWSTR)m_tempFilePath)){
return S_OK;
}
return E_FAIL;
}
HRESULT WindowsToastNotification::EnsureShortcut()
{
HRESULT hr = E_FAIL;
char shortcut[MAX_PATH];
DWORD charsWritten = GetEnvironmentVariable(L"APPDATA", (LPWSTR)shortcut, MAX_PATH);
if (charsWritten > 0) {
char shortcutCat[MAX_PATH];
sprintf(shortcutCat, SHORTCUT_FORMAT, s_appName);
errno_t concatErr = strcat_s(shortcut, ARRAYSIZE(shortcut), shortcutCat);
if (concatErr == 0) {
DWORD attr = GetFileAttributes((LPCWSTR)shortcut);
bool exists = attr < 0xFFFFFFF;
if (exists){
hr = S_OK;
}
else{
WCHAR path[MAX_PATH];
mbstowcs(path, shortcut, ARRAYSIZE(path));
hr = CreateShortcut(path);
}
}
}
return hr;
}
HRESULT WindowsToastNotification::CreateShortcut(WCHAR* path)
{
HRESULT hr = E_FAIL;
char exePath[MAX_PATH];
DWORD charsWritten = GetModuleFileNameEx(GetCurrentProcess(), nullptr, (LPWSTR)exePath, ARRAYSIZE(exePath));
if (charsWritten > 0) {
PROPVARIANT propVariant;
ComPtr<IShellLink> shellLink;
hr = CoCreateInstance(CLSID_ShellLink, nullptr, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&shellLink));
do{
BREAK_IF_BAD(hr);
hr = shellLink->SetPath((LPCWSTR)exePath);
BREAK_IF_BAD(hr);
ComPtr<IPropertyStore> propStore;
hr = shellLink.As(&propStore);
BREAK_IF_BAD(hr);
WCHAR wAppName[MAX_PATH];
swprintf(wAppName, ARRAYSIZE(wAppName), L"%S", s_appName);
hr = InitPropVariantFromString(wAppName, &propVariant);
BREAK_IF_BAD(hr);
hr = propStore->SetValue(PKEY_AppUserModel_ID, propVariant);
BREAK_IF_BAD(hr);
hr = propStore->Commit();
BREAK_IF_BAD(hr);
ComPtr<IPersistFile> persistFile;
hr = shellLink.As(&persistFile);
BREAK_IF_BAD(hr);
hr = persistFile->Save(path, TRUE);
} while (FALSE);
PropVariantClear(&propVariant);
}
return hr;
}
ToastEventHandler::ToastEventHandler(WindowsToastNotification* notification)
/*
/ Toast Event Handler
*/
ToastEventHandler::ToastEventHandler(WindowsToastNotification* notification, content::DesktopNotificationDelegate* delegate)
{
m_ref = 1;
m_notification = notification;
n_delegate = delegate;
}
ToastEventHandler::~ToastEventHandler()
{
// Empty
}
IFACEMETHODIMP ToastEventHandler::Invoke(IToastNotification* sender, IInspectable* args)
{
//Notification "activated" (clicked)
if (m_notification != NULL){
// Notification "activated" (clicked)
n_delegate->NotificationClick();
if (m_notification != NULL) {
m_notification->NotificationClicked();
}
return S_OK;
}
IFACEMETHODIMP ToastEventHandler::Invoke(IToastNotification* sender, IToastDismissedEventArgs* e)
{
//Notification dismissed
if (m_notification != NULL){
{
// Notification dismissed
n_delegate->NotificationClosed();
if (m_notification != NULL) {
m_notification->NotificationDismissed();
}
return S_OK;
}

34
brightray/browser/win/windows_toast_notification.h
View file

@ -1,12 +1,22 @@
// Copyright (c) 2015 Felix Rieseberg <feriese@microsoft.com>. All rights reserved.
// Copyright (c) 2015 Ryan McShane <rmcshane@bandwidth.com> and Brandon Smith <bsmith@bandwidth.com>
// Thanks to both of those folks mentioned above who first thought up a bunch of this code
// and released it as MIT to the world.
#ifndef __WINDOWS_TOAST_NOTIFICATION_H__
#define __WINDOWS_TOAST_NOTIFICATION_H__
#define WIN32_LEAN_AND_MEAN
#include "content/public/browser/desktop_notification_delegate.h"
#include "content/public/common/platform_notification_data.h"
#include "base/bind.h"
#include <windows.h>
#include <windows.ui.notifications.h>
#include <wrl/client.h>
#include <wrl/implements.h>
#include <string>
using namespace Microsoft::WRL;
using namespace ABI::Windows::UI::Notifications;
@ -24,35 +34,24 @@ namespace WinToasts{
{
private:
static char s_appName[MAX_PATH];
static char s_tempDirPath[MAX_PATH];
char* m_tempFilePath;
ToastEventHandler* m_eventHandler;
content::DesktopNotificationDelegate* n_delegate;
HRESULT GetToastXml(IToastNotificationManagerStatics* toastMgr, const WCHAR* title, const WCHAR* msg, const char* img, IXmlDocument** toastXml);
HRESULT GetToastXml(IToastNotificationManagerStatics* toastMgr, const WCHAR* title, const WCHAR* msg, std::string iconPath, IXmlDocument** toastXml);
HRESULT SetXmlText(IXmlDocument* doc, const WCHAR* text);
HRESULT SetXmlText(IXmlDocument* doc, const WCHAR* title, const WCHAR* body);
HRESULT SetXmlImage(IXmlDocument* doc);
HRESULT SetXmlImage(IXmlDocument* doc, std::string iconPath);
HRESULT GetTextNodeList(HSTRING* tag, IXmlDocument* doc, IXmlNodeList** nodeList, UINT32 reqLength);
HRESULT AppendTextToXml(IXmlDocument* doc, IXmlNode* node, const WCHAR* text);
HRESULT SetupCallbacks(IToastNotification* toast);
HRESULT CreateHString(const WCHAR* source, HSTRING* dest);
HRESULT CreateTempImageFile(const char* base64);
HRESULT ConvertBase64DataToImage(const char* base64, BYTE** buff, DWORD* buffLen);
HRESULT WriteToFile(BYTE* buff, DWORD buffLen);
HRESULT EnsureTempDir();
HRESULT DeleteTempImageFile();
HRESULT EnsureShortcut();
HRESULT CreateShortcut(WCHAR* path);
public:
WindowsToastNotification(const char* appName);
WindowsToastNotification(const char* appName, content::DesktopNotificationDelegate* delegate);
~WindowsToastNotification();
void ShowNotification(const WCHAR* title, const WCHAR* msg, const char* img);
void ShowNotification(const WCHAR* title, const WCHAR* msg, std::string iconPath);
void NotificationClicked();
void NotificationDismissed();
static void InitSystemProps(char* appName, char* tempDirPath);
};
@ -62,9 +61,10 @@ namespace WinToasts{
private:
ULONG m_ref;
WindowsToastNotification* m_notification;
content::DesktopNotificationDelegate* n_delegate;
public:
ToastEventHandler(WindowsToastNotification* notification);
ToastEventHandler(WindowsToastNotification* notification, content::DesktopNotificationDelegate* delegate);
~ToastEventHandler();
IFACEMETHODIMP Invoke(IToastNotification* sender, IInspectable* args);
IFACEMETHODIMP Invoke(IToastNotification* sender, IToastDismissedEventArgs* e);