New makeSingleInstance API

atom/browser/api/atom_api_app.cc

@@ -350,8 +350,8 @@ struct Converter<content::CertificateRequestResultType> {
 namespace atom {
 
 ProcessMetric::ProcessMetric(int type,
-    base::ProcessId pid,
-    std::unique_ptr<base::ProcessMetrics> metrics) {
+                             base::ProcessId pid,
+                             std::unique_ptr<base::ProcessMetrics> metrics) {
   this->type = type;
   this->pid = pid;
   this->metrics = std::move(metrics);
@@ -864,25 +864,52 @@ std::string App::GetLocale() {
   return g_browser_process->GetApplicationLocale();
 }
 
-bool App::MakeSingleInstance(
-    const ProcessSingleton::NotificationCallback& callback) {
+bool App::OnSecondInstance(const base::CommandLine::StringVector& cmd,
+                           const base::FilePath& cwd) {
+  Emit("second-instance", cmd, cwd);
+  // This value is used literally no where, but we need it for Reasons(tm)
+  return false;
+}
+
+bool App::IsPrimaryInstance(mate::Arguments* args) {
+  if (single_instance_state_ == SingleInstanceState::UNINITIALIZED) {
+    args->ThrowError(
+        "You can not check if you are the primary instance without calling "
+        "makeSingleInstance");
+  }
+  return single_instance_state_ == SingleInstanceState::PRIMARY;
+}
+
+bool App::IsSingleInstance() {
   if (process_singleton_)
+    return true;
+  return false;
+}
+
+bool App::MakeSingleInstance() {
+  if (IsSingleInstance())
     return false;
 
   base::FilePath user_dir;
   PathService::Get(brightray::DIR_USER_DATA, &user_dir);
+
+  ProcessSingleton::NotificationCallback cb =
+      base::Bind(&App::OnSecondInstance, base::Unretained(this));
+
   process_singleton_.reset(new ProcessSingleton(
-      user_dir, base::Bind(NotificationCallbackWrapper, callback)));
+      user_dir, base::Bind(NotificationCallbackWrapper, cb)));
 
   switch (process_singleton_->NotifyOtherProcessOrCreate()) {
     case ProcessSingleton::NotifyResult::LOCK_ERROR:
     case ProcessSingleton::NotifyResult::PROFILE_IN_USE:
     case ProcessSingleton::NotifyResult::PROCESS_NOTIFIED: {
       process_singleton_.reset();
+      single_instance_state_ = SingleInstanceState::SECONDARY;
       return true;
     }
     case ProcessSingleton::NotifyResult::PROCESS_NONE:
     default:  // Shouldn't be needed, but VS warns if it is not there.
+      single_instance_state_ = SingleInstanceState::PRIMARY;
       return false;
   }
 }
@@ -1252,6 +1279,8 @@ void App::BuildPrototype(v8::Isolate* isolate,
 #if defined(USE_NSS_CERTS)
       .SetMethod("importCertificate", &App::ImportCertificate)
 #endif
+      .SetMethod("isSingleInstance", &App::IsSingleInstance)
+      .SetMethod("isPrimaryInstance", &App::IsPrimaryInstance)
       .SetMethod("makeSingleInstance", &App::MakeSingleInstance)
       .SetMethod("releaseSingleInstance", &App::ReleaseSingleInstance)
       .SetMethod("relaunch", &App::Relaunch)

atom/browser/api/atom_api_app.h

@@ -45,6 +45,12 @@ namespace atom {
 enum class JumpListResult : int;
 #endif
 
+enum SingleInstanceState {
+  UNINITIALIZED,
+  PRIMARY,
+  SECONDARY,
+};
+
 struct ProcessMetric {
   int type;
   base::ProcessId pid;
@@ -178,8 +184,12 @@ class App : public AtomBrowserClient::Delegate,
 
   void SetDesktopName(const std::string& desktop_name);
   std::string GetLocale();
-  bool MakeSingleInstance(
-      const ProcessSingleton::NotificationCallback& callback);
+  bool OnSecondInstance(const base::CommandLine::StringVector& cmd,
+                        const base::FilePath& cwd);
+  bool IsPrimaryInstance(mate::Arguments* args);
+  bool IsSingleInstance();
+  // TODO(MarshallOfSound): Remove return value in 4.0
+  bool MakeSingleInstance();
   void ReleaseSingleInstance();
   bool Relaunch(mate::Arguments* args);
   void DisableHardwareAcceleration(mate::Arguments* args);
@@ -229,6 +239,9 @@ class App : public AtomBrowserClient::Delegate,
       std::unordered_map<base::ProcessId, std::unique_ptr<atom::ProcessMetric>>;
   ProcessMetricMap app_metrics_;
 
+  SingleInstanceState single_instance_state_ =
+      SingleInstanceState::UNINITIALIZED;
+
   DISALLOW_COPY_AND_ASSIGN(App);
 };
 

docs/api/app.md

@@ -373,6 +373,22 @@ app.on('session-created', (event, session) => {
 })
 ```
 
+### Event: 'second-instance'
+
+Returns:
+
+* `argv` String[] - An array of the second instance's command line arguments
+* `workingDirectory` String - The second instance's working directory
+
+This event will be emitted inside the primary instance of your application
+when a second instance has been executed. `argv` is an Array of the second instance's
+command line arguments, and `workingDirectory` is its current working directory. Usually
+applications respond to this by making their primary window focused and
+non-minimized.
+
+This event is guaranteed to be emitted after the `ready` event of `app`
+gets emitted.
+
 ## Methods
 
 The `app` object has the following methods:
@@ -742,33 +758,31 @@ app.setJumpList([
 ])
 ```
 
-### `app.makeSingleInstance(callback)`
-
-* `callback` Function
-  * `argv` String[] - An array of the second instance's command line arguments
-  * `workingDirectory` String - The second instance's working directory
-
-Returns `Boolean`.
+### `app.makeSingleInstance()`
 
 This method makes your application a Single Instance Application - instead of
 allowing multiple instances of your app to run, this will ensure that only a
 single instance of your app is running, and other instances signal this
 instance and exit.
 
-`callback` will be called by the first instance with `callback(argv, workingDirectory)`
-when a second instance has been executed. `argv` is an Array of the second instance's
-command line arguments, and `workingDirectory` is its current working directory. Usually
-applications respond to this by making their primary window focused and
-non-minimized.
+### `app.isSingleInstance()`
 
-The `callback` is guaranteed to be executed after the `ready` event of `app`
-gets emitted.
+Returns `Boolean`
+
+This methods returns whether or not `makeSingleInstance` has been called.
 
-This method returns `false` if your process is the primary instance of the
-application and your app should continue loading. And returns `true` if your
+### `app.isPrimaryInstance()`
+
+Returns `Boolean`
+
+This method returns `true` if your process is the primary instance of the
+application and your app should continue loading. And returns `false` if your
 process has sent its parameters to another instance, and you should immediately
 quit.
 
+This method will throw an error if you call it without first calling
+`app.makeSingleInstance()`.
+
 On macOS the system enforces single instance automatically when users try to open
 a second instance of your app in Finder, and the `open-file` and `open-url`
 events will be emitted for that. However when users start your app in command
@@ -782,15 +796,19 @@ starts:
 const {app} = require('electron')
 let myWindow = null
 
-const isSecondInstance = app.makeSingleInstance((commandLine, workingDirectory) => {
+app.makeSingleInstance()
+
+app.on('second-instance', (commandLine, workingDirectory) => {
   // Someone tried to run a second instance, we should focus our window.
   if (myWindow) {
     if (myWindow.isMinimized()) myWindow.restore()
     myWindow.focus()
   }
 })
 
-if (isSecondInstance) {
+const isPrimaryInstance = app.isPrimaryInstance()
+
+if (!isPrimaryInstance) {
   app.quit()
 }
 

lib/browser/api/app.js

@@ -109,6 +109,16 @@ for (let name of events) {
   })
 }
 
+// TODO(MarshallOfSound): Remove in 4.0
+const originalMakeSingleInstance = app.makeSingleInstance.bind(app)
+app.makeSingleInstance = (cb) => {
+  if (cb && typeof cb === 'function') {
+    deprecate.warn('app.makeSingleInstance(cb)', 'app.makeSingleInstance() and app.on(\'second-instance\', cb)')
+    app.on('second-instance', (event, ...args) => cb(...args))
+  }
+  return originalMakeSingleInstance()
+}
+
 // Wrappers for native classes.
 const {DownloadItem} = process.atomBinding('download_item')
 Object.setPrototypeOf(DownloadItem.prototype, EventEmitter.prototype)

spec/fixtures/api/singleton/main.js

@@ -5,7 +5,7 @@ app.once('ready', () => {
 })
 
 const shouldExit = app.makeSingleInstance(() => {
-  process.nextTick(() => app.exit(0))
+  setImmediate(() => app.exit(0))
 })
 
 if (shouldExit) {