rairtame 1.0.0

data/README.md

@@ -0,0 +1,50 @@
+# Rairtame
+
+Rairtame is a library and CLI utility to interact with the `airtame-streamer` JSON-RPC API.
+
+It allows to easily control the `airtame-streamer` daemon, which is in charge of capturing and streaming video to an [AIRTAME dongle](http://airtame.com).
+
+**Make sure the `airtame-streamer` is running when using `rairtame`**.
+
+## Installation
+
+Rairtame is distributed as a Ruby gem. It can be installed by running:
+
+    $ gem install rairtame
+
+## CLI Usage
+
+The Rairtame Command-Line interface is accessed through the
+
+    $ rairtame command [arguments]
+
+command.
+
+Remember to run `rairtame init` to init the streamer before connecting anywhere.
+
+You can see all the options running `rairtame -h`.
+
+## Ruby library usage
+
+You can also easily integrate your own code against this library. For example:
+
+```ruby
+require 'rairtame'
+client = Rairtame::Client.new()
+client.init_streamer()
+client.connect("myairtame")
+client.quality = 5
+client.buffer = 5000
+client.disconnect()
+client.close_streamer()
+```
+
+## Limitations
+
+Rairtame does not yet implement the SSDP protocol (which allows autodiscovery of the streamer) nor performs any registration with the `airtame-streamer` (for example to receive notifications).
+
+Particularly, I don't see many uses for these features at this point, and the official [Airtame CLI](https://github.com/airtame/airtame-cli) supports them.
+
+## Contributing
+
+Please do!

data/Rakefile

@@ -0,0 +1,18 @@
+# coding: utf-8
+# This file is part of Rairtame.
+
+# Rairtame is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# Rairtame is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with Rairtame.  If not, see <http://www.gnu.org/licenses/>
+
+require "bundler/gem_tasks"
+

data/bin/rairtame

@@ -0,0 +1,177 @@
+#!/usr/bin/env ruby
+
+# This file is part of Rairtame.
+
+# Rairtame is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# Rairtame is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with Rairtame.  If not, see <http://www.gnu.org/licenses/>
+
+lib = File.expand_path('../../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+
+require "bundler/setup"
+require 'gli'
+require 'colorize'
+require 'rairtame'
+
+module Rairtame
+  module RairtameCLI
+    SUBCOMMANDS = {
+      :init => {
+        :short => 'Init the streamer',
+        :long => 'Initializes the streamer',
+        :arg => nil,
+        :method => :init_streamer
+      },
+      :close => {
+        :short => 'Close the streamer',
+        :long => 'Closes the streamer',
+        :arg => nil,
+        :method => :close_streamer
+      },
+      :connect => {
+        :short => 'Connect to Airtame dongle',
+        :long => 'Connects and starts streaming to the Airtame dongle',
+        :arg => 'hostname/ip',
+        :method => :connect
+      },
+      :disconnect => {
+        :short => 'Disconnect from the Airtame dongle',
+        :long => 'Disconnects and stops streaming to the Airtame dongle',
+        :arg => 'hostname/ip',
+        :method => :disconnect
+      },
+      :mode => {
+        :short => 'Set streaming mode',
+        :long => 'Sets streaming mode to one of the options',
+        :arg => 'manual|video|work|present',
+        :allowed => ['manual', 'video', 'work', 'present'],
+        :method => :mode=
+      },
+      :quality => {
+        :short => 'Set streaming quality [1-5]',
+        :long => 'Sets the streaming quality from 0-worst to 5-best,
+ when using manual mode',
+        :arg => 'quality',
+        :allowed => (0..5).map(&:to_s),
+        :method => :quality=
+      },
+      :fps => {
+        :short => 'Set streaming fps [1-60]',
+        :long => 'Sets the fps [1-60] for streaming, when using manual mode',
+        :arg => 'fps',
+        :allowed => (1..60).map(&:to_s),
+        :method => :framerate=
+      },
+      :audio => {
+        :short => 'Enable or disable audio',
+        :long => 'Enables or disables audio streaming to the Airtame dongle',
+        :arg => 'on/off',
+        :allowed => ['on', 'off'],
+        :method => :audio=
+      },
+      :video => {
+        :short => 'Enable or disable video',
+        :long => 'Enables or disables video streaming to the Airtame dongle',
+        :arg => 'on/off',
+        :allowed => ['on', 'off'],
+        :method => :video=
+      },
+      :buffer => {
+        :short => 'Set streaming buffer length in ms',
+        :long => 'Sets the length of the streaming buffer in ms',
+        :arg => 'ms',
+        :method => :buffer=
+      },
+      :fluent => {
+        :short => 'Enable or disable fluent video',
+        :long => 'Enables or disables the fluent video streaming feature',
+        :arg => 'on/off',
+        :allowed => ['on', 'off'],
+        :method => :video_jitterbuffer=      
+      },
+      :state => {
+        :short => 'Show streamer\'s state',
+        :long => 'Prints streamer\'s state in a pretty way',
+        :arg => nil,
+        :method => :pretty_state
+      }
+    }
+
+    class << self
+      include GLI::App
+
+      def setup
+        program_desc <<EOF
+A Ruby interface to the airtame-streamer JSON-RPC API, which allows
+to stream to an AIRTAME dongle. 
+EOF
+
+        switch [:v, :verbose]
+        switch [:c, :color], :default_value => true
+        flag [:streamer_host], :default_value => 'localhost'
+        flag [:config_file]
+        
+        pre do |global_options, command, options, args|
+          @client = Rairtame::Client.new(global_options)
+          String.disable_colorization = !global_options[:color]
+          true
+        end
+
+        SUBCOMMANDS.each do |cmd_name, cmd|
+          block = Proc.new do |c|
+            c.action do |global_options, options, args|
+              argument = args.first
+              client_method = cmd[:method]
+              if cmd[:arg] && argument.nil?
+                help_now!("Provide an argument for the command")
+              end
+              if cmd[:allowed] &&
+                  !cmd[:allowed].include?(argument)
+                help_now!("Invalid argument: #{argument}")
+              end
+
+              begin
+
+                if argument
+                  puts "> Setting #{cmd_name}:#{argument}".
+                    colorize(:light_yellow).bold()
+                  result = @client.send(client_method, argument)
+                else
+                  puts "> Getting #{client_method}".
+                    colorize(:light_yellow).bold()
+                  result = @client.send(client_method)
+                end
+                puts "< OK".colorize(:light_green).bold()
+              rescue ClientException
+                puts "< ERROR: #{$!.message}".
+                  colorize(:light_red).bold
+              rescue Jsonrpctcp::RPCException, Jsonrpctcp::RPCError
+                puts "< ERROR from streamer: #{$!.message}".
+                  colorize(:light_red).bold
+              end
+
+            end
+          end
+
+          desc(cmd[:short])
+          long_desc(cmd[:long])
+          arg_name("<#{cmd[:arg]}>") if cmd[:arg]
+          command(cmd_name, &block)
+        end
+      end
+    end
+  end
+end
+
+Rairtame::RairtameCLI::setup()
+Rairtame::RairtameCLI::run(ARGV)

data/lib/rairtame/client.rb

@@ -0,0 +1,177 @@
+# coding: utf-8
+# This file is part of Rairtame.
+
+# Rairtame is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# Rairtame is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with Rairtame.  If not, see <http://www.gnu.org/licenses/>
+
+require 'ipaddr'
+require 'jsonrpctcp'
+require 'socket'
+require 'pp'
+
+require 'rairtame/config'
+
+module Rairtame
+
+  class ClientException < Exception
+    attr_reader :code, :message
+    def initialize(message, code=nil)
+      @code = code
+      @message = message
+    end
+  end
+
+  class Client
+    STREAMER_CMDS_PORT = "8004"
+    RECEIVER_PORT = "8002"
+
+    def initialize(opts={})
+      @config = Rairtame::Config.new(opts)
+      @verbose = opts[:verbose]
+      @streamer_host = opts[:streamer_host] || 'localhost'
+      @streamer_uri = "http://#{@streamer_host}:#{STREAMER_CMDS_PORT}/"
+      @json_rpc_client = Jsonrpctcp::Client.new(@streamer_host,
+                                                STREAMER_CMDS_PORT)
+    end
+
+    def rpc_call(method, *params)
+      begin
+        log_command(method, params)
+        r = @json_rpc_client[method.to_s, *params]
+        log_response(r)
+        return r
+      rescue Jsonrpctcp::RPCException
+        raise $!
+      rescue Jsonrpctcp::RPCError
+        log_response($!.source_object)
+        raise $!
+      rescue StandardError
+        msg = "Cannot connect to streamer: is it running?: #{$!.message}"
+        raise ClientException.new(msg)
+      rescue Exception
+        msg = "An error occurred while talking to the streamer: #{$!.message}"
+        raise ClientException.new(msg)
+      end
+    end
+
+    def init_streamer
+      rpc_call(:initStreamer)
+    end
+
+    def connect(host)
+      ip = resolve(host)
+      rpc_call(:connect, ip, RECEIVER_PORT)
+    end
+
+    def disconnect(host)
+      ip = resolve(host)
+      rpc_call(:disconnect, ip, RECEIVER_PORT)
+    end
+
+    def close_streamer
+      rpc_call(:closeStreamer)
+    end
+
+    def state
+      rpc_call(:getState)
+    end
+
+    def pretty_state
+      rpc_call(:getState)
+    end
+
+    def framerate=(v)
+      rpc_call(:setStreamerSettings, 'framerate', v.to_s)
+    end
+
+    def quality=(v)
+      rpc_call(:setStreamerSettings, 'quality', v.to_s)
+    end
+
+    def buffer=(v)
+      rpc_call(:setStreamerSettings, 'buffer', v.to_s)
+    end
+
+    def mode=(v)
+      rpc_call(:setStreamerSettings, 'streaming_mode', v)
+    end
+
+    def audio=(v)
+      # TODO: Read av flags first and keep the video flag
+      value = case v
+              when "on" then "3"
+              when "off" then "1"
+              end
+      rpc_call(:setStreamerSettings, 'av_flags', value)
+
+    end
+
+    def video=(v)
+      # TODO: Read av flags first and keep the audio
+      value = case v
+              when "on" then "1"
+              when "off" then "0"
+              end
+      rpc_call(:setStreamerSettings, 'av_flags', value)
+    end
+
+    # fluent video
+    def video_jitterbuffer=(v)
+      value = case v
+              when "on" then "1"
+              when "off" then "0"
+              end
+      rpc_call(:setStreamerSettings, 'video_jb_flags', value)
+    end
+
+    # unused
+    def audio_jitterbuffer=(v)
+      warn "Not implemented"
+      nil
+    end
+
+    # unknown
+    def jitterbuffer_delay=(v)
+      rpc_call(:setStreamerSettings, 'jb_delay', v.to_s)
+    end
+
+    def reliable_transport=(v)
+      warn "Not implemented"
+      nil
+    end
+
+    private
+
+    def log_command(method, params)
+      return unless @verbose
+      puts "Sending command: [#{method} | #{params}]"
+    end
+
+    def log_response(r)
+      # log anyway
+      return unless @verbose
+      is_error = JsonRpcClient.is_error?(r)
+      if is_error then warn "Received error:"
+      else puts "Received response:" end
+      pp r
+    end
+
+    def resolve(host)
+      begin 
+        IPAddr.new(host).to_s
+      rescue IPAddr::InvalidAddressError
+        Socket.getaddrinfo(host, nil)[0][3]
+      end
+    end
+  end
+end

data/lib/rairtame/config.rb

@@ -0,0 +1,91 @@
+# coding: utf-8
+# This file is part of Rairtame.
+
+# Rairtame is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# Rairtame is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with Rairtame.  If not, see <http://www.gnu.org/licenses/>
+
+require 'fileutils'
+require 'uuidtools'
+require 'json'
+
+
+module Rairtame
+  class Config
+    def initialize(opts={})
+      set_paths(opts[:config_file])
+      @config = read_config()
+    end
+
+    def [](key)
+      @config[key]
+    end
+
+    def []=(key, value)
+      @config[key] = value
+    end
+
+    private
+
+    def set_paths(config_file)
+      if config_file.nil?
+        home = Dir.respond_to?(:home) ? Dir.home : File.expand_path('~')
+        @cfg_folder = File.join(home, '.config', 'rairtame')
+        @cfg_file = File.join(@cfg_folder, 'config')
+      else
+        @cfg_file = config_file
+        @cfg_folder = File.dirname(@cfg_file)
+      end
+    end
+
+    def read_config
+      begin
+        @config = JSON.load(File.read(@cfg_file))
+        @uuid = @config['uuid']
+        # We really need an uuid
+        if @uuid.nil?
+          create_uuid
+        end
+      rescue 
+        initialize_config()
+        retry
+      end
+    end
+
+    def save_config
+      begin
+        File.write(@cfg_file, @config.to_json)
+      rescue
+        warn 'Cannot save configuration!!'
+        raise $!
+      end
+    end
+
+    def initialize_config
+      begin
+        puts "Initialize configuration at #{@cfg_file}"
+        FileUtils.mkdir_p(@cfg_folder) if !File.exists?(@cfg_folder)
+        FileUtils.touch(@cfg_file) if !File.exists?(@cfg_file)
+        File.write(@cfg_file, '{}')
+      rescue
+        warn 'Cannot initialize configuration!!'
+        raise $!
+      end
+    end
+
+    def create_uuid
+      @uuid = UUIDTools::UUID.random_create.to_s
+      @config['uuid'] = @uuid
+      save_config
+    end
+  end
+end

data/lib/rairtame/version.rb

@@ -0,0 +1,19 @@
+# coding: utf-8
+# This file is part of Rairtame.
+
+# Rairtame is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# Rairtame is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with Rairtame.  If not, see <http://www.gnu.org/licenses/>
+
+module Rairtame
+  VERSION = "1.0.0"
+end

data/lib/rairtame.rb

@@ -0,0 +1,22 @@
+# coding: utf-8
+# This file is part of Rairtame.
+
+# Rairtame is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# Rairtame is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with Rairtame.  If not, see <http://www.gnu.org/licenses/>
+
+require "rairtame/version"
+require "rairtame/client"
+
+module Rairtame
+  # Your code goes here...
+end

data/rairtame.gemspec

@@ -0,0 +1,48 @@
+# coding: utf-8
+# Copyright (C) 2015 Hector Sanjuan
+
+# This file is part of Rairtame.
+
+# Rairtame is free software: you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+
+# Rairtame is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+
+# You should have received a copy of the GNU General Public License
+# along with Rairtame.  If not, see <http://www.gnu.org/licenses/>
+
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'rairtame/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "rairtame"
+  spec.version       = Rairtame::VERSION
+  spec.authors       = ["Hector Sanjuan"]
+  spec.email         = ["hector@convivencial.org"]
+  spec.summary       = "CLI and Ruby wrapper around the 'airtame-streamer' JSON-RPC API."
+  spec.description   = <<EOF
+Rairtame is a Command-Line Interface and Ruby wrapper around the 'airtame-streamer' JSON-RPC API.
+
+It allows to easily control the `airtame-streamer` daemon, which is in charge of capturing and streaming video to an AIRTAME dongle.
+EOF
+  spec.homepage      = "https://github.com/hsanjuan/rairtame"
+  spec.license       = "GPLv3+"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_dependency "gli", "~> 2.13"
+  spec.add_dependency "uuidtools", "~> 2.1"
+  spec.add_dependency "colorize", "~> 0.7"
+  spec.add_dependency "jsonrpctcp", '~> 1.0', '>= 1.0.1'
+end