pebblewatch 0.0.1 → 0.0.2

data/README.md

@@ -6,9 +6,9 @@ The protocol implementation was based on the documentation at http://pebbledev.o
 
 ## To Do
 
-- [ ] Basic protocol communication
-- [ ] Sending of messages (notifications etc)
-- [ ] Receiving of events (log, music control)
+- [x] Basic protocol communication
+- [x] Sending of messages (notifications etc)
+- [x] Receiving of events (log, music control)
 - [ ] Firmware/app uploading
 - [ ] CLI
 - [ ] REPL
@@ -16,17 +16,109 @@ The protocol implementation was based on the documentation at http://pebbledev.o
 ## Installation
 
 ```sh
-gem install pebble
+gem install pebblewatch
 ```
 
 ## Usage
 
+Make sure your Pebble is paired to your computer and set up as a serial port. We're going to need the path or index of the port, which in the case of OS X looks like `/dev/tty.Pebble7F30-SerialPortSe` for Pebble ID `7F30`. 
+
 ```ruby
 require "pebble"
 
-# etc
+# Create your watch using the serial port assigned to your Pebble.
+watch = Pebble::Watch.new("7F30", "/dev/tty.Pebble7F30-SerialPortSe")
+# You can also use autodetection if you're on OS X:
+# watch = Pebble::Watch.autodetect
+
+# The watch object will be on the receiving end of 3 kinds of events:
+watch.on_event(:log) do |event|
+  puts "LOG"
+  puts "timestamp:  #{event.timestamp}"
+  puts "level:      #{event.level}"
+  puts "filename:   #{event.filename}"
+  puts "linenumber: #{event.linenumber}"
+  puts "message:    #{event.message}"
+end
+
+watch.on_event(:system_message) do |event|
+  puts "System Message: #{event.message} (#{event.code})"
+end
+
+handler = watch.on_event(:media_control) do |event|
+  case event.button
+  when :playpause
+    puts "Play or pause music"
+  when :next
+    puts "Next track"
+  when :previous
+    puts "Previous track"
+  end
+end
+
+# Suddenly got a change of heart? Just cover your ears.
+watch.stop_listening(:media_control, handler)
+
+# To make sure we don't miss any events, we haven't connected yet. 
+# To be able to *send* stuff to the watch, we will now.
+watch.connect
+
+
+# We can of course send notifications.
+watch.ping
+watch.notification_sms("Scarlett Johansson", "Hey baby, what are you doing tonight?")
+watch.notification_email("Tim Cook", "RE: Final offer", 
+  "All right, you drive a hard bargain. We'll pay $2 Billion for the whole shop and that is our final offer.")
+
+# Or let Pebble know what we're listening to.
+watch.set_nowplaying_metadata(
+  "Artist you've probably never heard of",
+  "Album released exclusively through SoundCloud", 
+  "Song that doesn't suck per se but isn't great either"
+)
+
+# We can also do some maintenancy things, although there's currently no firmware/app uploading.
+versions = watch.get_versions
+puts "Normal firmware version:    #{versions[:firmwares][:normal][:version]}"
+puts "Recovery firmware version:  #{versions[:firmwares][:recovery][:version]}"
+puts "Bluetooth MAC address:      #{versions[:btmac]}"
+
+# Fun fact: We don't have to wait for the results synchronously. (This works on every message with a response.)
+watch.get_installed_apps do |apps|
+  puts "Installed apps: (#{apps[:apps].length} of #{apps[:banks_count]} banks in use)"
+  apps[:apps].each do |app|
+    puts "#{app[:index]}/#{app[:id]}: #{app[:name]} by #{app[:author]}"
+  end
+end
+
+# Dieting is not just for dogs anymore.
+watch.remove_app(id, index)
+
+time = watch.get_time
+# Or asynchronously: watch.get_time { |time| ... }
+
+# Time travel is just one method call away.
+watch.set_time(Time.now + (365 * 24 * 60 * 60))
+
+# This is mostly interesting for internal stuff, but since there's a :system_message event as well, I thought why not.
+watch.system_message(Pebble::SystemMessages::FIRMWARE_OUT_OF_DATE)
+
+# Yeah, I'd stay away from this one.
+watch.reset
+
+
+# If you're done sending messages but want the program to keep listing for incoming events, say so:
+watch.listen_for_events
+# Note that listening will only end when the connection is lost, so anything that comes after this call will only then be executed. 
+# This will generally be the last call in your program.
+
+# If we don't want to wait around and listen, just let the program exit or disconnect explicitly:
+watch.disconnect
 ```
 
