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

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
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) 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 // Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE-CHROMIUM file. // found in the LICENSE-CHROMIUM file.
#include "browser/win/notification_presenter_win.h" #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/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/browser/desktop_notification_delegate.h"
#include "content/public/common/platform_notification_data.h" #include "content/public/common/platform_notification_data.h"
#include "third_party/skia/include/core/SkBitmap.h"
#include "common/application_info.h" #include "common/application_info.h"
#include <stdlib.h> #include <stdlib.h>
#include <stdio.h> #include <stdio.h>
#include <vector> #include <vector>
#include "third_party/skia/include/core/SkBitmap.h"
#include "base/win/windows_version.h"
// Windows Header // Windows Header
#define WIN32_LEAN_AND_MEAN #define WIN32_LEAN_AND_MEAN
#include <windows.h> #include <windows.h>
#include <wrl/client.h>
#include <windows.ui.notifications.h> #include <windows.ui.notifications.h>
#include <wrl/client.h>
#include <wrl/implements.h> #include <wrl/implements.h>
#include <winstring.h> #include <winstring.h>
#include "windows_toast_notification.h" #include "windows_toast_notification.h"
@ -58,18 +54,20 @@ void NotificationPresenterWin::ShowNotification(
base::Closure* cancel_callback) { base::Closure* cancel_callback) {
std::wstring title = data.title; 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(); std::string appName = GetApplicationName();
char* img = NULL;
WinToasts::WindowsToastNotification* wtn = new WinToasts::WindowsToastNotification(appName.c_str()); WinToasts::WindowsToastNotification* wtn = new WinToasts::WindowsToastNotification(appName.c_str(), delegate_ptr.release());
wtn->ShowNotification(title.c_str(), body.c_str(), img); wtn->ShowNotification(title.c_str(), body.c_str(), iconPath);
} }
void NotificationPresenterWin::CancelNotification() { void NotificationPresenterWin::CancelNotification() {
// No can do.
} }
void NotificationPresenterWin::DeleteNotification() { void NotificationPresenterWin::DeleteNotification() {
// No can do.
} }
} // namespace brightray } // 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) 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 // Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE-CHROMIUM file. // 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_ #ifndef BRIGHTRAY_BROWSER_NOTIFICATION_PRESENTER_WIN_H_
#define 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> // 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 // 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. // and released it as MIT to the world.
#include "windows_toast_notification.h" #include "windows_toast_notification.h"
#include "content/public/browser/desktop_notification_delegate.h"
#include <Psapi.h> #include <Psapi.h>
#include <stdio.h> #include <stdio.h>
#include <ShObjidl.h> #include <ShObjidl.h>
#include <propvarutil.h> #include <propvarutil.h>
#include <propkey.h> #include <propkey.h>
#include <wincrypt.h> #include <wincrypt.h>
#include <string>
using namespace WinToasts; using namespace WinToasts;
using namespace Windows::Foundation; using namespace Windows::Foundation;
#define BREAK_IF_BAD(hr) if(!SUCCEEDED(hr)) break; #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_appName[MAX_PATH] = {};
char WindowsToastNotification::s_tempDirPath[MAX_PATH] = {};
namespace WinToasts { namespace WinToasts {
WindowsToastNotification::WindowsToastNotification(const char* appName) WindowsToastNotification::WindowsToastNotification(const char* appName, content::DesktopNotificationDelegate* delegate)
{ {
sprintf_s(s_appName, ARRAYSIZE(s_appName), "%s", appName); sprintf_s(s_appName, ARRAYSIZE(s_appName), "%s", appName);
m_eventHandler = NULL; m_eventHandler = NULL;
m_tempFilePath = NULL; n_delegate = delegate;
} }
WindowsToastNotification::~WindowsToastNotification() WindowsToastNotification::~WindowsToastNotification()
{ {
if (m_eventHandler){ if (m_eventHandler) {
delete m_eventHandler; delete m_eventHandler;
} }
if (m_tempFilePath){ if (n_delegate) {
DeleteTempImageFile(); delete n_delegate;
delete m_tempFilePath;
} }
} }
/*static*/ void WindowsToastNotification::InitSystemProps(char* appName, char* tempDirPath) void WindowsToastNotification::ShowNotification(const WCHAR* title, const WCHAR* msg, std::string iconPath)
{
sprintf_s(s_tempDirPath, ARRAYSIZE(s_tempDirPath), "%s", tempDirPath);
}
void WindowsToastNotification::ShowNotification(const WCHAR* title, const WCHAR* msg, const char* img)
{ {
// Init using WRL // Init using WRL
Windows::Foundation::Initialize(RO_INIT_MULTITHREADED); Windows::Foundation::Initialize(RO_INIT_MULTITHREADED);
@ -55,14 +49,10 @@ void WindowsToastNotification::ShowNotification(const WCHAR* title, const WCHAR*
HSTRING toastNotifMgrStr = NULL; HSTRING toastNotifMgrStr = NULL;
HSTRING appId = NULL; HSTRING appId = NULL;
HSTRING toastNotifStr = NULL; HSTRING toastNotifStr = NULL;
HRESULT hr;
// 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();
do{ do {
HRESULT hr = CreateHString(RuntimeClass_Windows_UI_Notifications_ToastNotificationManager, &toastNotifMgrStr); hr = CreateHString(RuntimeClass_Windows_UI_Notifications_ToastNotificationManager, &toastNotifMgrStr);
BREAK_IF_BAD(hr); BREAK_IF_BAD(hr);
ComPtr<IToastNotificationManagerStatics> toastMgr; ComPtr<IToastNotificationManagerStatics> toastMgr;
@ -70,7 +60,7 @@ void WindowsToastNotification::ShowNotification(const WCHAR* title, const WCHAR*
BREAK_IF_BAD(hr); BREAK_IF_BAD(hr);
ComPtr<IXmlDocument> toastXml; ComPtr<IXmlDocument> toastXml;
hr = GetToastXml(toastMgr.Get(), title, msg, img, &toastXml); hr = GetToastXml(toastMgr.Get(), title, msg, iconPath, &toastXml);
BREAK_IF_BAD(hr); BREAK_IF_BAD(hr);
WCHAR wAppName[MAX_PATH]; WCHAR wAppName[MAX_PATH];
@ -99,52 +89,48 @@ void WindowsToastNotification::ShowNotification(const WCHAR* title, const WCHAR*
hr = notifier->Show(toast.Get()); hr = notifier->Show(toast.Get());
BREAK_IF_BAD(hr); BREAK_IF_BAD(hr);
//m_cbFn.Reset(Isolate::GetCurrent(), cbFn); n_delegate->NotificationDisplayed();
//todo:
//cbPtr->NotificationDisplayed();
} while (FALSE); } while (FALSE);
if (toastNotifMgrStr != NULL){ if (toastNotifMgrStr != NULL) {
WindowsDeleteString(toastNotifMgrStr); WindowsDeleteString(toastNotifMgrStr);
} }
if (appId != NULL){ if (appId != NULL) {
WindowsDeleteString(appId); WindowsDeleteString(appId);
} }
if (toastNotifStr != NULL){ if (toastNotifStr != NULL) {
WindowsDeleteString(toastNotifStr); WindowsDeleteString(toastNotifStr);
} }
// if (!SUCCEEDED(hr)){ if (!SUCCEEDED(hr)) {
// delete this; delete this;
// } }
} }
void WindowsToastNotification::NotificationClicked() void WindowsToastNotification::NotificationClicked()
{ {
// Local<Function> fn = Local<Function>::New(Isolate::GetCurrent(), m_cbFn); delete this;
// Handle<Value> args[1];
// fn->Call(Isolate::GetCurrent()->GetCurrentContext()->Global(), 0, args);
// delete this;
} }
void WindowsToastNotification::NotificationDismissed() void WindowsToastNotification::NotificationDismissed()
{ {
delete this; delete this;
} }
HRESULT WindowsToastNotification::GetToastXml(
HRESULT WindowsToastNotification::GetToastXml(IToastNotificationManagerStatics* toastMgr, const WCHAR* title, const WCHAR* msg, const char* img, IXmlDocument** toastXml) IToastNotificationManagerStatics* toastMgr,
{ const WCHAR* title,
const WCHAR* msg,
std::string iconPath,
IXmlDocument** toastXml) {
HRESULT hr; HRESULT hr;
ToastTemplateType templateType; ToastTemplateType templateType;
if (title == NULL || msg == NULL){ if (title == NULL || msg == NULL) {
// Single line toast // Single line toast
templateType = img == NULL ? ToastTemplateType_ToastText01 : ToastTemplateType_ToastImageAndText01; templateType = iconPath.length() == 0 ? ToastTemplateType_ToastText01 : ToastTemplateType_ToastImageAndText01;
hr = toastMgr->GetTemplateContent(templateType, toastXml); hr = toastMgr->GetTemplateContent(templateType, toastXml);
if (SUCCEEDED(hr)) { if (SUCCEEDED(hr)) {
const WCHAR* text = title != NULL ? title : msg; const WCHAR* text = title != NULL ? title : msg;
@ -152,18 +138,17 @@ HRESULT WindowsToastNotification::GetToastXml(IToastNotificationManagerStatics*
} }
} else { } else {
// Title and body toast // Title and body toast
templateType = img == NULL ? ToastTemplateType_ToastText02 : ToastTemplateType_ToastImageAndText02; templateType = iconPath.length() == 0 ? ToastTemplateType_ToastText02 : ToastTemplateType_ToastImageAndText02;
hr = toastMgr->GetTemplateContent(templateType, toastXml); hr = toastMgr->GetTemplateContent(templateType, toastXml);
if (SUCCEEDED(hr)) { if (SUCCEEDED(hr)) {
hr = SetXmlText(*toastXml, title, msg); hr = SetXmlText(*toastXml, title, msg);
} }
} }
if (img != NULL && SUCCEEDED(hr)){ if (iconPath.length() != 0 && SUCCEEDED(hr)) {
// Toast has image // Toast has image
hr = CreateTempImageFile(img); if (SUCCEEDED(hr)) {
if (SUCCEEDED(hr)){ hr = SetXmlImage(*toastXml, iconPath);
hr = SetXmlImage(*toastXml);
} }
// Don't stop a notification from showing just because an image couldn't be displayed. By default the app icon will be shown. // 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; return hr;
} }
HRESULT WindowsToastNotification::SetXmlText(IXmlDocument* doc, const WCHAR* text) HRESULT WindowsToastNotification::SetXmlText(IXmlDocument* doc, const WCHAR* text)
{ {
HSTRING tag = NULL; HSTRING tag = NULL;
@ -190,14 +174,13 @@ HRESULT WindowsToastNotification::SetXmlText(IXmlDocument* doc, const WCHAR* tex
hr = AppendTextToXml(doc, node.Get(), text); hr = AppendTextToXml(doc, node.Get(), text);
} while (FALSE); } while (FALSE);
if (tag != NULL){ if (tag != NULL) {
WindowsDeleteString(tag); WindowsDeleteString(tag);
} }
return hr; return hr;
} }
HRESULT WindowsToastNotification::SetXmlText(IXmlDocument* doc, const WCHAR* title, const WCHAR* body) HRESULT WindowsToastNotification::SetXmlText(IXmlDocument* doc, const WCHAR* title, const WCHAR* body)
{ {
HSTRING tag = NULL; HSTRING tag = NULL;
@ -219,21 +202,21 @@ HRESULT WindowsToastNotification::SetXmlText(IXmlDocument* doc, const WCHAR* tit
hr = AppendTextToXml(doc, node.Get(), body); hr = AppendTextToXml(doc, node.Get(), body);
} while (FALSE); } while (FALSE);
if (tag != NULL){ if (tag != NULL) {
WindowsDeleteString(tag); WindowsDeleteString(tag);
} }
return hr; return hr;
} }
HRESULT WindowsToastNotification::SetXmlImage(IXmlDocument* doc, std::string iconPath)
HRESULT WindowsToastNotification::SetXmlImage(IXmlDocument* doc)
{ {
HSTRING tag = NULL; HSTRING tag = NULL;
HSTRING src = NULL; HSTRING src = NULL;
HSTRING imgPath = NULL; HSTRING imgPath = NULL;
HRESULT hr = CreateHString(L"image", &tag); HRESULT hr = CreateHString(L"image", &tag);
do{
do {
BREAK_IF_BAD(hr); BREAK_IF_BAD(hr);
ComPtr<IXmlNodeList> nodeList; ComPtr<IXmlNodeList> nodeList;
@ -256,7 +239,7 @@ HRESULT WindowsToastNotification::SetXmlImage(IXmlDocument* doc)
BREAK_IF_BAD(hr); BREAK_IF_BAD(hr);
WCHAR xmlPath[MAX_PATH]; WCHAR xmlPath[MAX_PATH];
swprintf(xmlPath, ARRAYSIZE(xmlPath), L"file:///%S", m_tempFilePath); swprintf(xmlPath, ARRAYSIZE(xmlPath), L"%S", iconPath);
hr = CreateHString(xmlPath, &imgPath); hr = CreateHString(xmlPath, &imgPath);
BREAK_IF_BAD(hr); BREAK_IF_BAD(hr);
@ -272,20 +255,19 @@ HRESULT WindowsToastNotification::SetXmlImage(IXmlDocument* doc)
hr = srcAttr->AppendChild(srcNode.Get(), &childNode); hr = srcAttr->AppendChild(srcNode.Get(), &childNode);
} while (FALSE); } while (FALSE);
if (tag != NULL){ if (tag != NULL) {
WindowsDeleteString(tag); WindowsDeleteString(tag);
} }
if (src != NULL){ if (src != NULL) {
WindowsDeleteString(src); WindowsDeleteString(src);
} }
if (imgPath != NULL){ if (imgPath != NULL) {
WindowsDeleteString(imgPath); WindowsDeleteString(imgPath);
} }
return hr; return hr;
} }
HRESULT WindowsToastNotification::GetTextNodeList(HSTRING* tag, IXmlDocument* doc, IXmlNodeList** nodeList, UINT32 reqLength) HRESULT WindowsToastNotification::GetTextNodeList(HSTRING* tag, IXmlDocument* doc, IXmlNodeList** nodeList, UINT32 reqLength)
{ {
HRESULT hr = CreateHString(L"text", tag); HRESULT hr = CreateHString(L"text", tag);
@ -304,7 +286,7 @@ HRESULT WindowsToastNotification::GetTextNodeList(HSTRING* tag, IXmlDocument* do
} }
} while (FALSE); } while (FALSE);
if (!SUCCEEDED(hr)){ if (!SUCCEEDED(hr)) {
// Allow the caller to delete this string on success // Allow the caller to delete this string on success
WindowsDeleteString(*tag); WindowsDeleteString(*tag);
} }
@ -312,12 +294,11 @@ HRESULT WindowsToastNotification::GetTextNodeList(HSTRING* tag, IXmlDocument* do
return hr; return hr;
} }
HRESULT WindowsToastNotification::AppendTextToXml(IXmlDocument* doc, IXmlNode* node, const WCHAR* text) HRESULT WindowsToastNotification::AppendTextToXml(IXmlDocument* doc, IXmlNode* node, const WCHAR* text)
{ {
HSTRING str = NULL; HSTRING str = NULL;
HRESULT hr = CreateHString(text, &str); HRESULT hr = CreateHString(text, &str);
do{ do {
BREAK_IF_BAD(hr); BREAK_IF_BAD(hr);
ComPtr<IXmlText> xmlText; ComPtr<IXmlText> xmlText;
@ -332,20 +313,20 @@ HRESULT WindowsToastNotification::AppendTextToXml(IXmlDocument* doc, IXmlNode* n
hr = node->AppendChild(textNode.Get(), &appendNode); hr = node->AppendChild(textNode.Get(), &appendNode);
} while (FALSE); } while (FALSE);
if (str != NULL){ if (str != NULL) {
WindowsDeleteString(str); WindowsDeleteString(str);
} }
return hr; return hr;
} }
HRESULT WindowsToastNotification::SetupCallbacks(IToastNotification* toast) HRESULT WindowsToastNotification::SetupCallbacks(IToastNotification* toast)
{ {
EventRegistrationToken activatedToken, dismissedToken; EventRegistrationToken activatedToken, dismissedToken;
m_eventHandler = new ToastEventHandler(this); m_eventHandler = new ToastEventHandler(this, n_delegate);
ComPtr<ToastEventHandler> eventHandler(m_eventHandler); ComPtr<ToastEventHandler> eventHandler(m_eventHandler);
HRESULT hr = toast->add_Activated(eventHandler.Get(), &activatedToken); HRESULT hr = toast->add_Activated(eventHandler.Get(), &activatedToken);
if (SUCCEEDED(hr)) { if (SUCCEEDED(hr)) {
hr = toast->add_Dismissed(eventHandler.Get(), &dismissedToken); hr = toast->add_Dismissed(eventHandler.Get(), &dismissedToken);
} }
@ -353,7 +334,6 @@ HRESULT WindowsToastNotification::SetupCallbacks(IToastNotification* toast)
return hr; return hr;
} }
HRESULT WindowsToastNotification::CreateHString(const WCHAR* source, HSTRING* dest) HRESULT WindowsToastNotification::CreateHString(const WCHAR* source, HSTRING* dest)
{ {
if (source == NULL || dest == NULL) { if (source == NULL || dest == NULL) {
@ -364,229 +344,43 @@ HRESULT WindowsToastNotification::CreateHString(const WCHAR* source, HSTRING* de
return hr; return hr;
} }
/*
HRESULT WindowsToastNotification::CreateTempImageFile(const char* base64) / Toast Event Handler
{ */
BYTE* buff = NULL; ToastEventHandler::ToastEventHandler(WindowsToastNotification* notification, content::DesktopNotificationDelegate* delegate)
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)
{ {
m_ref = 1; m_ref = 1;
m_notification = notification; m_notification = notification;
n_delegate = delegate;
} }
ToastEventHandler::~ToastEventHandler() ToastEventHandler::~ToastEventHandler()
{ {
// Empty // Empty
} }
IFACEMETHODIMP ToastEventHandler::Invoke(IToastNotification* sender, IInspectable* args) IFACEMETHODIMP ToastEventHandler::Invoke(IToastNotification* sender, IInspectable* args)
{ {
//Notification "activated" (clicked) // Notification "activated" (clicked)
if (m_notification != NULL){ n_delegate->NotificationClick();
if (m_notification != NULL) {
m_notification->NotificationClicked(); m_notification->NotificationClicked();
} }
return S_OK; return S_OK;
} }
IFACEMETHODIMP ToastEventHandler::Invoke(IToastNotification* sender, IToastDismissedEventArgs* e) IFACEMETHODIMP ToastEventHandler::Invoke(IToastNotification* sender, IToastDismissedEventArgs* e)
{ {
//Notification dismissed // Notification dismissed
if (m_notification != NULL){ n_delegate->NotificationClosed();
if (m_notification != NULL) {
m_notification->NotificationDismissed(); m_notification->NotificationDismissed();
} }
return S_OK; 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__ #ifndef __WINDOWS_TOAST_NOTIFICATION_H__
#define __WINDOWS_TOAST_NOTIFICATION_H__ #define __WINDOWS_TOAST_NOTIFICATION_H__
#define WIN32_LEAN_AND_MEAN #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.h>
#include <windows.ui.notifications.h> #include <windows.ui.notifications.h>
#include <wrl/client.h> #include <wrl/client.h>
#include <wrl/implements.h> #include <wrl/implements.h>
#include <string>
using namespace Microsoft::WRL; using namespace Microsoft::WRL;
using namespace ABI::Windows::UI::Notifications; using namespace ABI::Windows::UI::Notifications;
@ -24,35 +34,24 @@ namespace WinToasts{
{ {
private: private:
static char s_appName[MAX_PATH]; static char s_appName[MAX_PATH];
static char s_tempDirPath[MAX_PATH];
char* m_tempFilePath;
ToastEventHandler* m_eventHandler; 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* text);
HRESULT SetXmlText(IXmlDocument* doc, const WCHAR* title, const WCHAR* body); 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 GetTextNodeList(HSTRING* tag, IXmlDocument* doc, IXmlNodeList** nodeList, UINT32 reqLength);
HRESULT AppendTextToXml(IXmlDocument* doc, IXmlNode* node, const WCHAR* text); HRESULT AppendTextToXml(IXmlDocument* doc, IXmlNode* node, const WCHAR* text);
HRESULT SetupCallbacks(IToastNotification* toast); HRESULT SetupCallbacks(IToastNotification* toast);
HRESULT CreateHString(const WCHAR* source, HSTRING* dest); 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: public:
WindowsToastNotification(const char* appName); WindowsToastNotification(const char* appName, content::DesktopNotificationDelegate* delegate);
~WindowsToastNotification(); ~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 NotificationClicked();
void NotificationDismissed(); void NotificationDismissed();
static void InitSystemProps(char* appName, char* tempDirPath);
}; };
@ -62,9 +61,10 @@ namespace WinToasts{
private: private:
ULONG m_ref; ULONG m_ref;
WindowsToastNotification* m_notification; WindowsToastNotification* m_notification;
content::DesktopNotificationDelegate* n_delegate;
public: public:
ToastEventHandler(WindowsToastNotification* notification); ToastEventHandler(WindowsToastNotification* notification, content::DesktopNotificationDelegate* delegate);
~ToastEventHandler(); ~ToastEventHandler();
IFACEMETHODIMP Invoke(IToastNotification* sender, IInspectable* args); IFACEMETHODIMP Invoke(IToastNotification* sender, IInspectable* args);
IFACEMETHODIMP Invoke(IToastNotification* sender, IToastDismissedEventArgs* e); IFACEMETHODIMP Invoke(IToastNotification* sender, IToastDismissedEventArgs* e);