airplay 0.2.9 → 1.0.0.beta1

data/lib/airplay/connection/persistent.rb

@@ -0,0 +1,44 @@
+require "net/ptth"
+require "uuid"
+
+module Airplay
+  # Public: The class that handles all the outgoing basic HTTP connections
+  #
+  class Connection
+    attr_reader :session
+
+    # Public: Class that wraps a persistent connection to point to the airplay
+    #         server and other configuration
+    #
+    class Persistent
+      def initialize(address, options = {})
+        @logger = Airplay::Logger.new("airplay::connection::persistent")
+        @socket = Net::PTTH.new(address, options)
+        @socket.set_debug_output = @logger
+
+        @socket.socket
+      end
+
+      def session
+        @_session ||= UUID.generate
+      end
+
+      def close
+        socket.close
+      end
+
+      def socket
+        @socket.socket
+      end
+
+      # Public: send a request to the active server
+      #
+      #   request - The Net::HTTP request to be executed
+      #   &block  - An optional block to be executed within the block
+      #
+      def request(request)
+        @socket.request(request)
+      end
+    end
+  end
+end

data/lib/airplay/device.rb

@@ -0,0 +1,81 @@
+require "airplay/playable"
+require "airplay/viewable"
+require "airplay/device/features"
+require "airplay/device/info"
+
+module Airplay
+  # Public: Represents an Airplay Node
+  #
+  class Device
+    attr_reader :name, :address, :password
+
+    include Playable
+    include Viewable
+
+    def initialize(attributes = {})
+      @name = attributes[:name]
+      @address = attributes[:address]
+      @password = attributes[:password]
+
+      Airplay.configuration.load
+    end
+
+    def ip
+      @_ip ||= address.split(":").first
+    end
+
+    def password=(passwd)
+      @password = passwd
+    end
+
+    def password?
+      !!password && !password.empty?
+    end
+
+    def address=(address)
+      @address = address
+    end
+
+    def features
+      @_features ||= Features.new(self)
+    end
+
+    def info
+      @_info ||= Info.new(self)
+    end
+
+    def server_info
+      @_server_info ||= basic_info.merge(extra_info)
+    end
+
+    def connection
+      @_connection ||= Airplay::Connection.new(self)
+    end
+
+    def refresh_connection
+      @_connection = nil
+    end
+
+    private
+
+    def basic_info
+      @_basic_info ||= begin
+        response = connection.get("/server-info").response
+        plist = CFPropertyList::List.new(data: response.body)
+        CFPropertyList.native_types(plist.value)
+      end
+    end
+
+    def extra_info
+      @_extra_info ||= begin
+        new_device = clone
+        new_device.refresh_connection
+        new_device.address = "#{ip}:7100"
+
+        response = new_device.connection.get("/stream.xml").response
+        plist = CFPropertyList::List.new(data: response.body)
+        CFPropertyList.native_types(plist.value)
+      end
+    end
+  end
+end

data/lib/airplay/device/features.rb

@@ -0,0 +1,43 @@
+module Airplay
+  # Public: Represents an Airplay Node
+  #
+  class Device
+    # Public: The feature list of a given device
+    #
+    class Features
+      attr_reader :properties
+
+      def initialize(device)
+        @device = device
+        check_features
+      end
+
+      private
+
+      def check_features
+        hex = @device.server_info["features"].to_s.hex
+        @properties = {
+          video?:                   0 < (hex & ( 1 <<  0 )),
+          photo?:                   0 < (hex & ( 1 <<  1 )),
+          video_fair_play?:         0 < (hex & ( 1 <<  2 )),
+          video_volume_control?:    0 < (hex & ( 1 <<  3 )),
+          video_http_live_streamr?: 0 < (hex & ( 1 <<  4 )),
+          slideshow?:               0 < (hex & ( 1 <<  5 )),
+          screen?:                  0 < (hex & ( 1 <<  7 )),
+          screen_rotate?:           0 < (hex & ( 1 <<  8 )),
+          audio?:                   0 < (hex & ( 1 <<  9 )),
+          audio_redundant?:         0 < (hex & ( 1 << 11 )),
+          FPSAPv2pt5_AES_GCM?:      0 < (hex & ( 1 << 12 )),
+          photo_caching?:           0 < (hex & ( 1 << 13 ))
+        }
+
+        @properties.each do |key, value|
+          self.class.send(:define_method, key) { value }
+        end
+
+      end
+
+    end
+
+  end
+end