+## Examples
+Check out the `examples/` folder for two examples that I actually use myself. They're kind of similar, but should give you an idea of how this whole thing works.
+
 ## License
 Copyright (c) 2013 Douwe Maan
 

data/lib/pebble/capabilities.rb

@@ -16,7 +16,7 @@ module Pebble
       SMS           = 32
       GPS           = 64
       BTLE          = 128
-      CAMERA_FRONT  = 240 # No, that doesn't make sense, but it's apparently true.
+      # CAMERA_FRONT  = 240 # Doesn't make sense as it'd mess up the bitmask, but it's apparently true.
       CAMERA_REAR   = 256
       ACCEL         = 512
       GYRO          = 1024

data/lib/pebble/endpoints.rb

@@ -20,5 +20,9 @@ module Pebble
     RUNKEEPER           = 7000
     PUT_BYTES           = 48879
     MAX_ENDPOINT        = 65535
+
+    def self.for_code(code)
+      constants.find { |constant| const_get(constant) == code }
+    end
   end
 end

data/lib/pebble/protocol.rb

@@ -1,5 +1,160 @@
+require "serialport"
+
 module Pebble
   class Protocol
+    module Errors
+      class NotConnected < StandardError; end
+      class LostConnection < StandardError; end
+      class MalformedResponse < StandardError; end
+    end
+
+    attr_reader :connected
+    attr_reader :message_handlers
+
+    def self.open(port)
+      protocol = new(port)
+
+      begin
+        protocol.connect
+        yield protocol
+      ensure
+        protocol.disconnect
+      end
+      nil
+    end
+
+    def initialize(port)
+      @port = port
+
+      @connected          = false
+      @send_message_mutex = Mutex.new
+      @message_handlers   = Hash.new { |hash, key| hash[key] = [] }
+    end
+
+    def connect
+      puts "Connecting with port #{@port}"
+
+      @serial_port = SerialPort.new(@port, baudrate: 115200)
+      @serial_port.read_timeout = 500
+
+      @connected = true
+      puts "Connected"
+      
+      @receive_messages_thread = Thread.new(&method(:receive_messages))
+
+      true
+    end
+
+    def disconnect
+      raise Errors::NotConnected unless @connected
+
+      @connected = false
+
+      @serial_port.close()
+      @serial_port = nil
+
+      true
+    end
+
+    def listen_for_messages
+      raise Errors::NotConnected unless @connected
+
+      @receive_messages_thread.join
+    end
+
+    def on_receive(endpoint = :any, &handler)
+      @message_handlers[endpoint] << handler
+      handler
+    end
+
+    def stop_receiving(*params)
+      handler   = params.pop
+      endpoint  = params.pop || :any
+
+      @message_handlers[endpoint].delete(handler)
+    end
+
+    def send_message(endpoint, message, async_response_handler = nil, &response_parser)
+      raise Errors::NotConnected unless @connected
+
+      message ||= ""
+
+      puts "Sending #{Endpoints.for_code(endpoint)}: #{message.inspect}"
+
+      data = [message.size, endpoint].pack("S>S>") + message
+
+      @send_message_mutex.synchronize do
+        @serial_port.write data
+
+        if response_parser
+          if async_response_handler
+            identifier = on_receive(endpoint) do |response_message|
+              stop_receiving(endpoint, identifier)
+
+              parsed_response = response_parser.call(response_message)
+
+              async_response_handler.call(parsed_response)
+            end
+
+            true
+          else
+            received        = false
+            parsed_response = nil
+            identifier = on_receive(endpoint) do |response_message|
+              stop_receiving(endpoint, identifier)
+
+              parsed_response = response_parser.call(response_message)
+              received        = true
+            end
+
+            sleep 0.015 until received
+
+            parsed_response
+          end
+        else
+          true
+        end
+      end
+    end
+
+    private
+      def receive_messages
+        puts "Waiting for messages"
+        while @connected
+          header = @serial_port.read(4)
+          next unless header
+
+          raise Errors::MalformedResponse if header.length < 4
+
+          size, endpoint = header.unpack("S>S>")
+          message = @serial_port.read(size)
+
+          puts "Received #{Endpoints.for_code(endpoint)}: #{message.inspect}"
+
+          trigger_received(endpoint, message)
+        end
+      rescue IOError => e
+        if @connected
+          puts "Lost connection"
+          @connected = false
+          raise Errors::LostConnection
+        end
+      ensure
+        puts "Finished waiting for messages"
+      end
+
+      def trigger_received(endpoint, message)
+        @message_handlers[:any].each do |handler|
+          Thread.new(handler) do |handler|
+            handler.call(endpoint, message)
+          end
+        end
 
