dropcam 0.0.1

data/.gitignore

@@ -0,0 +1,20 @@
+.DS_Store
+*.flv
+
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,5 @@
+source 'https://rubygems.org'
+
+gem 'awesome_print'
+# Specify your gem's dependencies in dropcam.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 Nolan Brown
+
+MIT License
+
+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,83 @@
+# Dropcam
+
+RubyGem to access Dropcam account and Camera including direct live stream access
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'dropcam'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install dropcam
+
+## Usage
+
+	require 'dropcam'
+	
+	dropcam = Dropcam::Dropcam.new("<USERNAME>","<PASSWORD>")
+	camera = dropcam.cameras.first
+	
+	# returns jpg image data of the latest frame captured
+	screenshot = camera.current_image
+	
+	# write data to disk
+	File.open("#{camera.title}.jpg", 'w') {|f| f.write(screenshot) }
+	
+	# access and modify settings
+	# this disables the watermark on your camera stream
+	settings = camera.settings
+	settings["watermark.enabled"].set(false)
+
+
+## Live Stream
+
+**Streaming isn't directly integrated currently and it's up to you to find a player. Some of the players available:**
+	
+- VLC (RTSP/RTMP)
+- RTMPDump (RTMP)
+- openRTSP (RTSP)
+
+The easiest way to record the live camera stream is with RTMPDump. Install via homebrew:
+	
+	`$ brew install rtmpdump`
+
+To save a live stream:
+
+	require 'dropcam'
+	dropcam = Dropcam::Dropcam.new("<USERNAME>","<PASSWORD>")
+	camera = dropcam.cameras.first
+	
+	# record the live stream for 30 seconds
+	camera.stream.save_live("#{camera.title}.flv", 30)
+	
+	# to get access information to use a third party application
+	# RTMP/Flash Streaming
+	camera.stream.rtmp_details
+	
+	# RTSP Streaming
+	camera.stream.rtsp_details
+	
+
+Currently stream resolution is limited to 400x240.
+
+
+
+## NOTES: ##
+
+The Dropcam API is unofficial and unreleased. This code can break at anytime as Dropcam changes/updates their service. 
+
+This gem has only been tested on Mac OS 10.8 running Ruby 1.9.3
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/dropcam.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'dropcam/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "dropcam"
+  gem.version       = Dropcam::VERSION
+  gem.authors       = ["Nolan Brown"]
+  gem.email         = ["nolanbrown@gmail.com"]
+  gem.description   = %q{Access Dropcam account and cameras}
+  gem.summary       = gem.description
+  gem.homepage      = "https://github.com/nolanbrown/dropcam"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+  
+  
+end

data/example/basics.rb

@@ -0,0 +1,15 @@
+#dropcam = Dropcam::Session.new("username","password")
+lib = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'dropcam'
+require 'awesome_print'
+dropcam = Dropcam::Dropcam.new(ENV["DROPCAM_USERNAME"],ENV["DROPCAM_PASSWORD"])
+camera = dropcam.cameras.first
+ap camera.uuid
+ap camera.session_token
+ap camera.rtsp_url
+ap camera.rtmpdump_stream_command
+
+settings = camera.settings
+#ap settings["watermark.enabled"].set(false)

data/example/camera.rb

@@ -0,0 +1,16 @@
+lib = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'dropcam'
+require 'awesome_print'
+
+dropcam = Dropcam::Dropcam.new(ENV["DROPCAM_USERNAME"],ENV["DROPCAM_PASSWORD"])
+
+all_cameras = dropcam.cameras
+all_cameras.each { |aCamera|
+  puts "\n------------------------------------\n"
+  aCamera.instance_variables.each{|variable|
+    print "#{variable} : "; $stdout.flush
+    ap aCamera.instance_variable_get(variable)
+  }
+}

data/example/notifications.rb

