hybridgroup-pebblewatch 0.0.3

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 937789bdc1fc2b9c6c8c925996d0167f408ebb60
+  data.tar.gz: 3f1f77aa03e41f69d185a7abb47c8fc401dd8a7b
+SHA512:
+  metadata.gz: 54c63c16810a10685fb2c9fb424a3c194aa5cb9a53c80ad55d619d900be76a920855e4b3e037d79468017559884c159fc70d18cf18f667fc31e8dfbe33fc9154
+  data.tar.gz: b8752582686510075a44f0b4bffe8fd5b4c2b2c0b47c2489915d5650d0668c463ce6b8f05be3b1b6753b3bacee900f3bf01846f20ba1e8e0641fa261c6dee1fa

data/Gemfile

@@ -0,0 +1,3 @@
+source 'https://rubygems.org'
+
+gemspec

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2013 Douwe Maan
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,153 @@
+# pebblewatch
+
+A Ruby library for communicating with your Pebble smartwatch.
+
+The protocol implementation was based on the documentation at http://pebbledev.org/, the Python implementation at [Hexxeh/libpebble](https://github.com/Hexxeh/libpebble) and the .NET implementation at [barometz/flint](https://github.com/barometz/flint).
+
+## To Do
+
+- [x] Basic protocol communication
+- [x] Sending of messages (notifications etc)
+- [x] Receiving of events (log, music control)
+- [ ] Full 2-way app message support
+- [ ] Firmware/app uploading
+- [ ] CLI
+- [ ] REPL
+
+## Installation
+
+```sh
+gem install pebblewatch
+```
+
+## Usage
+
+Make sure your Pebble is paired with 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"
+
+# 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 had 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. 
+# Because we also want 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
+```
+
+Oh, and if you want to do some lower level stuff, have a look at [`Pebble::Protocol`](lib/pebble/protocol.rb) which you can access through `watch.protocol`.
+
+```ruby
+watch.protocol.on_receive(endpoint) do |message|
+  # Do whatever
+end
+
+watch.protocol.send_message(endpoint, message)
+```
+
+## Examples
+Check out the [`examples/`](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
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,17 @@
+require "rspec/core/rake_task"
+
+spec = Gem::Specification.load("pebblewatch.gemspec")
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec
+
+desc "Build the .gem file"
+task :build do
+  system "gem build #{spec.name}.gemspec"
+end
+
+desc "Push the .gem file to rubygems.org"
+task release: :build do
+  system "gem push #{spec.name}-#{spec.version}.gem"
+end

data/lib/pebble/capabilities.rb

@@ -0,0 +1,26 @@
+module Pebble
+  module Capabilities
+    module Session
+      GAMMA_RAY = 0x80000000
+    end
+
+    module Client
+      UNKNOWN = 0
+      IOS     = 1
+      ANDROID = 2
+      OSX     = 3
+      LINUX   = 4
+      WINDOWS = 5
+
+      TELEPHONY     = 16
+      SMS           = 32
+      GPS           = 64
+      BTLE          = 128
+      # 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
+      COMPASS       = 2048
+    end
+  end
+end

data/lib/pebble/endpoints.rb

@@ -0,0 +1,30 @@
+module Pebble
+  module Endpoints
+    FIRMWARE            = 1
+    TIME                = 11
+    VERSION             = 16
+    PHONE_VERSION       = 17
+    SYSTEM_MESSAGE      = 18
+    MUSIC_CONTROL       = 32
+    PHONE_CONTROL       = 33
+    APPLICATION_MESSAGE = 48
+    LAUNCHER            = 49
+    LOGS                = 2000
+    PING                = 2001
+    DRAW                = 2002
+    RESET               = 2003
+    APP                 = 2004
+    NOTIFICATION        = 3000
+    RESOURCE            = 4000
+    SYS_REG             = 5000
+    FCT_REG             = 5001
+    APP_INSTALL_MANAGER = 6000
+    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

@@ -0,0 +1,162 @@
+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
+      if @port.is_a?(String)
+        @serial_port = SerialPort.new(@port, baudrate: 115200)
+        @serial_port.read_timeout = 500
+      else
+        @serial_port = @port
+      end
+      
+      @connected = true
+      Pebble.logger.debug "Connected to port #{@port}"
+      
+      @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 ||= ""
+
+      Pebble.logger.debug "Sending #{Endpoints.for_code(endpoint) || 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
+        Pebble.logger.debug "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)
+
+          Pebble.logger.debug "Received #{Endpoints.for_code(endpoint) || endpoint}: #{message.inspect}"
+
+          trigger_received(endpoint, message)
+        end
+      rescue IOError => e
+        if @connected
+          Pebble.logger.debug "Lost connection"
+          @connected = false
+          raise Errors::LostConnection
+        end
+      ensure
+        Pebble.logger.debug "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

@@ -0,0 +1,16 @@
+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

@@ -0,0 +1,3 @@
+module Pebble
+  VERSION = "0.0.3"
+end

data/lib/pebble/watch/app_message_event.rb

@@ -0,0 +1,60 @@
+module Pebble
+  class Watch
+    class AppMessageEvent < Event
+      module TupleType
+        ByteArray       = 0
+        String          = 1
+        UnsignedInteger = 2
+        Integer         = 3
+      end
+
+      attr_accessor :transaction_id
+      attr_accessor :uuid
+      attr_accessor :data
+
+      def self.parse(raw_message)
+        return nil if raw_message.length < 19
+
+        message_type, transaction_id, uuid, dictionary_length = raw_message[0, 19].unpack("CCA16C")
+
+        data = {}
+
+        offset = 19
+        dictionary_length.times do |i|
+          key, tuple_type, item_length = raw_message[offset, 7].unpack("CL>S<")
+          offset += 7
+
+          format = case tuple_type
+          when TupleType::ByteArray;      "a*"
+          when TupleType::String;         "A*"
+          when TupleType::UnsignedInteger
+            case item_length
+            when 1; "C"
+            when 2; "S<"
+            when 4; "L<"
+            end
+          when TupleType::Integer
+            case item_length
+            when 1; "c"
+            when 2; "s<"
+            when 4; "l<"
+            end
+          end
+
+          item_data = raw_message[offset, item_length].unpack(format).first
+          offset += item_length
+
+          data[key] = item_data
+        end
+
+        event = new
+
+        event.transaction_id  = transaction_id
+        event.uuid            = uuid
+        event.data            = data
+
+        event
+      end
+    end
+  end
+end

data/lib/pebble/watch/event.rb

@@ -0,0 +1,14 @@
+module Pebble
+  class Watch
+    class Event
+      def self.parse(message)
+        new
+      end
+    end
+  end
+end
+
+require "pebble/watch/log_event"
+require "pebble/watch/system_message_event"
+require "pebble/watch/media_control_event"
+require "pebble/watch/app_message_event"

data/lib/pebble/watch/log_event.rb

@@ -0,0 +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

@@ -0,0 +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

data/lib/pebble/watch.rb

@@ -0,0 +1,279 @@
+require "pebble/watch/event"
+
+module Pebble
+  class Watch
+    module Errors
+      class NoWatchesFound < StandardError; end
+    end
+
+    def self.autodetect
+      return nil unless RUBY_PLATFORM =~ /darwin/
+
+      watches = Dir.glob("/dev/tty.Pebble????-SerialPortSe")
+
+      raise Errors::NoWatchesFound if watches.length == 0
+      Pebble.logger.debug "Found multiple watches: #{watches}" if watches.length > 1
+
+      port = watches.first
+      id = port[15, 4]
+      Pebble.logger.debug "Detected 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
+      log_log_events
+    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)
+      Pebble.logger.debug "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],
+          [:app_message,    Endpoints::APPLICATION_MESSAGE, AppMessageEvent]
+        ]
+
+        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 log_log_events
+        on_event(:log) do |event|
+          case event.level
+          when :error
+            Pebble.logger.error event.message
+          when :warning
+            Pebble.logger.warn event.message
+          when :info
+            Pebble.logger.info event.message
+          when :debug, :verbose
+            Pebble.logger.debug event.message
+          else
+            Pebble.logger.info event.message
+          end
+        end
+      end
+
+      def trigger_event(name, event)
+        Pebble.logger.debug "Triggering 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.rb

@@ -0,0 +1,25 @@
+require "logger"
+
+module Pebble
+  def self.logger=(new_logger)
+    @@logger = new_logger
+  end
+
+  def self.logger
+    return @@logger if defined?(@@logger)
+    @@logger = default_logger
+  end
+
+  def self.default_logger
+    logger = Logger.new(STDOUT)
+    logger.level = Logger::INFO
+    logger
+  end
+end
+
+require "pebble/version"
+require "pebble/endpoints"
+require "pebble/capabilities"
+require "pebble/system_messages"
+require "pebble/protocol"
+require "pebble/watch"

data/lib/pebblewatch.rb

@@ -0,0 +1 @@
+require "pebble"

metadata

@@ -0,0 +1,105 @@
+--- !ruby/object:Gem::Specification
+name: hybridgroup-pebblewatch
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- Douwe Maan
+- Ron Evans
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-06-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: serialport
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: A Ruby library for communicating with your Pebble smartwatch.
+email:
+- douwe@selenight.nl
+- artoo@hybridgroup.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/pebblewatch.rb
+- lib/pebble.rb
+- lib/pebble/protocol.rb
+- lib/pebble/capabilities.rb
+- lib/pebble/system_messages.rb
+- lib/pebble/watch.rb
+- lib/pebble/watch/system_message_event.rb
+- lib/pebble/watch/app_message_event.rb
+- lib/pebble/watch/media_control_event.rb
+- lib/pebble/watch/event.rb
+- lib/pebble/watch/log_event.rb
+- lib/pebble/version.rb
+- lib/pebble/endpoints.rb
+- LICENSE
+- README.md
+- Rakefile
+- Gemfile
+homepage: https://github.com/hybridgroup/pebblewatch
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.3
+signing_key: 
+specification_version: 4
+summary: Pebble communication library
+test_files: []