+        @message_handlers[endpoint].each do |handler|
+          Thread.new(handler) do |handler|
+            handler.call(message)
+          end
+        end
+      end
   end
 end

data/lib/pebble/system_messages.rb

@@ -1,10 +1,16 @@
-module SystemMessages
-  FIRMWARE_AVAILABLE            = 0
-  FIRMWARE_START                = 1
-  FIRMWARE_COMPLETE             = 2
-  FIRMWARE_FAIL                 = 3
-  FIRMWARE_UP_TO_DATE           = 4
-  FIRMWARE_OUT_OF_DATE          = 5
-  BLUETOOTH_START_DISCOVERABLE  = 6
-  BLUETOOTH_END_DISCOVERABLE    = 7
+module Pebble
+  module SystemMessages
+    FIRMWARE_AVAILABLE            = 0
+    FIRMWARE_START                = 1
+    FIRMWARE_COMPLETE             = 2
+    FIRMWARE_FAIL                 = 3
+    FIRMWARE_UP_TO_DATE           = 4
+    FIRMWARE_OUT_OF_DATE          = 5
+    BLUETOOTH_START_DISCOVERABLE  = 6
+    BLUETOOTH_END_DISCOVERABLE    = 7
+
+    def self.for_code(code)
+      constants.find { |constant| const_get(constant) == code }
+    end
+  end
 end

data/lib/pebble/version.rb

@@ -1,3 +1,3 @@
 module Pebble
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/lib/pebble/watch.rb

@@ -2,6 +2,260 @@ require "pebble/watch/event"
 
 module Pebble
   class Watch
+    module Errors
+      class NoWatchesFound < StandardError; end
+    end
 
