macOS implementation of notifications in the main process

atom/browser/api/atom_api_notification.cc

@@ -0,0 +1,126 @@
+// Copyright (c) 2014 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/api/atom_api_notification.h"
+
+#include <string>
+
+#include "atom/browser/api/atom_api_menu.h"
+#include "atom/browser/browser.h"
+#include "atom/common/api/atom_api_native_image.h"
+#include "atom/common/native_mate_converters/gfx_converter.h"
+#include "atom/common/native_mate_converters/image_converter.h"
+#include "atom/common/native_mate_converters/string16_converter.h"
+#include "atom/common/node_includes.h"
+#include "base/threading/thread_task_runner_handle.h"
+#include "native_mate/constructor.h"
+#include "native_mate/dictionary.h"
+#include "ui/gfx/image/image.h"
+
+namespace atom {
+
+namespace api {
+
+int id_counter = 1;
+std::map<int, Notification*> notifications_;
+
+Notification::Notification(v8::Isolate* isolate, v8::Local<v8::Object> wrapper, mate::Arguments* args) {
+  InitWith(isolate, wrapper);
+
+  mate::Dictionary opts;
+  if (args->GetNext(&opts)) {
+    opts.Get("title", &title_);
+    opts.Get("body", &body_);
+    has_icon_ = opts.Get("icon", &icon_);
+    opts.Get("silent", &silent_);
+    opts.Get("replyPlaceholder", &reply_placeholder_);
+    opts.Get("hasReply", &has_reply_);
+    id_ = id_counter++;
+  }
+  notifications_[id_] = this;
+  OnInitialProps();
+}
+
+Notification::~Notification() {}
+
+// static
+mate::WrappableBase* Notification::New(mate::Arguments* args) {
+  if (!Browser::Get()->is_ready()) {
+    args->ThrowError("Cannot create Notification before app is ready");
+    return nullptr;
+  }
+  return new Notification(args->isolate(), args->GetThis(), args);
+}
+
+bool Notification::HasID(int id) {
+  return notifications_.find(id) != notifications_.end();
+}
+
+Notification* Notification::FromID(int id) {
+  return notifications_[id];
+}
+
+// Getters
+int Notification::GetID() { return id_; } 
+std::string Notification::GetTitle() { return title_; }
+std::string Notification::GetBody() { return body_; }
+bool Notification::GetSilent() { return silent_; }
+std::string Notification::GetReplyPlaceholder() { return reply_placeholder_; }
+bool Notification::GetHasReply() { return has_reply_; }
+
+// Setters
+void Notification::SetTitle(std::string new_title) { title_ = new_title; NotifyPropsUpdated(); }
+void Notification::SetBody(std::string new_body) { body_ = new_body; NotifyPropsUpdated(); }
+void Notification::SetSilent(bool new_silent) { silent_ = new_silent; NotifyPropsUpdated(); }
+void Notification::SetReplyPlaceholder(std::string new_reply_placeholder) { reply_placeholder_ = new_reply_placeholder; NotifyPropsUpdated(); }
+void Notification::SetHasReply(bool new_has_reply) { has_reply_ = new_has_reply; NotifyPropsUpdated(); }
+
+void Notification::OnClicked() {
+  Emit("click");
+}
+
+void Notification::OnReplied(std::string reply) {
+  Emit("reply", reply);
+}
+
+void Notification::OnShown() {
+  Emit("show");
+}
+
+// static
+void Notification::BuildPrototype(v8::Isolate* isolate,
+                          v8::Local<v8::FunctionTemplate> prototype) {
+  prototype->SetClassName(mate::StringToV8(isolate, "Notification"));
+  mate::ObjectTemplateBuilder(isolate, prototype->PrototypeTemplate())
+      .MakeDestroyable()
+      .SetMethod("show", &Notification::Show)
+      .SetProperty("id", &Notification::GetID)
+      .SetProperty("title", &Notification::GetTitle, &Notification::SetTitle)
+      .SetProperty("body", &Notification::GetBody, &Notification::SetBody)
+      .SetProperty("silent", &Notification::GetSilent, &Notification::SetSilent)
+      .SetProperty("replyPlaceholder", &Notification::GetReplyPlaceholder, &Notification::SetReplyPlaceholder)
+      .SetProperty("hasReply", &Notification::GetHasReply, &Notification::SetHasReply);
+}
+
+}  // namespace api
+
+}  // namespace atom
+
+
+namespace {
+
+using atom::api::Notification;
+
+void Initialize(v8::Local<v8::Object> exports, v8::Local<v8::Value> unused,
+                v8::Local<v8::Context> context, void* priv) {
+  v8::Isolate* isolate = context->GetIsolate();
+  Notification::SetConstructor(isolate, base::Bind(&Notification::New));
+
+  mate::Dictionary dict(isolate, exports);
+  dict.Set("Notification", Notification::GetConstructor(isolate)->GetFunction());
+}
+
+}  // namespace
+
+NODE_MODULE_CONTEXT_AWARE_BUILTIN(atom_common_notification, Initialize)

atom/browser/api/atom_api_notification.h