@@ -0,0 +1,19 @@
+lib = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'dropcam'
+require 'awesome_print'
+dropcam = Dropcam::Dropcam.new(ENV["DROPCAM_USERNAME"],ENV["DROPCAM_PASSWORD"])
+camera = dropcam.cameras.first
+camera.notification_devices.each{|notification|
+  # print all variable values
+  notification.instance_variables.each{|variable|
+    print "#{variable} : "; $stdout.flush
+    ap notification.instance_variable_get(variable)
+  }
+  
+  # enable or disable notification
+  # notification.set_enabled(true)
+  puts "\n------------------------------------\n\n"
+  
+}

data/example/settings.rb

@@ -0,0 +1,16 @@
+lib = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'dropcam'
+require 'awesome_print'
+dropcam = Dropcam::Dropcam.new(ENV["DROPCAM_USERNAME"],ENV["DROPCAM_PASSWORD"])
+camera = dropcam.cameras.first
+settings = camera.settings
+
+ap settings
+
+setting_name = "watermark.enabled"
+setting_value = settings[setting_name].value
+puts "Changing #{setting_name} from #{setting_value} to #{!setting_value}"
+settings[setting_name].set(!setting_value)
+puts "Changing #{setting_name} is now #{settings[setting_name].value}"

data/example/stream.rb

@@ -0,0 +1,16 @@
+lib = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require 'dropcam'
+
+dropcam = Dropcam::Dropcam.new(ENV["DROPCAM_USERNAME"],ENV["DROPCAM_PASSWORD"])
+camera = dropcam.cameras.first
+
+puts "\nRTSP URI"
+puts camera.stream.rtsp_uri.to_s
+
+puts "\nRTMPDump command"
+puts camera.stream.rtmpdump
+
+puts "\nSave Live Stream as FLV"
+puts camera.stream.save_live("#{camera.title}.flv",30)

data/lib/dropcam/base.rb