data/lib/airplay/device/info.rb

@@ -0,0 +1,22 @@
+module Airplay
+  # Public: Represents an Airplay Device
+  #
+  class Device
+    # Public: Simple class to represent information of a Device
+    #
+    class Info
+      attr_reader :model, :os_version, :mac_address
+
+      def initialize(device)
+        @device = device
+        @model = device.server_info["model"]
+        @os_version = device.server_info["osBuildVersion"]
+        @mac_address = device.server_info["macAddress"]
+      end
+
+      def resolution
+        @_resolution ||= "#{@device.server_info["width"]}x#{@device.server_info["height"]}"
+      end
+    end
+  end
+end

data/lib/airplay/devices.rb

@@ -0,0 +1,46 @@
+require "forwardable"
+require "airplay/device"
+
+module Airplay
+  # Public: Represents an array of devices
+  #
+  class Devices
+    include Enumerable
+    extend  Forwardable
+
+    def_delegators :@items, :each, :size, :empty?
+
+    def initialize
+      @items = []
+    end
+
+    # Public: Finds a device given a name
+    #
+    #   device_name - The name of the device
+    #
+    # Returns a Node object
+    #
+    def find_by_name(device_name)
+      find_by_block { |device| device if device.name == device_name }
+    end
+
+    def find_by_ip(ip)
+      find_by_block { |device| device if device.ip == ip }
+    end
+
+    # Public: Adds a device to the list
+    #
+    #   value - The Node
+    def <<(device)
+      return if find_by_ip(device.ip)
+      @items << device
+    end
+
+    private
+
+    def find_by_block(&block)
+      @items.find(&block)
+    end
+
+  end
+end

data/lib/airplay/logger.rb

@@ -0,0 +1,20 @@
+require "log4r"
+
+module Airplay
+  # Public: A Log4r wrapper
+  #
+  class Logger < Log4r::Logger
+    def initialize(*)
+      super
+      add Airplay.configuration.output
+    end
+
+    # Public: Helper method to be compatible with Net::HTTP
+    #
+    #   message - The message to be logged as debug
+    #
+    def <<(message)
+      debug message
+    end
+  end
+end

data/lib/airplay/playable.rb

@@ -0,0 +1,24 @@
+require "airplay/protocol/player"
+
+module Airplay
+  module Playable
+
+    # Public: Plays a given video
+    #
+    #   file_or_url - The video to be played
+    #   options - Optional start position
+    #
+    # Returns a Player object to control the playback
+    #
+    def play(file_or_url, options = {})
+      player.async.play(file_or_url, options)
+      player
+    end
+
+    private
+
+    def player
+      @_player ||= Airplay::Protocol::Player.new(self)
+    end
+  end
+end

data/lib/airplay/protocol.rb

@@ -1,75 +1,12 @@
-class Airplay::Protocol
-  attr_reader :host, :resource, :request
-
-  DEFAULT_HEADERS = { "User-Agent" => "MediaControl/1.0" }
-  SEARCH          = '_airplay._tcp.'
-  PORT            = 7000
-
-  def initialize(host, port, password)
-    @device = { :host => host, :port => port }
-    @password = password
-    @authentications = {}
-    @http = Net::HTTP::Persistent.new
-    @http.idle_timeout = nil
-    @http.debug_output = $stdout if ENV.has_key?('HTTP_DEBUG')
-  end
-
-  def put(resource, body = nil, headers = {})
-    @request = Net::HTTP::Put.new resource
-    @request.body = body
-    @request.initialize_http_header DEFAULT_HEADERS.merge(headers)
-    make_request
-  end
-
- def post(resource, body = nil, headers = {})
-    @request = Net::HTTP::Post.new resource
-    @request.body = body
-    @request.initialize_http_header DEFAULT_HEADERS.merge(headers)
-    make_request
+module Airplay
+  # Public: The protocol module
+  #
+  module Protocol
   end
