airplay 0.2.9 → 1.0.0.beta1

data/examples/image.rb

@@ -0,0 +1,9 @@
+require "airplay"
+
+Airplay.use "corax", "corax"
+Airplay.configure do |c|
+  c.log_level = "debug"
+end
+
+Airplay.view("http://fitdeck.com/Portals/24254/images/Sunrise.jpg")
+sleep 4

data/examples/video.rb

@@ -0,0 +1,24 @@
+require "airplay"
+
+Airplay.configure do |c|
+#  c.log_level = "debug"
+end
+
+video = "http://trailers.apple.com/movies/marvel/ironman3/ironman3-tlr1-m4mb0_h1080p.mov"
+
+Airplay.play video
+puts "Starts playing: #{video}"
+Airplay.player.progress -> info {
+  if info["rate"]
+    if info["readyToPlay"]
+      total = info["duration"]
+      current = info["position"]
+      percent = (current*100/total).round
+
+      print "\r|#{"=" * percent}> #{percent}%"
+    end
+  end
+}
+
+Airplay.player.wait
+puts "Video playback finished!"

data/lib/airplay.rb

@@ -1,17 +1,38 @@
-require 'dnssd'
-require 'net/http'
-require 'net/http/persistent'
-require 'net/http/digest_auth'
-require 'uri'
-
-module Airplay end
-require 'airplay/server'
-require 'airplay/server/browser'
-require 'airplay/server/node'
-
-require 'airplay/protocol'
-require 'airplay/protocol/image'
-require 'airplay/protocol/media'
-require 'airplay/protocol/scrub'
-
-require 'airplay/client'
+require "airplay/configuration"
+require "airplay/browser"
+
+# Public: Airplay core module
+#
+module Airplay
+  class << self
+    def configure(&block)
+      yield(configuration) if block
+    end
+
+    def browse
+      browser.browse
+    end
+
+    # Public: Lists found devices
+    #
+    def devices
+      browse if browser.devices.empty?
+      browser.devices
+    end
+
+    def configuration
+      @_configuration ||= Configuration.new
+    end
+
+    def [](device_name)
+      devices.find_by_name(device_name)
+    end
+
+    private
+
+    def browser
+      @_browser ||= Browser.new
+    end
+  end
+end
+

data/lib/airplay/browser.rb

@@ -0,0 +1,68 @@
+require "dnssd"
+require "timeout"
+
+require "airplay/logger"
+require "airplay/devices"
+
+module Airplay
+  # Public: Browser class to find Airplay-enabled devices in the network
+  #
+  class Browser
+    SEARCH = "_airplay._tcp."
+
+    def initialize
+      @logger = Airplay::Logger.new("airplay::browser")
+    end
+
+    # Public: Browses in the search of devices and adds them to the nodes
+    #
+    def browse
+      timeout(5) do
+        DNSSD.browse!(SEARCH) do |node|
+          resolve(node)
+          break unless node.flags.more_coming?
+        end
+      end
+    end
+
+    # Public: Access to the node list
+    #
+    def devices
+      @_devices ||= Devices.new
+    end
+
+    private
+
+    # Private: Resolves a node given a node and a resolver
+    #
+    #   node - The given node
+    #   resolver - The DNSSD::Server that is resolving nodes
+    #
+    # Returns if there are more nodes coming
+    #
+    def node_resolver(node, resolved)
+      info = Socket.getaddrinfo(resolved.target, nil, Socket::AF_INET)
+      ip = info[0][2]
+
+      airplay_device = Device.new(
+        name:     node.name.gsub(/\u00a0/, ' '),
+        address: "#{ip}:#{resolved.port}",
+      )
+
+      devices << airplay_device
+
+      resolved.flags.more_coming?
+    end
+
+    # Private: Resolves the node information given a node
+    #
+    #   node - The node from the DNSSD browsing
+    #
+    def resolve(node)
+      resolver = DNSSD::Service.new
+      resolver.resolve(node) do |resolved|
+        break unless node_resolver(node, resolved)
+      end
+    end
+  end
+end

data/lib/airplay/cli.rb

@@ -0,0 +1,104 @@
+require "airplay"
+require "ruby-progressbar"
+
+module Airplay
+  module CLI
+    class << self
+      def list
+        Airplay.devices.each do |device|
+          puts <<-EOS.gsub(/^\s{12}/,'')
+            * #{device.name} (#{device.info.model} running #{device.info.os_version})
+              ip: #{device.ip}
+              resolution: #{device.info.resolution}
+
+          EOS
+        end
+      end
+
+      def play(video, options)
+        device = options[:device]
+        player = device.play(video)
+        puts "Playing #{video}"
+        bar = ProgressBar.create(
+          title: device.name,
+          format: "%a [%B] %p%% %t"
+        )
+
+        player.progress -> playback {
+          bar.progress = playback.percent
+        }
+
+        player.wait
+      end
+
+      def view(file_or_dir, options)
+        device = options[:device]
+        wait = options[:wait]
+
+        if File.directory?(file_or_dir)
+          files = Dir.glob("#{file_or_dir}/*")
+
+          if options[:interactive]
+            view_interactive(files)
+          else
+            view_slideshow(files)
+          end
+        else
+          view_image(device, file_or_dir)
+          sleep
+        end
+      end
+
+      private
+
+      def view_interactive(files)
+        numbers = Array(0...files.count)
+        transition = "None"
+
+        i = 0
+        loop do
+          view_image(device, files[i], transition)
+
+          case read_char
+            # Right Arrow
+          when "\e[C"
+            i = i + 1 > numbers.count - 1 ? 0 : i + 1
+            transition = "SlideLeft"
+          when "\e[D"
+            i = i - 1 < 0 ? numbers.count - 1 : i - 1
+            transition = "SlideRight"
+          else
+            break
+          end
+        end
+      end
+
+      def view_slideshow(files)
+        files.each do |file|
+          view_image(device, file)
+          sleep wait
+        end
+      end
+
+      def read_char
+        STDIN.echo = false
+        STDIN.raw!
+
+        input = STDIN.getc.chr
+        if input == "\e" then
+          input << STDIN.read_nonblock(3) rescue nil
+          input << STDIN.read_nonblock(2) rescue nil
+        end
+      ensure
+        STDIN.echo = true
+        STDIN.cooked!
+
+        return input
+      end
+
+      def view_image(device, image, transition = "SlideLeft")
+        device.view(image, transition: transition)
+      end
+    end
+  end
+end