@@ -0,0 +1,126 @@
+require 'uri'
+require 'net/http'
+require 'json'
+
+module Net
+  class HTTPResponse
+    def success?
+      self.code.to_i == 200
+    end
+    def not_found?
+      self.code.to_i == 404
+    end
+    def error?
+      self.code.to_i == 400
+    end
+    def not_authorized?
+      self.code.to_i == 403
+    end
+  end
+end
+
+module Dropcam
+  class Base
+    attr_accessor :session_token, :cookies
+    
+    
+    ::NEXUS_API_BASE = "https://nexusapi.dropcam.com/"
+    
+    ::NEXUS_GET_IMAGE_PATH = "get_image" # uuid and width
+    ::NEXUS_GET_AVAILABLE_PATH = "get_available" # start_time and uuid
+    ::NEXUS_GET_CUEPOINT_PATH = "get_cuepoint" # start_time_uuid
+    ::NEXUS_GET_EVENT_CLIP_PATH = "get_event_clip" # start_time_uuid
+    ::NEXUS_GET_REVERSE_PAGINATED_CUEPOINTS_PATH = "get_reverse_paginated_cuepoint"
+    ::API_BASE = "https://www.dropcam.com"
+    ::API_PATH = "/api/v1"
+    
+    
+    ::CAMERA_HTML_SETTINGS_BASE = "/cameras/settings/" # /uuid
+    
+    ::USERS_LOGIN = "#{API_PATH}/login.login"
+    ::CAMERAS_UPDATE = "#{API_PATH}/cameras.update" # uuid, is_public
+    ::CAMERAS_GET_BY_PUBLIC_TOKEN = "#{API_PATH}/cameras.get_by_public_token"
+    ::CAMERAS_GET = "#{API_PATH}/cameras.get" # uuid
+    ::CAMERAS_GET_VISIBLE = "#{API_PATH}/cameras.get_visible"
+    ::CAMERAS_GET_PUBLIC = "#{API_PATH}/cameras.get_demo"
+    
+    ::DROPCAMS_GET_PROPERTIES = "#{API_PATH}/dropcams.get_properties" # uuid
+    ::DROPCAMS_SET_PROPERTY = "#{API_PATH}/dropcams.set_property" # POST: uuid, key, value
+    ::CAMERA_NOTIFICATION_UPDATE = "#{API_PATH}/camera_notifications.update"
+    ::CAMERA_ADD_EMAIL_NOTIFICATION = "#{API_PATH}/users.add_email_notification_target"
+    ::CAMERA_DELETE_NOTIFICATION = "#{API_PATH}/users.delete_notification_target"
+    ::CAMERA_FIND_NOTIFICATIONS = "#{API_PATH}/camera_notifications.find_by_camera"
+    
+    ::SUBSCRIPTIONS_LIST = "#{API_PATH}/subscriptions.list" # camera_uuid
+    ::SUBSCRIPTIONS_DELETE = "#{API_PATH}/subscriptions.delete"
+    ::SUBSCRIPTIONS_CREATE_PUBLIC = "#{API_PATH}/subscriptions.create_public"
+    ::USERS_GET_SESSION_TOKEN = "#{API_PATH}/users.get_session_token"
+    ::USERS_GET_CURRENT = "#{API_PATH}/users.get_current"
+    
+    ::CLIP_GET_ALL = "#{API_PATH}/videos.get_owned"
+    ::CLIP_CREATE = "#{API_PATH}/videos.request" # POST:  start_date (ex. 1357598395), title, length (in seconds), uuid, description
+    ::CLIP_DELETE = "#{API_PATH}/videos.delete" # DELETE:  id = clip_id
+    
+    ## videos.get # id = clip_id
+    ## videos.download # id = clip_id
+    ## videos.play # id = clip_idß
+    def post(path, parameters, cookies, use_nexus=false)
+
+      http = _dropcam_http(use_nexus)
+      
+      request = Net::HTTP::Post.new(path)
+      request.set_form_data(parameters)
+      
+      request.add_field("Cookie",cookies.join('; ')) if cookies
+
+      response = http.request(request)
+      
+      return response
+    end
+    
+    def get(path, parameters,cookies, use_nexus=false)
+      http = _dropcam_http(use_nexus)
+            
+      query_path = "#{path}"
+      query_path = "#{path}?#{URI.encode_www_form(parameters)}" if parameters.length > 0
+      request = Net::HTTP::Get.new(query_path)      
+      
+      request.add_field("Cookie",cookies.join('; ')) if cookies
+            
+      response = http.request(request)
+      return response
+    end
+    
+    def delete(path, parameters,cookies, use_nexus=false)
+      http = _dropcam_http(use_nexus)
+            
+      query_path = "#{path}"
+      query_path = "#{path}?#{URI.encode_www_form(parameters)}" if parameters.length > 0
+      request = Net::HTTP::Delete.new(query_path)      
+      
+      request.add_field("Cookie",cookies.join('; ')) if cookies
+            
+      response = http.request(request)
+      return response
+    end
+    
+    protected
+    
+    def _dropcam_http(use_nexus)
+      base = API_BASE
+      base = NEXUS_API_BASE if use_nexus
+      uri = URI.parse(base)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = true
+      http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+      #http.set_debug_output($stdout)
+      
+      return http
+    end
+    
+    
+  end
+  
+  
+  
+end

data/lib/dropcam/camera.rb