+    def self.autodetect
+      return nil unless RUBY_PLATFORM =~ /darwin/
+
+      devices = Dir.glob("/dev/tty.Pebble????-SerialPortSe")
+
+      raise NoWatchesFound if devices.length == 0
+      puts "Found multiple watches" if devices.length > 1
+
+      port = devices.first
+      id = port[15, 4]
+      puts "Found watch with ID #{id}"
+
+      return new(id, port)
+    end
+
+    def self.open(id, port)
+      watch = new(id, port)
+
+      begin
+        watch.connect
+        yield watch
+      ensure
+        watch.disconnect
+      end
+      nil
+    end
+
+    attr_reader :id
+    attr_reader :protocol
+    attr_reader :event_handlers
+    attr_accessor :session_capabilities
+    attr_accessor :client_capabilities
+
+    def initialize(id, port)
+      @id = id
+
+      @protocol       = Protocol.new(port)
+      @event_handlers = Hash.new { |hash, key| hash[key] = [] }
+
+      # We're mirroring Android here.
+      @session_capabilities = Capabilities::Session::GAMMA_RAY
+      @client_capabilities  = Capabilities::Client::TELEPHONY | Capabilities::Client::SMS | Capabilities::Client::ANDROID
+
+      answer_phone_version_message
+      
+      receive_event_messages
+    end
+
+    def connect
+      @protocol.connect
+    end
+
+    def disconnect
+      @protocol.disconnect
+    end
+
+    def listen_for_events
+      @protocol.listen_for_messages
+    end
+
+    def on_event(event = :any, &handler)
+      @event_handlers[event] << handler
+      handler
+    end
+
+    def stop_listening(*params)
+      handler = params.pop
+      event   = params.pop || :any
+
+      @event_handlers[event].delete(handler)
+    end
+
+
+    def ping(cookie = 0xDEADBEEF, &async_response_handler)
+      message = [0, cookie].pack("CL>")
+
+      @protocol.send_message(Endpoints::PING, message, async_response_handler) do |message|
+        restype, cookie = message.unpack("CL>")
+        cookie
+      end
+    end
+
+    def notification_sms(sender, body)
+      notification(:sms, sender, body)
+    end
+
+    def notification_email(sender, subject, body)
+      notification(:email, sender, body, subject)
+    end
+
+    def set_nowplaying_metadata(artist, album, track)
+      message = [16].pack("C")
+      message << package_strings(artist, album, track, 30)
+
+      @protocol.send_message(Endpoints::MUSIC_CONTROL, message)
+    end
+
+    def get_versions(&async_response_handler)
+      @protocol.send_message(Endpoints::VERSION, "\x00", async_response_handler) do |message|
+        response = {}
+
+        response[:firmwares] = {}
+
+        size = 47
+        [:normal, :recovery].each_with_index do |type, index|
+          offset = index * size + 1
+
+          fw = {}
+
+          fw[:timestamp], fw[:version], fw[:commit], fw[:is_recovery], 
+            fw[:hardware_platform], fw[:metadata_version] =
+            message[offset, size].unpack("L>A32A8ccc")
+
+          fw[:is_recovery] = (fw[:is_recovery] == 1)
+
+          response[:firmwares][type] = fw
+        end
+
+        response[:bootloader_timestamp], response[:hardware_version], response[:serial] =
+          message[95, 25].unpack("L>A9A12")
+
+        response[:btmac] = message[120, 6].unpack("H*").first.scan(/../).reverse.map { |c| c.upcase }.join(":")
+
+        response
+      end
+    end
+
+    def get_installed_apps(&async_response_handler)
+      @protocol.send_message(Endpoints::APP_INSTALL_MANAGER, "\x01", async_response_handler) do |message|
+        response = {}
+
+        response[:banks_count], apps_count = message[1, 8].unpack("L>L>")
+        response[:apps] = []
+
+        size = 78
+        apps_count.times do |index|
+          offset = index * size + 9
+
+          app = {}
+
+          app[:id], app[:index], app[:name], app[:author], app[:flags], app[:version] = 
+            message[offset, size].unpack("L>L>A32A32L>S>")
+
+          response[:apps] << app
+        end
+
+        response
+      end
+    end
+
+    def remove_app(app_id, app_index)
+      message = [2, app_id, app_index].pack("cL>L>")
+
+      @protocol.send_message(Endpoints::APP_INSTALL_MANAGER, message)
+    end
+
+    def get_time(&async_response_handler)
+      @protocol.send_message(Endpoints::TIME, "\x00", async_response_handler) do |message|
+        restype, timestamp = message.unpack("CL>")
+        Time.at(timestamp)
+      end
+    end
+
+    def set_time(time)
+      timestamp = time.to_i
+      message = [2, timestamp].pack("CL>")
+
+      @protocol.send_message(Endpoints::TIME, message)
+    end
+
+    def system_message(code)
+      puts "Sending system message #{SystemMessages.for_code(code)}"
+
+      message = [code].pack("S>")
+
+      @protocol.send_message(Endpoints::SYSTEM_MESSAGE, message)
+    end
+
+    def reset
+      @protocol.send_message(Endpoints::RESET, "\x00")
+    end
+
+    private
+      def answer_phone_version_message
+        @protocol.on_receive(Endpoints::PHONE_VERSION) do |message|
+          response_message = [1, -1].pack("Cl>")
+          response_message << [@session_capabilities, @client_capabilities].pack("L>L>")
+
+          @protocol.send_message(Endpoints::PHONE_VERSION, response_message)
+        end
+      end
+
+      def receive_event_messages
+        events = [
+          [:log,            Endpoints::LOGS,            LogEvent],
+          [:system_message, Endpoints::SYSTEM_MESSAGE,  SystemMessageEvent],
+          [:media_control,  Endpoints::MUSIC_CONTROL,   MediaControlEvent]
+        ]
+
+        events.each do |(name, endpoint, event_klass)|
+          @protocol.on_receive(endpoint) do |message|
+            event = event_klass.parse(message)
+            trigger_event(name, event) if event
+          end
+        end
+      end
+
+      def trigger_event(name, event)
+        puts "Event '#{name}': #{event.inspect}"
+
+        @event_handlers[:any].each do |handler|
+          Thread.new(handler) do |handler|
+            handler.call(name, event)
+          end
+        end
+
+        @event_handlers[name].each do |handler|
+          Thread.new(handler) do |handler|
+            handler.call(event)
+          end
+        end
+      end
+
+      def notification(type, *params)
+        types = {
+          email:  0,
+          sms:    1
+        }
+
+        timestamp = Time.now.to_i
+        params.insert(2, timestamp.to_s)
+
+        message = [types[type]].pack("C") 
+        message << package_strings(*params)
+
+        @protocol.send_message(Endpoints::NOTIFICATION, message)
+      end
+
+      def package_strings(*parts)
+        max_part_length = 255
+        max_part_length = parts.pop if parts.last.is_a?(Integer)
+
+        message = ""
+        parts.each do |part|
+          part ||= ""
+
+          part = part[0, max_part_length] if part.length > max_part_length
+          message << [part.length].pack("C") + part
+        end
+        message
+      end
   end
 end

data/lib/pebble/watch/event.rb

@@ -7,4 +7,5 @@ module Pebble
 end
 
 require "pebble/watch/log_event"
