remotedroid 0.4.2 → 0.5.2

data/lib/remotedroid/client.rb

@@ -0,0 +1,167 @@
+module RemoteDroid
+
+  class Client
+    using ColouredText
+    
+    def initialize(hostx='127.0.0.1', host: hostx, port: '5777', sps_host: 'sps.home', sps_port: '59000')
+      @drb = OneDrb::Client.new host: host, port: port    
+      @sps = SPSPub.new host: sps_host, port: sps_port
+    end
+    
+    def control
+      @drb.control
+    end
+    
+    def export(s)
+      @drb.export(s)
+    end
+    
+    def invoke(s, *args)
+      @drb.invoke(s, *args)
+    end
+    
+    def macros()
+      @drb.macros
+    end
+    
+    def query(id=nil)
+      
+      return @drb.query unless id
+      t = Time.now
+      h = @drb.query(id)
+      h.merge({latency: (Time.now - t).round(3)})
+      
+    end
+    
+    def run_macro(name)
+      a = @drb.run_macro name
+      a.each {|msg| @sps.notice 'macrodroid/action: ' + msg }
+    end
+    
+    def update(key, val)
+      @drb.update key.to_sym, val
+    end
+    
+    def store()
+      @drb.store
+    end
+    
+    def syslog()
+      @drb.syslog
+    end
+    
+    # -- helpful methods -----------------
+    
+    def battery()
+      query.battery
+    end
+    
+    def cell_tower()
+      query.cell_tower
+    end
+    
+    def disable(macro)
+      control.disable macro
+    end
+    
+    def enable(macro)
+      control.enable macro
+    end    
+    
+    def hotspot(state=nil)      
+      control.hotspot state
+    end    
+    
+    def location()
+      query.location
+    end
+    
+    def location_watch(refresh: '1 minute', interval: refresh, 
+                       duration: '30 minutes')
+      
+
+      d = ChronicDuration.parse(duration)
+      seconds = ChronicDuration.parse(interval)
+      puts ("monitoring location every %s for %s" % [interval, duration]).info
+
+      Thread.new do      
+        
+        t = Time.now + d
+
+        begin
+
+          query.location
+          sleep seconds
+
+        end until Time.now >= t
+        
+      end
+      
+    end
+    
+    def photo()
+      take_picture
+    end
+    
+    def say(text)
+      control.speak_text text
+    end
+    
+    def say_time()
+      control.say_time
+    end
+    
+    alias saytime say_time
+    
+    def screen(state=nil)      
+      control.screen state
+    end
+    
+    def screen_on()
+      screen :on
+    end
+    
+    def screen_off()
+      screen :off
+    end
+    
+    def stay_awake()
+      control.stay_awake
+    end
+    
+    def stay_awake_off()
+      control.stay_awake_off
+    end
+    
+    def take_picture(ftp_src: nil, fileout: '.')
+      
+      #screen.on
+      r = query.take_picture
+            
+      if ftp_src then
+        
+        # give the device a second to write the image to file
+        sleep 1
+        
+        credentials, dir = ftp_src.match(/(ftp:\/\/[^\/]+)\/([^$]+)/).captures
+        ftp = MyMediaFTP.new(credentials)
+        ftp.cd dir
+        filename = ftp.ls.sort_by {|x| x[:ctime]}.last[:name]
+        ftp.cp filename, fileout
+        
+      end
+      
+    end   
+    
+    alias take_photo take_picture
+    
+    def torch()
+      control.torch
+    end    
+    
+    def vibrate
+      control.vibrate
+    end
+      
+  end
+end

data/lib/remotedroid/control.rb