@@ -0,0 +1,263 @@
+require 'hpricot'
+
+require_relative 'base'
+require_relative 'error'
+require_relative 'notification'
+require_relative 'setting'
+require_relative 'cuepoint'
+require_relative 'clip'
+require_relative 'stream'
+
+module Dropcam
+  class Camera < Base
+    
+    attr_reader :uuid, :notification_devices, :download_host, :download_server_live, :is_streaming, :title, :public_token
+    attr_reader :description, :timezone_utc_offset, :timezone, :is_connected, :is_online, :is_public, :hours_of_recording_max
+    attr_reader :type, :id, :owner_id
+    attr_accessor :settings
+
+    
+    def initialize(uuid, properties={})
+      @uuid = uuid
+      @settings = {}
+      self.properties = properties
+    end
+    
+    def properties=(properties)
+      properties.each{|key, value|
+        instance_variable_set("@#{key}", value)
+      }
+    end
+    
+    
+    def get_image(width=1200, timestamp=nil)
+      params = {"uuid"=>@uuid, "width" => width}
+      params["time"] = timestamp if timestamp
+      
+      response = get(::IMAGE_PATH, params, @cookies, true)      
+      if response.success?
+        return response.body
+      elsif response.not_authorized?
+        raise AuthorizationError 
+      else 
+        raise CameraNotFoundError 
+      end
+    end
+    
+    def current_image(width=1200)
+      return get_image(width)
+    end
+    
+    def clips
+      response = get(::CLIP_GET_ALL, {}, @cookies)      
+      if response.success?
+        return response.body ## returns a zip
+        clips = []
+        all_clips = JSON.parse(response.body)["items"]
+        for clip in all_clips
+          c = Clip.new(self, clip)
+          if c.camera_id == self.id
+            clips.push c
+          end
+        end
+        return clips
+      elsif response.not_authorized?
+        raise AuthorizationError 
+      else 
+        raise CameraNotFoundError 
+      end
+    end
+    
+    
+    def create_clip(length, start_date, title, description)
+      params = {"uuid"=>@uuid, "length" => length, "start_date" => start_date, "title" => title, "description" => description}
+      response = post(::VIDEOS_REQUEST, params, @cookies)      
+      if response.success?
+        clip_info = JSON.parse(response.body)["items"][0]
+        return Clip.new(self, clip_info)
+      elsif response.not_authorized?
+        raise AuthorizationError 
+      else 
+        raise CameraNotFoundError 
+      end
+    end
+    
+    
+    def get_event_clip_image_archive(cuepoint_id, number_of_frames, width)      
+      params = {"uuid"=>@uuid, "width" => width, "cuepoint_id" => cuepoint_id, "num_frames" => number_of_frames, "format" => "TAR_JPG"}
+      response = get(::NEXUS_GET_EVENT_CLIP_PATH, params, @cookies, true)      
+      if response.success?
+        return response.body ## returns a zip
+      elsif response.not_authorized?
+        raise AuthorizationError 
+      else 
+        raise CameraNotFoundError 
+      end
+    end
+    
+    def get_event_clip_video(cuepoint_id, number_of_frames, width)      
+      params = {"uuid"=>@uuid, "width" => width, "cuepoint_id" => cuepoint_id, "num_frames" => number_of_frames, "format" => "h264"}
+      response = get(::NEXUS_GET_EVENT_CLIP_PATH, params, @cookies, true)      
+      if response.success?
+        return response.body ## returns a zip
+      elsif response.not_authorized?
+        raise AuthorizationError 
+      else 
+        raise CameraNotFoundError 
+      end
+    end
+    
+    def get_all_cuepoints(limit=2500)
+      params = {"uuid"=>@uuid, "max_results"=>limit}
+      response = get(::NEXUS_GET_REVERSE_PAGINATED_CUEPOINTS_PATH, params, @cookies, true)      
+      if response.success?
+        cuepoints = []
+        all_cuepoints = JSON.parse(response.body)
+        for cuepoint in all_cuepoints
+          cuepoints.push Cuepoint.new(cuepoint)
+        end
+        
+        return cuepoints
+      elsif response.not_authorized?
+        raise AuthorizationError 
+      else 
+        raise CameraNotFoundError 
+      end
+    end
+        
+    def get_cuepoint(start_time)
+      params = {"uuid"=>@uuid, "start_time" => start_time}
+      response = get(::NEXUS_GET_CUEPOINT_PATH, params, @cookies, true)      
+      if response.success?
+        return Cuepoint.new(JSON.parse(response.body)[0])        
+      elsif response.not_authorized?
+        raise AuthorizationError 
+      else 
+        raise CameraNotFoundError 
+      end
+    end
+    
+    def update_info
+      response = get(::CAMERAS_GET, {"id"=>@uuid}, @cookies)      
+      if response.success?
+        self.properties = JSON.parse(response.body)["items"][0]
+      elsif response.not_authorized?
+        raise AuthorizationError 
+      else 
+        raise CameraNotFoundError 
+      end
+    end
+    
+    
+    
+    def public=(is_public)
+      response = post(::CAMERAS_UPDATE, {"uuid"=>@uuid, "is_public"=>is_public, "accepted_public_terms_at" => "true"}, @cookies)      
+      if response.success?
+        self.properties = JSON.parse(response.body)["items"][0]
+      elsif response.not_authorized?
+        raise AuthorizationError 
+      else 
+        raise CameraNotFoundError 
+      end
+    end
+    
+    def public?
+      @is_public
+    end
+    
+    def set_public_token(token)
+      response = post(::CAMERAS_UPDATE, {"uuid"=>@uuid, "token"=>token}, @cookies)      
+      if response.success?
+        self.properties = JSON.parse(response.body)["items"][0]
+        return true
+      elsif response.not_authorized?
+        raise AuthorizationError 
+      else 
+        raise CameraNotFoundError 
+      end
+    end
+    
+    def settings=(new_settings)
+      @settings = {}
+      new_settings.each{|key,value|
+        @settings[key] = Setting.new(key, value, self)
+      }
+      @settings
+    end
+    
+    def settings(force=false)
+      return @settings unless force == true or @settings.length == 0 # key these cached
+      
+      response = get(::DROPCAMS_GET_PROPERTIES, {"uuid"=>@uuid}, @cookies)      
+      if response.success?
+        self.settings = JSON.parse(response.body)["items"][0]
+        return @settings
+      elsif response.not_authorized?
+        raise AuthorizationError 
+      else 
+        raise CameraNotFoundError 
+      end
+    end
+    
+    def notification_devices
+      
+      response = get(::CAMERA_FIND_NOTIFICATIONS, { "id" => @uuid }, @cookies)      
+      if response.success?
+        notifications = []
+
+        all_notifications = JSON.parse(response.body)["items"]
+        all_notifications.each{|note|
+          notifications.push Notification.new(self, note["target"])
+        }
+        
+        notifications
+      elsif response.not_authorized?
+        raise AuthorizationError 
+      else 
+        raise CameraNotFoundError 
+      end
+    end
+    
+    ## API for Notifications doesn't include email notifcations
+    ## The code below parses an HTML Partial to get all notifcation values
+    
+    def all_notification_devices
+      request_path = ::CAMERA_HTML_SETTINGS_BASE + @uuid
+      response = get(request_path, {}, @cookies)      
+      if response.success?
+        raw_html = response.body
+        doc = Hpricot.parse(raw_html)
+    
+        notifications = []
+        doc.search("//div[@class='notification_target']").each { |notification_target|
+          puts notification_target
+          data_id =  notification_target.get_attribute("data-id")
+          puts data_id
+          name =  notification_target.at("div/span").inner_text
+          
+          input =  notification_target.at("div/input")
+    
+          attributes = input.attributes.to_hash
+          data_type = attributes["data-type"]
+          data_value = attributes["data-value"]
+          checked = attributes.has_key?("checked")
+          
+    
+          notifications.push(note)
+        }
+        return notifications
+      elsif response.not_authorized?
+        raise AuthorizationError 
+      else 
+        raise CameraNotFoundError 
+      end
+    end
+    
+    
+    
+    def stream
+      Stream.new self
+    end
+      
+  end
+end