-require "pebble/watch/media_control_event"
+require "pebble/watch/system_message_event"
+require "pebble/watch/media_control_event"

data/lib/pebble/watch/log_event.rb

@@ -1,7 +1,41 @@
 module Pebble
   class Watch
     class LogEvent < Event
+      attr_accessor :timestamp
+      attr_accessor :level
+      attr_accessor :filename
+      attr_accessor :linenumber
+      attr_accessor :message
 
+      def self.parse(raw_message)
+        return nil if raw_message.length < 8
+
+        timestamp, level, message_size, linenumber = raw_message[0, 8].unpack("L>CCS>")
+        filename  = raw_message[8, 16]
+        message   = raw_message[24, message_size]
+
+        log_levels = {
+          1   => :error,
+          50  => :warning,
+          100 => :info,
+          200 => :debug,
+          250 => :verbose
+        }
+
+        event = new
+
+        event.timestamp   = Time.at(timestamp)
+        event.level       = log_levels[level] || :unknown
+        event.linenumber  = linenumber
+        event.filename    = filename
+        event.message     = message
+
+        event
+      end
+
+      def inspect
+        "[#{self.level.to_s.capitalize}] #{self.message}"
+      end
     end
   end
 end

data/lib/pebble/watch/media_control_event.rb

@@ -1,7 +1,29 @@
 module Pebble
   class Watch
     class MediaControlEvent < Event
+      attr_accessor :button
 
+      BUTTONS = {
+        1 => :playpause,
+        4 => :next,
+        5 => :previous
+      }
+
+      def self.parse(message)
+        button_id = message.unpack("C").first
+
+        return nil unless BUTTONS.has_key?(button_id)
+
+        event = new
+
+        event.button = BUTTONS[button_id]
+
+        event
+      end
+
+      def inspect
+        self.button.to_s.capitalize
+      end
     end
   end
 end

data/lib/pebble/watch/system_message_event.rb

@@ -0,0 +1,23 @@
+module Pebble
+  class Watch
+    class SystemMessageEvent < Event
+      attr_accessor :code
+
+      def self.parse(message)
+        event = new
+
+        event.code = message.length == 2 ? message.unpack("S>").first : -1
+
+        event
+      end
+
+      def message
+        SystemMessages.for_code(self.code) || "Unknown"
+      end
+
+      def inspect
+        "#{self.message} (#{self.code})"
+      end
+    end
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pebblewatch
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.0.2
   prerelease: 
 platform: ruby
 authors:
@@ -9,11 +9,11 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-03-30 00:00:00.000000000 Z
+date: 2013-04-01 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: serialport
-  requirement: &70167654887920 !ruby/object:Gem::Requirement
+  requirement: &70119208390380 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: '1.1'
   type: :runtime
   prerelease: false
-  version_requirements: *70167654887920
+  version_requirements: *70119208390380
 - !ruby/object:Gem::Dependency
   name: rake
-  requirement: &70167654886380 !ruby/object:Gem::Requirement
+  requirement: &70119208388900 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -32,10 +32,10 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70167654886380
+  version_requirements: *70119208388900
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &70167654884180 !ruby/object:Gem::Requirement
+  requirement: &70119208388220 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ! '>='
@@ -43,7 +43,7 @@ dependencies:
         version: '0'
   type: :development
   prerelease: false
-  version_requirements: *70167654884180
+  version_requirements: *70119208388220
 description: A Ruby library for communicating with your Pebble smartwatch.
 email: douwe@selenight.nl
 executables: []
@@ -52,15 +52,16 @@ extra_rdoc_files: []
 files:
 - lib/pebble/capabilities.rb
 - lib/pebble/endpoints.rb
-- lib/pebble/pebblewatch.rb
 - lib/pebble/protocol.rb
 - lib/pebble/system_messages.rb
 - lib/pebble/version.rb
 - lib/pebble/watch/event.rb
 - lib/pebble/watch/log_event.rb
 - lib/pebble/watch/media_control_event.rb
+- lib/pebble/watch/system_message_event.rb
 - lib/pebble/watch.rb
 - lib/pebble.rb
+- lib/pebblewatch.rb
 - LICENSE
 - README.md
 - Rakefile
@@ -80,7 +81,7 @@ required_ruby_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -921215416686416303
+      hash: 4433695980679618883
 required_rubygems_version: !ruby/object:Gem::Requirement
   none: false
   requirements:
@@ -89,7 +90,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
       segments:
       - 0
-      hash: -921215416686416303
+      hash: 4433695980679618883
 requirements: []
 rubyforge_project: 
 rubygems_version: 1.8.6