@@ -0,0 +1,78 @@
+// Copyright (c) 2014 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#ifndef ATOM_BROWSER_API_ATOM_API_NOTIFICATION_H_
+#define ATOM_BROWSER_API_ATOM_API_NOTIFICATION_H_
+
+#include <memory>
+#include <string>
+#include <vector>
+
+#include "atom/browser/api/trackable_object.h"
+#include "atom/browser/ui/notification_observer.h"
+#include "native_mate/handle.h"
+#include "ui/gfx/image/image.h"
+
+namespace atom {
+
+namespace api {
+
+class Notification : public mate::TrackableObject<Notification>,
+             public NotifictionObserver {
+ public:
+  static mate::WrappableBase* New(mate::Arguments* args);
+  static bool HasID(int id);
+  static Notification* FromID(int id);
+
+  static void BuildPrototype(v8::Isolate* isolate,
+                             v8::Local<v8::FunctionTemplate> prototype);
+
+  // NotificationObserver:
+  void OnClicked() override;
+  void OnReplied(std::string reply) override;
+  void OnShown() override;
+
+ protected:
+  Notification(v8::Isolate* isolate, v8::Local<v8::Object> wrapper, mate::Arguments* args);
+  ~Notification() override;
+
+  void OnInitialProps();
+  void Show();
+
+  // Prop Getters
+  int GetID();
+  std::string GetTitle();
+  std::string GetBody();
+  bool GetSilent();
+  std::string GetReplyPlaceholder();
+  bool GetHasReply();
+
+  // Prop Setters
+  void SetTitle(std::string new_title);
+  void SetBody(std::string new_body);
+  void SetSilent(bool new_silent);
+  void SetReplyPlaceholder(std::string new_reply_placeholder);
+  void SetHasReply(bool new_has_reply);
+
+  void NotifyPropsUpdated();
+
+ private:
+  std::string title_ = "";
+  std::string body_ = "";
+  gfx::Image icon_;
+  bool has_icon_ = false;
+  bool silent_ = false;
+  std::string reply_placeholder_ = "";
+  bool has_reply_ = false;
+
+  int id_;
+
+  DISALLOW_COPY_AND_ASSIGN(Notification);
+};
+
+}  // namespace api
+
+}  // namespace atom
+
+#endif  // ATOM_BROWSER_API_ATOM_API_NOTIFICATION_H_

atom/browser/api/atom_api_notification_mac.mm

@@ -0,0 +1,97 @@
+// Copyright (c) 2014 GitHub, Inc.
+// Use of this source code is governed by the MIT license that can be
+// found in the LICENSE file.
+
+#include "atom/browser/api/atom_api_notification.h"
+
+#import <Foundation/Foundation.h>
+
+#include "atom/browser/browser.h"
+#include "base/mac/mac_util.h"
+#include "base/mac/scoped_nsobject.h"
+#include "base/strings/sys_string_conversions.h"
+
+std::map<int, base::scoped_nsobject<NSUserNotification>> native_notifications_;
+
+@interface AtomNotificationCenter : NSObject<NSUserNotificationCenterDelegate> {
+}
+@end
+
+@implementation AtomNotificationCenter
+- (BOOL)userNotificationCenter:(NSUserNotificationCenter *)center
+     shouldPresentNotification:(NSUserNotification *)notification {
+    return YES;
+  }
+
+- (void)userNotificationCenter:(NSUserNotificationCenter *)center 
+       didActivateNotification:(NSUserNotification *)notification {
+    int n_id = [[notification.userInfo objectForKey:@"id"] intValue];
+    if (atom::api::Notification::HasID(n_id)) {
+      auto atomNotification = atom::api::Notification::FromID(n_id);
+
+      if (notification.activationType == NSUserNotificationActivationTypeReplied){
+        atomNotification->OnReplied([notification.response.string UTF8String]);
+      } else {
+        atomNotification->OnClicked(); 
+      }
+    }
+  }
+@end
+
+namespace atom {
+
+namespace api {
+
+AtomNotificationCenter* del = [[AtomNotificationCenter alloc] init];
+bool set_del_ = false;
+
+void Notification::Show() {
+  base::scoped_nsobject<NSUserNotification> notification_ = native_notifications_[id_];
+  [NSUserNotificationCenter.defaultUserNotificationCenter
+      deliverNotification:notification_];
+  OnShown();
+}
+
+void Notification::OnInitialProps() {
+  if (!set_del_) {
+    [[NSUserNotificationCenter defaultUserNotificationCenter] setDelegate:del];
+    set_del_ = true;
+  }
+
+  base::scoped_nsobject<NSUserNotification> notification_;
+  notification_.reset([[NSUserNotification alloc] init]);
+
+  native_notifications_[id_] = notification_;
+
+  NotifyPropsUpdated();
+}
+
+void Notification::NotifyPropsUpdated() {
+  base::scoped_nsobject<NSUserNotification> notification_ = native_notifications_[id_];
+
+  [notification_ setTitle:base::SysUTF8ToNSString(title_)];
+  [notification_ setInformativeText:base::SysUTF8ToNSString(body_)];
+
+  NSDictionary * userInfo = [NSMutableDictionary dictionary];
+  [userInfo setValue:[NSNumber numberWithInt:id_] forKey:@"id"];
+  [notification_ setUserInfo:userInfo];
+
+  if ([notification_ respondsToSelector:@selector(setContentImage:)] && has_icon_) {
+    [notification_ setContentImage:icon_.AsNSImage()];
+  }
+
+  if (has_reply_) {
+    [notification_ setResponsePlaceholder:base::SysUTF8ToNSString(reply_placeholder_)];
+    [notification_ setHasReplyButton:true];
+  }
+
+  if (silent_) {
+    [notification_ setSoundName:nil];
+  } else {
+    [notification_ setSoundName:NSUserNotificationDefaultSoundName];
+  }
+}
+
+}  // namespace api
+
+}  // namespace atom