From 3716aaf00bc080ba91a2743c69fc4bbf72e23c83 Mon Sep 17 00:00:00 2001
From: Daniel Hengeveld <danielwh@gmail.com>
Date: Tue, 2 Feb 2016 11:56:05 -0800
Subject: [PATCH] Spike out an update wrapper
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

We can expose just a few event subscription methods on atom.update to
take care of what most packages (e.g. About) would be interested in. Of
course the updater runs on the main thread so we’re proxying them
through IPC. It’s fine.
---
 src/application-delegate.coffee        | 28 +++++++++++++
 src/atom-environment.coffee            |  3 ++
 src/browser/auto-update-manager.coffee | 14 +++++++
 src/update.js                          | 56 ++++++++++++++++++++++++++
 4 files changed, 101 insertions(+)
 create mode 100644 src/update.js

diff --git a/src/application-delegate.coffee b/src/application-delegate.coffee
index cc1f4c946..a4262965f 100644
--- a/src/application-delegate.coffee
+++ b/src/application-delegate.coffee
@@ -182,6 +182,34 @@ class ApplicationDelegate
     new Disposable ->
       ipcRenderer.removeListener('message', outerCallback)
 
+  onDidBeginCheckingForUpdate: (callback) ->
+    outerCallback = (message, detail) ->
+      if message is 'checking-for-update'
+        callback(detail)
+
+    ipc.on('message', outerCallback)
+    new Disposable ->
+      ipc.removeListener('message', outerCallback)
+
+  onDidCompleteDownloadingUpdate: (callback) ->
+    outerCallback = (message, detail) ->
+      if message is 'update-downloaded'
+        callback(detail)
+
+    ipc.on('message', outerCallback)
+    new Disposable ->
+      ipc.removeListener('message', outerCallback)
+
+  onUpdateNotAvailable: (callback) ->
+    outerCallback = (message, detail) ->
+      if message is 'update-not-available'
+        callback(detail)
+
+    ipc.on('message', outerCallback)
+    new Disposable ->
+      ipc.removeListener('message', outerCallback)
+
+
   onApplicationMenuCommand: (callback) ->
     outerCallback = (event, args...) ->
       callback(args...)
diff --git a/src/atom-environment.coffee b/src/atom-environment.coffee
index 0ee12fe93..e6830ceaa 100644
--- a/src/atom-environment.coffee
+++ b/src/atom-environment.coffee
@@ -115,6 +115,9 @@ class AtomEnvironment extends Model
   # Public: A {TextEditorRegistry} instance
   textEditors: null
 
+  # Public: An {Update} instance
+  update: null
+
   saveStateDebounceInterval: 1000
 
   ###
diff --git a/src/browser/auto-update-manager.coffee b/src/browser/auto-update-manager.coffee
index 2df338761..c58d317cb 100644
--- a/src/browser/auto-update-manager.coffee
+++ b/src/browser/auto-update-manager.coffee
@@ -39,12 +39,19 @@ class AutoUpdateManager
 
     autoUpdater.on 'checking-for-update', =>
       @setState(CheckingState)
+      @emitWindowEvent('checking-for-update')
 
     autoUpdater.on 'update-not-available', =>
       @setState(NoUpdateAvailableState)
 
     autoUpdater.on 'update-available', =>
       @setState(DownladingState)
+      # We use sendMessage to send an event called 'update-available' below
+      # once the update download is complete. This mismatch between the electron
+      # autoUpdater events is unfortunate but in the interest of not changing the
+      # one existing event handled by applicationDelegate
+      @emitWindowEvent('did-begin-downloading-update')
+      @emit('did-begin-download')
 
     autoUpdater.on 'update-downloaded', (event, releaseNotes, @releaseVersion) =>
       @setState(UpdateAvailableState)
@@ -66,10 +73,16 @@ class AutoUpdateManager
 
   emitUpdateAvailableEvent: (windows...) ->
     return unless @releaseVersion?
+    @emitWindowEvent('update-available', {@releaseVersion})
     for atomWindow in windows
       atomWindow.sendMessage('update-available', {@releaseVersion})
     return
 
+  emitWindowEvent: (eventName, windows, payload) ->
+    for atomWindow in windows
+      atomWindow.sendMessage(eventName, payload)
+    return
+
   setState: (state) ->
     return if @state is state
     @state = state
@@ -93,6 +106,7 @@ class AutoUpdateManager
       @checkForUpdatesIntervalID = null
 
   check: ({hidePopups}={}) ->
+    console.log 'checking for update'
     unless hidePopups
       autoUpdater.once 'update-not-available', @onUpdateNotAvailable
       autoUpdater.once 'error', @onUpdateError
diff --git a/src/update.js b/src/update.js
new file mode 100644
index 000000000..fcadbc21c
--- /dev/null
+++ b/src/update.js
@@ -0,0 +1,56 @@
+'use babel'
+
+import {Emitter} from 'event-kit'
+
+export default class Update {
+  constructor () {
+    this.subscriptions = new CompositeDisposable()
+    this.emitter = new Emitter()
+  }
+
+  initialize () {
+    atom.applicationDelegate.onDidBeginDownloadingUpdate(() => {
+      this.emitter.emit('did-begin-downloading-update')
+    })
+    atom.applicationDelegate.onDidBeginCheckingForUpdate(() => {
+      this.emitter.emit('did-begin-checking-for-update')
+    })
+    atom.applicationDelegate.onUpdateAvailable(() => {
+      this.emitter.emit('did-complete-downloading-update')
+    })
+  }
+
+  dispose () {
+    this.subscriptions.dispose()
+  }
+
+  onDidBeginCheckingForUpdate (callback) {
+    this.subscriptions.add(
+      this.emitter.on('did-begin-checking-for-update', callback)
+    )
+  }
+
+  onDidBeginDownload (callback) {
+    this.subscriptions.add(
+      this.emitter.on('did-begin-downloading-update', callback)
+    )
+  }
+
+  onDidCompleteDownload (callback) {
+    this.subscriptions.add(
+      this.emitter.on('did-complete-downloading-update', callback)
+    )
+  }
+
+  onUpdateNotAvailable (callback) {
+    this.subscriptions.add()
+  }
+
+  check () {
+    // TODO
+  }
+
+  getState () {
+    // TODO
+  }
+}