data/lib/airplay/configuration.rb

@@ -0,0 +1,29 @@
+require 'log4r/config'
+
+module Airplay
+  # Public: Handles the Airplay configuration
+  #
+  class Configuration
+    attr_accessor :log_level, :output
+
+    def initialize
+      Log4r.define_levels(*Log4r::Log4rConfig::LogLevels)
+
+      @log_level = Log4r::WARN
+      @output = Log4r::Outputter.stdout
+    end
+
+    # Public: Loads the configuration into the affected parts
+    #
+    def load
+      level = if @log_level.is_a?(Fixnum)
+                @log_level
+              else
+                Log4r.const_get(@log_level.upcase)
+              end
+
+      Log4r::Logger.root.add @output
+      Log4r::Logger.root.level = level
+    end
+  end
+end

data/lib/airplay/connection.rb

@@ -0,0 +1,114 @@
+require "celluloid"
+require "airplay/connection/persistent"
+require "airplay/connection/authentication"
+
+module Airplay
+  # Public: The class that handles all the outgoing basic HTTP connections
+  #
+  class Connection
+    Response = Struct.new(:connection, :response)
+
+    attr_accessor :reverse, :events, :persistent
+
+    include Celluloid
+
+    def initialize(device, options = {})
+      @device = device
+      @options = options
+      @logger = Airplay::Logger.new("airplay::connection")
+    end
+
+    def persistent
+      address = @options[:address] || "http://#{@device.address}"
+      @_persistent ||= Airplay::Connection::Persistent.new(address, @options)
+    end
+
+    def start_reverse_connection
+      @reverse = Airplay::Protocol::Reverse.new(Airplay.active)
+      @reverse.async.connect
+    end
+
+    def close
+      persistent.close
+      @_persistent = nil
+    end
+
+    # Public: Executes a POST to a resource
+    #
+    #   resource - The resource on the currently active Device
+    #   body - The body of the action
+    #   headers - Optional headers
+    #
+    # Returns a response object
+    #
+    def post(resource, body = "", headers = {})
+      @logger.info("POST #{resource} with #{body.bytesize} bytes")
+      request = Net::HTTP::Post.new(resource)
+      request.body = body
+
+      send_request(request, headers)
+    end
+
+    # Public: Executes a PUT to a resource
+    #
+    #   resource - The resource on the currently active Device
+    #   body - The body of the action
+    #   headers - Optional headers
+    #
+    # Returns a response object
+    #
+    def put(resource, body = "", headers = {})
+      @logger.info("PUT #{resource} with #{body.bytesize} bytes")
+      request = Net::HTTP::Put.new(resource)
+      request.body = body
+
+      send_request(request, headers)
+    end
+
+    # Public: Executes a GET to a resource
+    #
+    #   resource - The resource on the currently active Device
+    #   headers - Optional headers
+    #
+    # Returns a response object
+    #
+    def get(resource, headers = {})
+      @logger.info("GET #{resource}")
+      request = Net::HTTP::Get.new(resource)
+
+      send_request(request, headers)
+    end
+
+    private
+
+    # Private: The defaults connection headers
+    #
+    def default_headers
+      {
+        "User-Agent"         => "MediaControl/1.0",
+        "X-Apple-Session-Id" => persistent.session
+      }
+    end
+
+    # Private: Sends a request to the Device
+    #
+    #   request - The Request object
+    #   headers - The headers of the request
+    #
+    # Returns a response object
+    #
+    def send_request(request, headers)
+      request.initialize_http_header(default_headers.merge(headers))
+
+      if @device.password?
+        authentication = Airplay::Connection::Authentication.new(persistent)
+        request = authentication.sign(request)
+      end
+
+      @logger.info("Sending request to #{@device.address}")
+      response = persistent.request(request)
+
+      Airplay::Connection::Response.new(persistent, response)
+    end
+  end
+end

data/lib/airplay/connection/authentication.rb

@@ -0,0 +1,37 @@
+require "net/http/digest_auth"
+
+module Airplay
+  class Connection
+    class Authentication < Struct.new(:handler)
+      def sign(request)
+        auth_token = authenticate(request)
+        request.add_field('Authorization', auth_token) if auth_token
+        request
+      end
+
+      private
+
+      def uri(request)
+        server = Airplay.active
+        path = "http://#{server.address}#{request.path}"
+        uri = URI.parse(path)
+        uri.user = "Airplay"
+        uri.password = server.password
+
+        uri
+      end
+
+      def authenticate(request)
+        response = handler.request(request)
+
+        auth = response["www-authenticate"] || response["WWW-Authenticate"]
+        digest_authentication(request, auth) if auth
+      end
+
+      def digest_authentication(request, auth)
+        digest = Net::HTTP::DigestAuth.new
+        digest.auth_header(uri(request), auth, request.method)
+      end
+    end
+  end
+end