data/lib/dropcam/clip.rb

@@ -0,0 +1,52 @@
+module Dropcam
+  class Clip
+    attr_reader :id, :public_link, :description, :title, :is_error, :start_time, :server, :camera_id, :generated_time
+    attr_reader :filename, :length_in_seconds
+    
+    attr_accessor :properties
+    def initialize(camera, properties = nil)
+      @camera = camera
+      self.properties = properties
+    end
+    
+    def properties=(properties)
+      properties.each{|key, value|
+        instance_variable_set("@#{key}", value)
+      }
+      @properties = properties
+    end
+    
+    def direct_link
+      return "https://#{@server}/#{@filename}"
+    end
+    def direct_screenshot_link
+      return "https://#{@server}/s3#{File.basename(@filename, File.extname(@filename))}.jpg"
+    end
+
+    def set_title(title)
+      return false unless @id
+      response = post(::CLIP_DELETE, { "id" => @id, "title" => title }, @cookies)      
+      if response.success?
+        return true
+      elsif response.not_authorized?
+        raise AuthorizationError 
+      else 
+        raise CameraNotFoundError 
+      end
+      
+    end
+    
+    def delete
+      return false unless @id
+      response = post(::CLIP_DELETE, { "id" => @id }, @cookies)      
+      if response.success?
+        return true
+      elsif response.not_authorized?
+        raise AuthorizationError 
+      else 
+        raise CameraNotFoundError 
+      end
+    end
+    
+  end
+end