-
-  def get(resource, headers = {})
-    @request = Net::HTTP::Get.new resource
-    @request.initialize_http_header DEFAULT_HEADERS.merge(headers)
-    make_request
-  end
-
-  private
-
-  def make_request
-    path = "http://#{@device[:host]}:#{@device[:port]}#{@request.path}"
-    @uri = URI.parse(path)
-    @uri.user = "Airplay"
-    @uri.password = @password
-
-    add_auth_if_needed
-
-    response = @http.request(@uri, @request) {}
-
-    raise Airplay::Protocol::InvalidRequestError if response.code == "404"
-    response.body
-  end
-
-  def add_auth_if_needed
-    if @password
-      authenticate
-      @request.add_field('Authorization', @authentications[@uri.path])
-    end
-  end
-
-  def authenticate
-    response = @http.request(@uri, @request) {}
-    auth = response['www-authenticate']
-    digest_authentication(auth) if auth
-  end
-
-  def digest_authentication(auth)
-    digest = Net::HTTP::DigestAuth.new
-    @authentications[@uri.path] ||=
-      digest.auth_header(@uri, auth, @request.method)
-  end
-
 end
 
-class Airplay::Protocol::InvalidRequestError < StandardError; end
-class Airplay::Protocol::InvalidMediaError   < StandardError; end
+require "airplay/protocol/message"
+require "airplay/protocol/image"
+require "airplay/protocol/reverse"
+require "airplay/protocol/slideshow"
+require "airplay/protocol/player"

data/lib/airplay/protocol/app.rb

@@ -0,0 +1,52 @@
+require "cuba"
+require "base64"
+require "cfpropertylist"
+
+module Airplay::Protocol
+  # Public: The app to be mounted on the reverse connection
+  #
+  class App < Cuba
+    class << self
+      attr_accessor :pipeline
+    end
+
+    def pipe
+      self.class.pipeline.mailbox
+    end
+
+    define do
+      on post, "event" do
+        plist = CFPropertyList::List.new(data: req.body.read)
+        native_plist = CFPropertyList.native_types(plist.value)
+
+        message = Message.create(
+          type:    :event,
+          content: native_plist
+        )
+
+        pipe << message
+      end
+
+      on "slideshows/1/assets/:id" do |id|
+        image = File.read("test/fixtures/files/logo.png")
+        image.force_encoding("BINARY")
+
+        data = {
+          data: CFPropertyList::Blob.new(image),
+          info: {
+            id: 1,
+            key: id
+          }
+        }
+
+        res["Content-Type"] = "application/x-apple-binary-plist"
+
+        plist = CFPropertyList::List.new
+        plist.value = CFPropertyList.guess(data)
+        binary_plist = plist.to_str
+
+        res.write binary_plist
+      end
+    end
+  end
+end

data/lib/airplay/protocol/message.rb

@@ -0,0 +1,8 @@
+require "airplay/structure"
+
+module Airplay::Protocol
+  # Public: Basic class to represent a message from an event callback
+  #
+  class Message < Structure.new(:type, :content)
+  end
+end

data/lib/airplay/protocol/playback_info.rb

@@ -0,0 +1,49 @@
+module Airplay::Protocol
+  PlaybackInfo = Struct.new(:info) do
+    def uuid
+      info["uuid"]
+    end
+
+    def duration
+      info["duration"]
+    end
+
+    def position
+      info["position"]
+    end
+
+    def percent
+      return unless position && duration
+      (position * 100 / duration).floor
+    end
+
+    def likely_to_keep_up?
+      info["playbackLikelyToKeepUp"]
+    end
+
+    def stall_count
+      info["stallCount"]
+    end
+
+    def ready_to_play?
+      info["readyToPlay"]
+    end
+
+    def stopped?
+      info.empty?
+    end
+
+    def playing?
+      info.has_key?("rate") && info.fetch("rate", false) && !info["rate"].zero?
+    end
+
+    def paused?
+      !playing?
+    end
+
+    def played?
+      # This is weird. I know. Bear with me.
+      info.keys.size == 2
+    end
+  end
+end