vlc-client 0.0.1.beta

data/lib/vlc-client/client/video_controls.rb

@@ -0,0 +1,10 @@
+module VLC
+  class Client
+    module VideoControls
+      # Toggles fullscreen on/off
+      def fullscreen
+        @connection.write('fullscreen')
+      end
+    end
+  end
+end

data/lib/vlc-client/connection.rb

@@ -0,0 +1,77 @@
+module VLC
+  #@ private
+  #
+  # Manages the connection to a VLC server
+  #
+  class Connection
+    attr_accessor :host, :port
+
+    def initialize(host, port)
+      @host, @port = host, port
+      @socket = NullObject.new
+    end
+
+    # Connects to VLC RC interface on Client#host and Client#port
+    def connect
+      @socket = TCPSocket.new(@host, @port)
+      2.times { read } #Clean the reading channel
+      true
+    rescue Errno::ECONNREFUSED => e
+      raise VLC::ConnectionRefused, "Could not connect to #{@host}:#{@port}: #{e}"
+    end
+
+    # Queries if there is a connection to VLC RC interface
+    #
+    # @return [Boolean] true is connected, false otherwise
+    #
+    def connected?
+      not @socket.nil?
+    end
+
+    # Disconnects from VLC RC interface
+    def disconnect
+      @socket.close
+      @socket = NullObject.new
+    end
+
+    alias :close :disconnect
+
+    # Writes data to the TCP server socket
+    #
+    # @param data the data to write
+    # @param fire_and_forget if true, no response response is expected from server,
+    #           when false, a response from the server will be returned.
+    #
+    # @return the server response data if there is one
+    #
+    def write(data, fire_and_forget = true)
+      raise NotConnectedError, "no connection to server" unless connected?
+      @socket.puts(data)
+      @socket.flush
+
+      return true if fire_and_forget
+      read
+    rescue Errno::EPIPE
+      disconnect
+      raise BrokenConnectionError, "the connection to the server is lost"
+    end
+
+    # Reads data from the TCP server
+    #
+    # @return [String] the data
+    #
+    def read
+      #TODO: Timeouts
+      raw_data = @socket.gets.chomp
+      if (data = process_data(raw_data))
+        data[1]
+      else
+        raise ProtocolError, "could not interpret the playload: #{raw_data}"
+      end
+    end
+
+    def process_data(data)
+      data.match(/^[>*\s*]*(.*)$/)
+    end
+  end
+end

data/lib/vlc-client/core_ext/array.rb

@@ -0,0 +1,12 @@
+# @private
+module Core
+  module Ext
+    module Array
+      def extract_options!
+        last.is_a?(::Hash) ? pop : {}
+      end unless method_defined?(:extract_options!)
+    end
+  end
+end
+
+Array.send(:include, Core::Ext::Array)

data/lib/vlc-client/errors.rb

@@ -0,0 +1,16 @@
+module VLC
+  # Root error class
+  class Error < StandardError; end
+
+  # Raised on connection refusal
+  class ConnectionRefused < Error; end
+
+  # Raised on communication errors
+  class ProtocolError < Error; end
+
+  # Raised on a write to a broken connection
+  class BrokenConnectionError < Error; end
+
+  # Raised on a write ti a disconnected connection
+  class NotConnectedError < Error; end
+end

data/lib/vlc-client/null_object.rb

@@ -0,0 +1,24 @@
+module VLC
+  # @private
+  class NullObject
+    class << self
+      def Null?(value)
+        value.nil? ? NullObject.new : value
+      end
+    end
+
+    def nil?; true; end
+    def blank?; true; end
+    def empty?; true; end
+    def present?; false; end
+    def size; 0; end
+    def to_a; []; end
+    def to_s; ""; end
+    def to_f; 0.0; end
+    def to_i; 0; end
+    def extract_options!; {}; end
+    def inspect; self.class; end
+
+    def method_missing(*args, &block) self; end
+  end
+end

data/lib/vlc-client/server.rb