@@ -0,0 +1,194 @@
+module RemoteDroid
+
+  class Control        
+    
+    def initialize(dev=nil, deviceid: dev, remote_url: nil, debug: false)
+      
+      @deviceid, @remote_url, @debug = deviceid, remote_url, debug
+
+    end    
+    
+    def bluetooth()
+      @bluetooth
+    end
+    
+    def camera_flash_light(options={})
+      http_exec 'camera-flash-light', options
+    end
+    
+    def disable(macro)
+      http_exec 'disable-macro', {name: macro}
+    end
+    
+    def enable(macro)
+      http_exec 'enable-macro', {name: macro}
+    end    
+    
+    def hotspot(state=nil)      
+      
+      if state then
+        http_exec 'hotspot', {enable: state == :enable} 
+      else        
+
+        def self.enable()
+          http_exec 'hotspot', {enable: true}
+        end                
+        
+        def self.on()
+          self.enable
+        end                
+        
+        def self.disable()
+          http_exec 'hotspot', {enable: false} 
+        end
+        
+        def self.off()
+          self.disable
+        end         
+        
+        self
+        
+      end
+    end    
+        
+    def http_exec(command, options={})
+      
+      url = "https://trigger.macrodroid.com/%s/%s" % [@deviceid, command]
+      
+      if options and options.any? then
+        h = options
+        url += '?' + \
+            URI.escape(h.map {|key,value| "%s=%s" % [key, value]}.join('&'))
+      end
+      
+      s = open(url).read
+      
+    end
+    
+    def location(options={})
+      http_exec 'location'
+    end    
+    
+    def say_current_time(options={})
+      http_exec 'say-current-time'
+    end    
+    
+    alias say_time say_current_time
+    
+    def screen(state=nil)      
+      
+      if state then
+        http_exec 'screen', {on: state == :on} 
+      else        
+        
+        def self.on()
+          http_exec 'screen', {on: true}
+        end
+        
+        def self.off()
+          http_exec 'screen', {on: false} 
+        end
+        
+        self
+        
+      end
+    end
+    
+    def share_location(options={})
+      http_exec 'share-location'
+    end
+    
+    def speak_text(obj)
+      
+      options = case obj
+      when String
+        {text: obj}
+      when Hash
+        obj
+      end
+    
+      http_exec 'speak-text', options
+    end
+    
+    alias say speak_text
+    
+    def stay_awake(options={})
+      http_exec 'stay-awake', options
+    end
+
+    def stay_awake_off(options={})
+      http_exec 'stay-awake-off', options
+    end
+    
+    def take_picture(options={})
+      http_exec 'take-picture', options
+    end
+    
+    alias take_photo take_picture
+
+    
+    def toast(options={})
+      http_exec :toast, options
+    end
+    
+    def torch(options={})
+      http_exec :torch 
+    end
+    
+    def vibrate(options={})
+      http_exec :vibrate
+    end    
+
+
+    def write(s)
+            
+      d = MacroDroid.new(RD_MACROS, deviceid: @deviceid, 
+                     remote_url: @remote_url, debug: false)
+      
+      a = d.macros.select do |macro|
+        
+        macro.triggers.find {|trigger| trigger.is_a? WebHookTrigger }.nil?
+        
+      end
+      puts 'a: ' + a.length.inspect
+      
+      aux_macros = %w(Disable Enable).map do |state|
+        
+        rows = a[1..-1].map do |macro|
+        
+"  Else If name = #{macro.title}
+    #{state} macro
+      #{macro.title}"
+        end
+
+        "
+m: #{state} macro
+v: name
+t: webhook
+a:
+  If name = #{a[0].title}
+    #{state} macro
+      #{a[0].title}
+#{rows.join("\n")}
+  End If
+"     end
+
+      puts aux_macros.join
+      d.import aux_macros.join
+      
+      # disable the non-webhook triggers by default
+      a.each(&:disable)
+      
+      d.export s
+      puts 'exported to ' + s
+      
+    end
+    
+    alias export write
+    
+    def method_missing2(method_name, *args)
+      http_exec(method_name, args.first)
+    end    
+    
+  end
+end

data/lib/remotedroid/controller.rb