data/lib/dropcam/cuepoint.rb

@@ -0,0 +1,11 @@
+module Dropcam
+  class Cuepoint
+    attr_reader :id, :note, :type, :time
+    def initialize(details)
+      @id = details["id"]
+      @note = details["note"]
+      @type = details["type"]
+      @time = details["time"]
+    end
+  end
+end

data/lib/dropcam/error.rb

@@ -0,0 +1,28 @@
+module Dropcam
+  class AuthenticationError < StandardError
+    def initialize(msg = "Invalid Credentials")
+      super(msg)
+    end
+  end
+  class AuthorizationError < StandardError
+    def initialize(msg = "Not Authorized")
+      super(msg)
+    end
+  end
+  class CameraNotFoundError < StandardError
+    def initialize(msg = "Camera Not Found")
+      super(msg)
+    end
+  end
+  class UnkownError < StandardError
+    def initialize(msg = "Unkown Error")
+      super(msg)
+    end
+  end
+  class RequestError < StandardError
+    def initialize(msg = "Request Error")
+      super(msg)
+    end
+  end
+
+end

data/lib/dropcam/notification.rb

@@ -0,0 +1,66 @@
+module Dropcam
+  class Notification < Base
+    
+    attr_accessor :name, :type, :value, :is_enabled, :id
+    
+    def initialize(camera, properties={})
+      @camera = camera
+      @name = properties["name"]
+      @type = properties["type"]
+      @value = properties["value"]
+      @id = properties["id"]
+      @is_enabled = properties["enabled"]
+    end
+    
+    def find(name)
+      note = @camera.notification_devices.select{|note|
+        if note.name == name
+          puts "#{note.name} == #{name}"
+          return note
+        end
+      }
+      note
+    end
+    
+    def create(email)
+      # {"status": 400, "items": [], "status_description": "bad-request", "status_detail": "This notification target already exists"}
+      response = post(::CAMERA_ADD_EMAIL_NOTIFICATION, {"email"=>email}, @camera.cookies)     
+      if response.success?
+        return Notification.new(@camera, JSON.parse(response.body)["items"][0])
+      elsif response.error?
+        raise UnkownError, JSON.parse(response.body)["status_detail"]
+      elsif response.not_authorized?
+        raise AuthorizationError 
+      else 
+        raise CameraNotFoundError 
+      end
+    end
+    
+    def set(enable)
+      # email or gcm or apn
+      params = {"id"=>@camera.uuid, "is_enabled"=>enable, "device_token" => @value}
+      puts params
+      response = post(::CAMERA_NOTIFICATION_UPDATE, params, @camera.cookies)      
+      if response.success?
+        return true
+      elsif response.not_authorized?
+        raise AuthorizationError 
+      else 
+        raise CameraNotFoundError 
+      end
+    end
+    
+    def delete(notifcation_id=nil)
+      notifcation_id = @id unless notifcation_id
+      response = post(::CAMERA_DELETE_NOTIFICATION, {"id"=>notifcation_id}, @camera.cookies)      
+      if response.success?
+        return true
+      elsif response.not_authorized?
+        raise AuthorizationError 
+      else 
+        raise CameraNotFoundError 
+      end
+    end
+
+  end
+end

data/lib/dropcam/session.rb