@@ -0,0 +1,73 @@
+module VLC
+  # Manages a local VLC server in a child process
+  class Server
+    attr_accessor :host, :port, :headless
+    alias         :headless? :headless
+
+    #
+    # Creates a VLC server lifecycle manager
+    #
+    # @param [String] host The ip to bind to
+    # @param [Integer] port the port
+    # @param [Boolean] headless if true VLC media player will run headless.
+    #                   i.e. without a graphical interface. Defaults to false
+    #
+    def initialize(host = 'localhost', port = 9595, headless = false)
+      @host, @port, @headless = host, port, headless
+      @pid = NullObject.new
+      setup_traps
+    end
+
+    # Queries if VLC is running
+    #
+    # @return [Boolean] true is VLC is running, false otherwise
+    #
+    def running?
+      not @pid.nil?
+    end
+
+    alias :started? :running?
+
+    # Queries if VLC is stopped
+    #
+    # @return [Boolean] true is VLC is stopped, false otherwise
+    #
+    def stopped?; not running?; end
+
+    # Starts a VLC instance in a subprocess
+    #
+    # @return [Integer] the subprocess PID or nil if the start command
+    #                     as no effect (e.g. VLC already running)
+    #
+    def start
+      return NullObject.new if running?
+      @pid = Process.fork do
+        STDIN.reopen "/dev/null"
+        STDOUT.reopen "/dev/null", "a"
+        STDERR.reopen "/dev/null", "a"
+
+        exec "#{headless? ? 'cvlc' : 'vlc'} --extraintf rc --rc-host #{@host}:#{@port}"
+      end
+    end
+
+    # Starts a VLC instance in a subprocess
+    #
+    # @return [Integer] the terminated subprocess PID or nil if the stop command
+    #                     as no effect (e.g. VLC not running)
+    #
+    def stop
+      return NullObject.new if not running?
+
+      Process.kill('INT', pid = @pid)
+      @pid = NullObject.new
+      pid
+    end
+
+    private
+    def setup_traps
+      trap("EXIT") { stop }
+      trap("INT")  { stop }
+      trap("CLD")  { stop }
+    end
+  end
+end

data/lib/vlc-client/system.rb

@@ -0,0 +1,58 @@
+module VLC
+  # Local Client/Server VLC system
+  class System
+    attr_reader :client
+
+    # Creates a local VLC Client/Server system
+    #
+    # @overload initialize(host, port, options) sets the host and port
+    #
+    #   @param [String] host The ip to connect to
+    #   @param [Integer] port the port
+    #   @param [Hash] options
+    #   @option options [Boolean] :auto_start When false, the server lifecycle is not managed automatically and controll is passed to the developer
+    #   @option options [Integer] :conn_retries Number of connection retries (each separated by a second) to make on auto-connect. Defaults to 5.
+    #
+    #   @example
+    #     vlc = VLC::System.new('10.10.0.10', 9000)
+    #
+    # @overload initialize()
+    #
+    #   @example
+    #     vlc = VLC::System.new
+    #
+    # @return [VLC::Server]
+    #
+    # @raise [VLC::ConnectionRefused] if the connection fails
+    #
+    def initialize(*args)
+      args = NullObject.Null?(args)
+      opts = args.extract_options!
+
+      server = VLC::Server.new
+      server.headless = opts.fetch(:headless, false)
+
+      if args.size == 2
+        server.host = args.first.to_s
+        server.port = Integer(args.last)
+      end
+      @client = VLC::Client.new(server, opts)
+    end
+
+    def server
+      client.server
+    end
+
+    def respond_to?(method, private_methods = false)
+      client.respond_to?(method, private_methods) || super(method, private_methods)
+    end
+
+  protected
+    # Delegate to VLC::Client
+    #
+    def method_missing(method, *args, &block)
+      return super unless client.respond_to?(method)
+      client.send(method, *args, &block)
+    end
+  end
+end

data/lib/vlc-client/version.rb

@@ -0,0 +1,3 @@
+module VLC
+  VERSION = "0.0.1.beta"
+end

data/spec/helper.rb