@@ -0,0 +1,170 @@
+module RemoteDroid
+  
+  class Controller
+    
+    attr_reader :model, :control, :syslog
+    attr_accessor :title, :macros, :store
+
+    def initialize(mcs, model=MODEL, deviceid: nil, debug: false)
+      
+      @debug = debug
+      @syslog = []
+            
+      @control = Control.new(deviceid)
+      @macros = mcs.macros
+      
+      if model then
+        @model = Model.new(model)
+      end
+      
+      @store = {}
+      @query = Query.new(self)
+      
+      # enable the required triggers on the Android device
+      #
+      names = @macros.map {|x| x.triggers.first.type}.uniq
+      #@control.enable names.first.to_s.gsub('_',' ')
+      puts 'Enabling ' + names.join(',')
+=begin      
+      Thread.new do
+        names.each do |title|
+          @control.enable title.to_s.gsub('_',' ')
+          sleep 0.8
+        end
+      end
+=end
+    end
+    
+    def delete_all()
+      @macros = []
+    end
+    
+    def export(s, replace: false)
+      
+      macros = MacroDroid.new(s).macros
+      replace ? @macros = macros : @macros << macros
+      
+    end
+    
+    def invoke(name, options={})      
+      
+      if @control.respond_to? name.to_sym then
+        @control.method(name.to_sym).call(options)
+      else
+        @control.http_exec name.to_sym, options
+      end
+    end
+
+    # Object Property (op)
+    # Helpful for accessing properites in dot notation 
+    # e.g. op.livingroom.light.switch = 'off'
+    #    
+    def op()
+      @model.op
+    end
+    
+    def query(id=nil)
+      
+      return @query unless id
+      
+      @store[id] = nil
+
+      sys = %i(accelerometer_rotation)      
+      
+      global = [:airplane_mode_on, :bluetooth_on, :cell_on, :device_name, \
+                :usb_mass_storage_enabled, :wifi_on]       
+      
+      secure = %i(bluetooth_name flashlight_enabled)
+
+      
+      # send http request via macrodroid.com API
+      
+      if id.downcase.to_sym == :location then
+        @control.http_exec id
+      elsif sys.include? id
+        @control.http_exec :'query-setting-system', {qvar: id}        
+      elsif global.include? id
+        @control.http_exec :'query-setting-global', {qvar: id}
+      elsif secure.include? id
+        @control.http_exec :'query-setting-secure', {qvar: id}        
+      elsif id.downcase.to_sym == :'take-picture'
+        @control.http_exec id
+      else
+        @control.http_exec :query, {qvar: id}
+      end
+      
+      # wait for the local variable to be updated
+      # timeout after 5 seoncds
+      t = Time.now
+      
+      begin
+        sleep 1
+      end until @store[id] or Time.now > t + 10
+      
+      return {warning: 'HTTP response timeout'} if Time.now > t+5
+      
+      return @store[id]
+
+      
+    end    
+    
+    def request(s)
+      @model.request s
+    end
+    
+    def run_macro(macro_name: '')
+      
+      found = @macros.find do |macro|
+        macro.title.downcase == macro_name.downcase
+      end
+      
+      found.run if found
+      
+    end
+    
+    def trigger(name, detail={})
+      
+      macros = @macros.select do |macro|
+        
+        puts 'macro: '  + macro.inspect if @debug
+
+        # fetch the associated properties from the model if possible and 
+        # merge them into the detail.
+        #
+        valid_trigger = macro.match?(name, detail, @model.op)
+        
+        #puts 'valid_trigger: ' + valid_trigger.inspect if @debug
+        
+        #if valid_trigger then
+        #  @syslog << [Time.now, :trigger, name] 
+        #  @syslog << [Time.now, :macro, macro.title]
+        #end
+        
+        @syslog << [Time.now, name, detail]
+                     
+        valid_trigger
+        
+      end
+      
+      puts 'macros: ' + macros.inspect if @debug
+      
+      macros.flat_map(&:run)
+    end
+    
+    alias trigger_fired trigger
+    
+    def update(id, val)
+      
+      key  = if %i(location take-picture).include? id
+        id
+      else
+        val.keys.first.to_sym
+      end
+      
+      @syslog << [id, val]      
+      @store[key] = val   
+      
+    end
+        
+  end
+end