@@ -0,0 +1,47 @@
+require_relative 'base'
+module Dropcam
+  class Session < Base
+    
+    attr_accessor :session_token, :cookies
+    def initialize(username, password)
+      @username = username
+      @password = password
+    end
+    
+    def authenticate
+      
+      params = {"username" => @username, "password" => @password}
+      response = post(::USERS_LOGIN, params, nil)
+      all_cookies = response.get_fields('set-cookie') # only cookies are set on valid credentials
+      
+      ## for some reason, dropcam responds with 200 on invalid credentials
+      if response.success? and all_cookies
+        
+        cookies = []
+        all_cookies.each { | cookie |
+            cookies.push(cookie.split('; ')[0])
+        }
+        
+        @cookies = cookies
+        @session_token = _session_token # this value is embedded in the cookie but leaving this as is incase the API changes
+        
+      else
+        raise AuthenticationError, "Invalid Credentials"
+      end      
+    end
+        
+        
+    
+    protected
+    def _session_token
+      response = get(::USERS_GET_SESSION_TOKEN, {}, @cookies)
+      if response.success?
+        response_json = JSON.parse(response.body)
+        token = response_json["items"][0]
+        return token
+      end
+      return nil
+    end
+
+  end
+end

data/lib/dropcam/setting.rb

@@ -0,0 +1,38 @@
+module Dropcam
+  class Setting < Base
+    # 
+    attr_accessor :name
+    def initialize(name, value, camera)
+      @camera = camera
+      @name = name
+      @current_value = value
+    end
+    
+    def value
+      return false if @current_value == 'false'
+      return true if @current_value == 'true'
+      
+      @current_value
+    end
+    
+    def to_s
+      "<Dropcam::Setting:#{object_id} @name=#{@name} @value=#{@current_value}>"
+    end
+    
+    def set(value)
+      response = post(::DROPCAMS_SET_PROPERTY, {"uuid"=>@camera.uuid, "key" => @name, "value" => value}, @camera.cookies)     
+      if response.success?
+        @current_value = value
+        @camera.settings = JSON.parse(response.body)["items"][0]
+        true
+      elsif response.error?
+        raise UnkownError, JSON.parse(response.body)["status_detail"]
+      elsif response.not_authorized?
+        raise AuthorizationError 
+      else 
+        raise CameraNotFoundError 
+      end
+    end
+    
+  end
+end

data/lib/dropcam/stream.rb

@@ -0,0 +1,96 @@
+require 'Open3'
+require 'timeout'
+module Dropcam
+  class Stream
+    DEFAULT_RTSP_PORT = "554"
+    BUFFER_SIZE = 1024
+    
+    attr_reader :camera
+    def initialize(camera)
+      @camera = camera
+    end
+    def rtsp_details
+      {
+        :protocol => "rtsp",
+        :user => "user",
+        :password => @camera.session_token,
+        :base => URI.parse(@camera.download_host).scheme,
+        :path => @camera.uuid,
+        :port => DEFAULT_RTSP_PORT
+      }
+    end
+    def rtsp_uri
+      URI.parse "rtsp://user:#{@camera.session_token}@#{URI.parse(@camera.download_host).scheme}:#{DEFAULT_RTSP_PORT}/#{@camera.uuid}"
+    end
+    
+    def rtmp_details
+      {
+        :app => "nexus",
+        :host => "stream.dropcam.com",
+        :playpath => @camera.uuid,
+        :variables => { "S:" => @camera.session_token }
+      }
+    end
+    
+    def rtmpdump
+      stream_command = "rtmpdump --live --app nexus --host stream.dropcam.com --playpath " + @camera.uuid
+      stream_command += " --conn S:" + @camera.session_token
+      return stream_command
+    end
+    
+    def save_live(filename, duration=30)
+      raise StandardError, "RTMPDump is not found in your PATH" unless system("which -s rtmpdump")
+      # we add 10 seconds because it take about that amount of time to get the stream up and running with rtmpdump
+      run_with_timeout("#{self.rtmpdump} --quiet --flv #{filename}", duration+10, 1)
+    end
+    
+    private
+    
+    # Runs a specified shell command in a separate thread.
+    # If it exceeds the given timeout in seconds, kills it.
+    # Returns any output produced by the command (stdout or stderr) as a String.
+    # Uses Kernel.select to wait up to the tick length (in seconds) between 
+    # checks on the command's status
+    #
+    # If you've got a cleaner way of doing this, I'd be interested to see it.
+    # If you think you can do it with Ruby's Timeout module, think again.
+    
+    ## VIA https://gist.github.com/1032297
+    def run_with_timeout(command, timeout, tick)
+      output = ''
+      begin
+        # Start task in another thread, which spawns a process
+        stdin, stderrout, thread = Open3.popen2e(command)
+        # Get the pid of the spawned process
+        pid = thread[:pid]
+        start = Time.now
+
+        while (Time.now - start) < timeout and thread.alive?
+          # Wait up to `tick` seconds for output/error data
+          Kernel.select([stderrout], nil, nil, tick)
+          # Try to read the data
+          begin
+            #output << stderrout.read_nonblock(BUFFER_SIZE)
+          rescue IO::WaitReadable
+            # A read would block, so loop around for another select
+          rescue EOFError
+            # Command has completed, not really an error...
+            break
+          end
+        end
+        # Give Ruby time to clean up the other thread
+        sleep 1
+
+        if thread.alive?
+          # We need to kill the process, because killing the thread leaves
+          # the process alive but detached, annoyingly enough.
+          Process.kill("TERM", pid)
+        end
+      ensure
+        stdin.close if stdin
+        stderrout.close if stderrout
+      end
+      return output
+    end
+  end
+end