@@ -0,0 +1,40 @@
+require 'simplecov'
+require 'pry'
+
+#setup simplecov
+SimpleCov.start do
+  add_filter "/spec"
+end
+
+require File.expand_path('../../lib/vlc-client', __FILE__)
+
+module Mocks
+  def mock_tcp_server(opts = {})
+    tcp = double()
+    TCPSocket.stub(:new).and_return do
+      if opts.fetch(:defaults, true)
+        tcp.should_receive(:gets).with(no_args).at_least(:twice).and_return("")
+        tcp.should_receive(:flush).with(no_args).any_number_of_times
+        tcp.should_receive(:close).with(no_args) if opts.fetch(:close, true)
+      end
+
+      yield(tcp) if block_given?
+      tcp
+    end
+    tcp
+  end
+
+  def mock_system_calls(opts = {})
+    Process.stub(:fork).and_return(1)
+    Process.should_receive(:kill).once.with('INT', 1) if opts.fetch(:kill, true)
+  end
+
+  def mock_sub_systems
+    mock_system_calls
+    mock_tcp_server
+  end
+end
+
+RSpec.configure do |cfg|
+  cfg.include(Mocks)
+end

data/spec/system_spec.rb

@@ -0,0 +1,31 @@
+describe VLC::System do
+  before(:each) do
+    mock_system_calls(:kill => false)
+  end
+
+  subject { VLC::System.new }
+
+  it 'creates a self-managed VLC media client/server local system' do
+    mock_tcp_server(:close => false)
+
+    subject.client.should be_a(VLC::Client)
+    subject.server.should be_a(VLC::Server)
+  end
+
+  it 'delegates calls to the client' do
+    mock_tcp_server(:close => false).should_receive(:puts).with('is_playing').once
+
+    should respond_to(:play)
+    should_not be_playing
+  end
+
+  it 'handles server lifecycle management to client code' do
+    mock_tcp_server(:close => false)
+
+    vlc = VLC::System.new('127.0.0.1', 9999, :auto_start => false)
+
+    vlc.server.should_not be_running
+    vlc.server.host.should eq('127.0.0.1')
+    vlc.server.port.should eq(9999)
+  end
+end

data/spec/vlc-client/client/connection_management_spec.rb

@@ -0,0 +1,24 @@
+describe VLC::Client::ConnectionManagement do
+  let(:vlc) { VLC::Client.new(:self_managed => false) }
+  before(:each) { mock_tcp_server }
+  after(:each) { vlc.disconnect }
+
+  context 'when disconnected' do
+    specify { vlc.should be_disconnected }
+
+    it 'connects to VLC' do
+      vlc.connect
+      vlc.should be_connected
+    end
+  end
+
+  context 'when connected' do
+    before(:each) { vlc.connect }
+    specify { vlc.should be_connected }
+
+    it 'disconnects to VLC' do
+      vlc.disconnect
+      vlc.should be_disconnected
+    end
+  end
+end

data/spec/vlc-client/client/media_controls_spec.rb

@@ -0,0 +1,188 @@
+describe VLC::Client::MediaControls do
+  let(:vlc) { VLC::Client.new(:self_managed => false) }
+  after(:each) { vlc.disconnect }
+
+  context 'plays media' do
+    it 'from filesystem' do
+      mock_tcp_server.should_receive(:puts).once.with('add ./media.mp3')
+      vlc.connect
+
+      vlc.play('./media.mp3')
+    end
+
+    it 'from a file descriptor' do
+      File.stub(:open).and_return {
+        f = File.new('./LICENSE', 'r')
+        f.should_receive(:path).once.and_return('./media.mp3')
+        f
+      }
+
+      mock_tcp_server.should_receive(:puts).once.with('add ./media.mp3')
+      vlc.connect
+
+      vlc.play(File.open("./media.mp3"))
+    end
+
+    it 'from web' do
+      mock_tcp_server.should_receive(:puts).once.with('add http://example.org/media.mp3')
+      vlc.connect
+
+      vlc.play('http://example.org/media.mp3')
+    end
+
+    it 'raises error for unknown schemas' do
+      mock_tcp_server
+      vlc.connect
+
+      expect { vlc.play(Class.new) }.to raise_error(ArgumentError)
+    end
+  end
+
+  context 'when playing media' do
+    def tcp_mock
+      tcp = mock_tcp_server(:defaults => false)
+
+      tcp.should_receive(:flush).with(no_args).any_number_of_times
+      tcp.should_receive(:gets).with(no_args).twice.and_return("")
+
+      tcp.should_receive(:puts).once.with('add http://example.org/media.mp3')
+
+      tcp.should_receive(:close).with(no_args)
+      tcp
+    end
+
+    it 'may stop playback' do
+      tcp = tcp_mock
+      tcp.should_receive(:puts).once.with('is_playing')
+      tcp.should_receive(:gets).once.with(no_args).and_return("0")
+
+      tcp.should_receive(:puts).once.with('play')
+      tcp.should_receive(:puts).once.with('is_playing')
+      tcp.should_receive(:gets).once.with(no_args).and_return("1")
+
+      tcp.should_receive(:puts).once.with("stop")
+
+      vlc.connect
+      vlc.play('http://example.org/media.mp3')
+
+      vlc.stop
+      vlc.should be_stopped
+
+      vlc.play #play current item
+      vlc.should be_playing
+    end
+
+    it 'may pause playback' do
+      tcp = tcp_mock
+
+      tcp.should_receive(:puts).once.with('pause')
+      tcp.should_receive(:puts).once.with('is_playing')
+      tcp.should_receive(:gets).once.with(no_args).and_return("0")
+
+
+      vlc.connect
+      vlc.play('http://example.org/media.mp3')
+
+      vlc.pause
+      vlc.should be_stopped
+    end
+
+    it 'may resume playback' do
+      tcp = tcp_mock
+
+      tcp.should_receive(:puts).once.with('pause')
+      tcp.should_receive(:puts).once.with('play')
+      tcp.should_receive(:puts).once.with('is_playing')
+      tcp.should_receive(:gets).once.with(no_args).and_return('1')
+
+      vlc.connect
+      vlc.play('http://example.org/media.mp3')
+
+      vlc.pause
+      vlc.play
+      vlc.should be_playing
+    end
+
+    it 'displays the playing media title' do
+      tcp = tcp_mock
+      tcp.should_receive(:puts).once.with('get_title')
+      tcp.should_receive(:gets).once.and_return('test media')
+      tcp.should_receive(:puts).once.with('stop')
+      tcp.should_receive(:puts).once.with('get_title')
+      tcp.should_receive(:gets).once.and_return('')
+
+      vlc.connect
+      vlc.play('http://example.org/media.mp3')
+
+      vlc.title.should eq('test media')
+      vlc.stop
+
+      vlc.title.should be_empty
+    end
+
+    it 'is aware of track time' do
+      tcp = tcp_mock
+
+      tcp.should_receive(:puts).once.with('get_time')
+      tcp.should_receive(:gets).once.and_return('60')
+
+      vlc.connect
+      vlc.play('http://example.org/media.mp3')
+
+      vlc.time.should eq(60)
+    end
+
+    it 'is aware of track length' do
+      tcp = tcp_mock
+
+      tcp.should_receive(:puts).once.with('get_length')
+      tcp.should_receive(:gets).once.and_return('100')
+
+      vlc.connect
+      vlc.play('http://example.org/media.mp3')
+
+      vlc.length.should eq(100)
+    end
+
+    it 'is aware of track progress' do
+      vlc.stub(:length).and_return { 0 }
+      vlc.stub(:time).and_return { 100 }
+      vlc.progress.should eq(0)
+
+      vlc.stub(:length).and_return { 100 }
+      vlc.stub(:time).and_return { 0 }
+      vlc.progress.should eq(0)
+
+      vlc.stub(:length).and_return { 100 }
+      vlc.stub(:time).and_return { 10 }
+      vlc.progress.should eq(10)
+
+      vlc.stub(:length).and_return { 100 }
+      vlc.stub(:time).and_return { 100 }
+      vlc.progress.should eq(100)
+    end
+  end
+
+  it 'is aware of current status' do
+    tcp = mock_tcp_server(:defaults => false)
+    tcp.should_receive(:flush).with(no_args).any_number_of_times
+
+    tcp.should_receive(:gets).with(no_args).twice.and_return("")
+
+    tcp.should_receive(:puts).once.with('is_playing')
+    tcp.should_receive(:gets).once.with(no_args).and_return("> > 0")
+
+    tcp.should_receive(:puts).once.with('add http://example.org/media.mp3')
+
+    tcp.should_receive(:puts).once.with('is_playing')
+    tcp.should_receive(:gets).once.with(no_args).and_return("> > 1")
+
+    tcp.should_receive(:close).with(no_args)
+
+    vlc.connect
+
+    vlc.should be_stopped
+    vlc.play('http://example.org/media.mp3')
+    vlc.should be_playing
+  end
+end