data/lib/dropcam/version.rb

@@ -0,0 +1,3 @@
+module Dropcam
+  VERSION = "0.0.1"
+end

data/lib/dropcam.rb

@@ -0,0 +1,65 @@
+require "dropcam/version"
+require "dropcam/base"
+require "dropcam/camera"
+require "dropcam/session"
+
+module Dropcam
+  class Dropcam < Base
+    attr_reader :session
+    def initialize(username, password)
+      @session = Session.new(username, password)
+      @session.authenticate
+      ## 
+    end
+    def camera(uuid)
+      c = Camera.new(uuid)
+      c.cookies = @session.cookies
+      c.session_token = @session.session_token
+      c.properties = c.info      
+      c
+    end
+    
+    def get_public_camera(token)
+      response = get(::CAMERAS_GET_BY_PUBLIC_TOKEN, {"token"=>token, "return_deleted"=>true}, @session.cookies)      
+      if response.success?
+        return response.body
+      elsif response.not_authorized?
+        raise AuthorizationError 
+      else 
+        raise CameraNotFoundError 
+      end
+    end
+    
+    def public_cameras      
+      response = get(::CAMERAS_GET_PUBLIC, {}, @session.cookies)
+      cameras = []
+      if response.success?
+        response_json = JSON.parse(response.body)
+        owned = response_json["items"][0]["owned"]
+        owned.each{|camera|
+          c = Camera.new(camera["uuid"], camera)
+          c.cookies = @session.cookies
+          c.session_token = @session.session_token
+          cameras.push(c)
+        }
+      end
+      return cameras
+    end
+    
+    def cameras      
+      response = get(::CAMERAS_GET_VISIBLE, {"group_cameras" => true}, @session.cookies)
+      cameras = []
+      if response.success?
+        response_json = JSON.parse(response.body)
+        owned = response_json["items"][0]["owned"]
+        owned.each{|camera|
+          c = Camera.new(camera["uuid"], camera)
+          c.cookies = @session.cookies
+          c.session_token = @session.session_token
+          cameras.push(c)
+        }
+      end
+      return cameras
+    end
+  end
+end

metadata

@@ -0,0 +1,67 @@
+--- !ruby/object:Gem::Specification
+name: dropcam
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Nolan Brown
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-01-12 00:00:00.000000000 Z
+dependencies: []
+description: Access Dropcam account and cameras
+email:
+- nolanbrown@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- dropcam.gemspec
+- example/basics.rb
+- example/camera.rb
+- example/notifications.rb
+- example/settings.rb
+- example/stream.rb
+- lib/dropcam.rb
+- lib/dropcam/base.rb
+- lib/dropcam/camera.rb
+- lib/dropcam/clip.rb
+- lib/dropcam/cuepoint.rb
+- lib/dropcam/error.rb
+- lib/dropcam/notification.rb
+- lib/dropcam/session.rb
+- lib/dropcam/setting.rb
+- lib/dropcam/stream.rb
+- lib/dropcam/version.rb
+homepage: https://github.com/nolanbrown/dropcam
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Access Dropcam account and cameras
+test_files: []