dacpclient 0.2.6 → 0.2.9

data/lib/dacpclient/client.rb

@@ -1,18 +1,25 @@
-require 'faraday'
 require 'digest'
-require 'net/http'
 require 'uri'
-require 'cgi'
 require 'plist'
+require 'dmapparser'
+require 'faraday'
+require 'dacpclient/faraday/flatter_params_encoder'
 require 'dacpclient/pairingserver'
-require 'dacpclient/dmapparser'
-require 'dacpclient/dmapbuilder'
+require 'dacpclient/browser'
 require 'dacpclient/version'
+require 'dacpclient/model'
+require 'dacpclient/models/status'
+require 'dacpclient/models/pair_info'
+require 'dacpclient/models/playlist'
+require 'dacpclient/models/playlists'
+require 'dacpclient/models/play_queue_item'
+require 'dacpclient/models/play_queue'
 
 module DACPClient
   # The Client class handles communication with the server
   class Client
-    attr_accessor :guid, :hsgid
+    attr_accessor :hsgid
+    attr_writer :guid
     attr_reader :name, :host, :port, :session_id
 
     HOME_SHARING_HOST = 'https://homesharing.itunes.apple.com'
@@ -26,25 +33,23 @@ module DACPClient
     }.freeze
 
     def initialize(name, host = 'localhost', port = 3689)
-      @client = Net::HTTP.new(host, port)
       @name = name
       @host = host
       @port = port
 
       @session_id = nil
       @hsgid = nil
-      @mediarevision = 1
-      @uri = URI::HTTP.build(host: @host, port: @port)
-      @client = Faraday.new(url: @uri.to_s)
+      @media_revision = 1
+      setup_connection
     end
 
-    [:play, :playpause, :stop, :pause, 
+    [:play, :playpause, :stop, :pause,
      :nextitem, :previtem, :getspeakers].each do |action_name|
-      define_method action_name do 
+      define_method action_name do
         do_action action_name
       end
     end
-    
+
     alias_method :previous, :previtem
     alias_method :prev, :previtem
     alias_method :next, :nextitem
@@ -70,22 +75,22 @@ module DACPClient
     end
 
     def pair(pin)
-      pairingserver = PairingServer.new(self, '0.0.0.0', 1024)
+      pairingserver = PairingServer.new(name, guid)
       pairingserver.pin = pin
       pairingserver.start
     end
 
     def serverinfo
-      do_action('server-info', {}, true)
+      do_action('server-info', clean_url: true)
     end
 
     def login
       response = nil
       if @hsgid.nil?
         pairing_guid = '0x' + guid
-        response = do_action(:login, 'pairing-guid' => pairing_guid)
+        response = do_action(:login,  :'pairing-guid' => pairing_guid)
       else
-        response = do_action(:login, 'hasFP' => '1')
+        response = do_action(:login, hasFP: 1)
       end
       @session_id = response[:mlid]
       response
@@ -93,16 +98,22 @@ module DACPClient
 
     def pair_and_login(pin = nil)
       login
-    rescue DACPForbiddenError => e
+    rescue DACPForbiddenError, Faraday::ConnectionFailed => e
       pin = 4.times.map { Random.rand(10) } if pin.nil?
-      warn "#{e.result.status} error: Cannot login, starting pairing process"
+      if e.instance_of? DACPForbiddenError
+        message = e.result.status
+      else
+        message = e
+      end
+      warn "#{message} error: Cannot login, starting pairing process"
       warn "Pincode: #{pin}"
-      pair(pin)
+      @host = pair(pin).host
+      setup_connection
       retry
     end
 
     def content_codes
-      do_action('content-codes', {}, true)
+      do_action('content-codes', clean_url: true)
     end
 
     def track_length
@@ -122,9 +133,10 @@ module DACPClient
     alias_method :position=, :seek
 
     def status(wait = false)
-      revision = wait ? @mediarevision : 1
-      result = do_action(:playstatusupdate, 'revision-number' => revision)
-      @mediarevision = result[:cmsr]
+      revision = wait ? @media_revision : 1
+      result = do_action(:playstatusupdate, :'revision-number' => revision,
+                                            model: Status)
+      @media_revision = result.media_revision
       result
     rescue Faraday::Error::TimeoutError => e
       if wait
@@ -140,7 +152,7 @@ module DACPClient
     end
 
     def volume=(volume)
-      do_action(:setproperty, 'dmcp.volume' => volume)
+      do_action(:setproperty, :'dmcp.volume' => volume)
     end
 
     def repeat
@@ -162,12 +174,12 @@ module DACPClient
     end
 
     def ctrl_int
-      do_action('ctrl-int', {}, true)
+      do_action('ctrl-int', clean_url: true)
     end
 
     def logout
       do_action(:logout)
-      @mediarevision = 1
+      @media_revision = 1
       @session_id = nil
     end
 
@@ -181,35 +193,37 @@ module DACPClient
     end
 
     def list_queue
-      do_action('playqueue-contents')
+      do_action('playqueue-contents', model: PlayQueue)
     end
 
     def databases
-      do_action('databases', {}, true)
+      do_action('databases', clean_url: true)
     end
 
-    def playlists(db)
-      do_action("databases/#{db}/containers", {}, true)
+    def playlists(db = default_db)
+      do_action("databases/#{db.miid}/containers", clean_url: true,
+                                                   model: Playlists).items
     end
 
     def default_db
-      databases[:mlcl].to_a.find { |item| item.mdbk == 1 }
+      databases.mlcl.to_a.find { |item| item.mdbk == 1 }
     end
 
-    def default_playlist(db)
-      @client.playlists(72).mlcl.to_a.find { |item| item.abpl }
+    def default_playlist(db = default_db)
+      playlists(db).find { |item| item.base_playlist? }
     end
 
     def artwork(database, id, width = 320, height = 320)
       url = "databases/#{database}/items/#{id}/extra_data/artwork"
-      do_action(url, { mw: width, mh: height }, true)
+      do_action(url, { mw: width, mh: height }, clean_url: true)
     end
 
     def now_playing_artwork(width = 320, height = 320)
       do_action(:nowplayingartwork, mw: width, mh: height)
     end
 
-    def search(db, container, search, type = nil)
+    def search(search, type = nil, db = default_db,
+               container = default_playlist(default_db))
       search = URI.escape(search)
       types = {
         title: 'dmap.itemname',
@@ -225,40 +239,54 @@ module DACPClient
       end
 
       q = queries.join(',')
-      meta  = %w(dmap.itemname dmap.itemid daap.songartist daap.songalbumartist
+      q = '(' + q + ')' if queries.length > 1
+      meta  = %w(dmap.itemname dmap.itemid com.apple.itunes.has-chapter-data
                  daap.songalbum com.apple.itunes.cloud-id dmap.containeritemid
                  com.apple.itunes.has-video com.apple.itunes.itms-songid
                  com.apple.itunes.extended-media-kind dmap.downloadstatus
-                 daap.songdisabled).join(',')
-
-      url = "databases/#{db}/containers/#{container}/items"
-      do_action(url, { type: 'music', sort: 'album', query: q, meta: meta },
-                true)
+                 daap.songdisabled daap.songhasbeenplayed daap.songbookmark
+                 com.apple.itunes.is-hd-video daap.songlongcontentdescription
+                 daap.songtime daap.songuserplaycount daap.songartist
+                 com.apple.itunes.content-rating daap.songdatereleased
+                 com.apple.itunes.movie-info-xml daap.songalbumartist
+                 com.apple.itunes.extended-media-kind).join(',')
+      url = "databases/#{db.miid}/containers/#{container.miid}/items"
+      do_action(url, { query: q, type: 'music', sort: 'album', meta: meta,
+                       :'include-sort-headers' => 1 }, clean_url: true)
     end
 
     private
 
-    def do_action(action, params = {}, cleanurl = false)
+    def setup_connection
+      @uri = URI::HTTP.build(host: @host, port: @port)
+      Faraday::Utils.default_params_encoder = Faraday::FlatterParamsEncoder
+      @client = Faraday.new(@uri.to_s)
+    end
+
+    def do_action(action, clean_url: false, model: nil, **params)
       action = '/' + action.to_s
       unless @session_id.nil?
-        params['session-id'] = @session_id
-        action = '/ctrl-int/1' + action unless cleanurl
+        params['session-id'] = @session_id.to_s
+        action = '/ctrl-int/1' + action unless clean_url
       end
       params['hsgid'] = @hsgid unless @hsgid.nil?
+      
       result = @client.get do |request|
+        request.options.params_encoder = Faraday::FlatterParamsEncoder
         request.url action
         request.params = params
         request.headers.merge!(DEFAULT_HEADERS)
       end
 
-      parse_result result
+      parse_result result, model
     end
-    
-    def parse_result(result)
+
+    def parse_result(result, model)
       if !result.success?
         fail DACPForbiddenError, result
       elsif result.headers['Content-Type'] == 'application/x-dmap-tagged'
-        DMAPParser.parse(result.body)
+        res = DMAPParser::Parser.parse(result.body)
+        model ? model.new(res) : res
       else
         result.body
       end

data/lib/dacpclient/faraday/flatter_params_encoder.rb

@@ -0,0 +1,77 @@
+# rubocop:disable all
+require 'cgi'
+module Faraday
+  module FlatterParamsEncoder
+    def self.escape(s)
+      s.to_s.gsub(/[^a-zA-Z0-9 .~_\-,:\*'\+()]/) do
+        '%' + $&.unpack('H2' * $&.bytesize).join('%').upcase
+      end.tr(' ', '+')
+    end
+    
+    def self.unescape(s)
+      CGI.unescape(s.to_s)
+    end
+
+    def self.encode(params)
+      return nil if params.nil?
+
+      unless params.is_a?(Array)
+        unless params.respond_to?(:to_hash)
+          fail TypeError,
+               "Can't convert #{params.class} into Hash."
+        end
+        params = params.to_hash
+        params = params.map do |key, value|
+          key = key.to_s if key.kind_of?(Symbol)
+          [key, value]
+        end
+        # Useful default for OAuth and caching.
+        # Only to be used for non-Array inputs. Arrays should preserve order.
+        params.sort!
+      end
+
+      # The params have form [['key1', 'value1'], ['key2', 'value2']].
+      buffer = ''
+      params.each do |key, value|
+        encoded_key = escape(key)
+        value = value.to_s if value == true || value == false
+        if value.nil?
+          buffer << "#{encoded_key}&"
+        elsif value.kind_of?(Array)
+          value.each do |sub_value|
+            encoded_value = escape(sub_value)
+            buffer << "#{encoded_key}=#{encoded_value}&"
+          end
+        else
+          encoded_value = escape(value)
+          buffer << "#{encoded_key}=#{encoded_value}&"
+        end
+      end
+      buffer.chop
+    end
+
+    def self.decode(query)
+      empty_accumulator = {}
+      return nil if query.nil?
+      split_query = (query.split('&').map do |pair|
+        pair.split('=', 2) if pair && !pair.empty?
+      end).compact
+      split_query.reduce(empty_accumulator.dup) do |accu, pair|
+        pair[0] = unescape(pair[0])
+        pair[1] = true if pair[1].nil?
+        if pair[1].respond_to?(:to_str)
+          pair[1] = unescape(pair[1].to_str.gsub(/\+/, ' '))
+        end
+        if accu[pair[0]].kind_of?(Array)
+          accu[pair[0]] << pair[1]
+        elsif accu[pair[0]]
+          accu[pair[0]] = [accu[pair[0]], pair[1]]
+        else
+          accu[pair[0]] = pair[1]
+        end
+        accu
+      end
+    end
+  end
+end
+# rubocop:enable all

data/lib/dacpclient/model.rb

@@ -0,0 +1,117 @@
+module DACPClient
+  class Model
+    class DMAPAttribute < Struct.new(:tag, :item_class, :value)
+      def initialize(tag, item_class = nil)
+        super tag, item_class, nil
+      end
+    end
+
+    def initialize(params = {})
+      if params.is_a? DMAPParser::TagContainer
+        deserialize(params)
+      elsif params
+        params.each do |attr, value|
+          public_send("#{attr}=", value)
+        end
+      end
+    end
+
+    def inspect
+      puts self.class.name
+      dmap_attributes.each do |key, value|
+        puts "  #{key}: #{value.value}"
+      end
+    end
+
+    def to_s
+      "#<#{self.class.name} " +  dmap_attributes.map do |key, value|
+        "#{key}: #{value.value}"
+      end.join(', ') + '>'
+    end
+
+    def to_dmap
+      attributes = dmap_attributes
+      DMAPParser::Builder.send dmap_tag do
+        attributes.values.each do |value|
+          send(value.tag, value.value)
+        end
+      end.to_dmap
+    end
+
+    def method_missing(method, *args, &block)
+      if method.to_s =~ /(.*)\=$/ &&
+         dmap_attributes.key?(Regexp.last_match[1].to_sym)
+        dmap_attributes[Regexp.last_match[1].to_sym].value = args.first
+      elsif method.to_s =~ /(.*)\?$/ &&
+            dmap_attributes.key?(Regexp.last_match[1].to_sym)
+        dmap_attributes[Regexp.last_match[1].to_sym].value
+      elsif dmap_attributes.key? method
+        dmap_attributes[method].value
+      else
+        super
+      end
+    end
+
+    class << self
+      def dmap_attribute(method, key)
+        @dmap_attributes ||= {}
+        @dmap_attributes[method] = key
+      end
+
+      def dmap_container(method, key, item_class)
+        @dmap_attributes ||= {}
+        @dmap_attributes[method] = [key, item_class]
+      end
+
+      def dmap_tag(tag = nil)
+        if tag
+          @dmap_tag = tag
+        else
+          @dmap_tag
+        end
+      end
+
+      def build_dmap(params = {})
+        new(params).to_dmap
+      end
+    end
+
+    private
+
+    def deserialize(data)
+      warn 'Invalid tag' if data.type.tag.to_sym != dmap_tag
+      dmap_attributes.values.each do |value|
+        value.value = get_value(data, value) if data.respond_to? value.tag
+      end
+      self
+    end
+
+    def get_value(data, value)
+      item_class = value.item_class
+      if item_class
+        data.send(value.tag).to_a.map do |item|
+          item_class.new(item) if item_class.dmap_tag == item.type.tag.to_sym
+        end.compact
+      else
+        data.send(value.tag)
+      end
+    end
+
+    def dmap_attributes
+      @dmap_attributes ||= initialize_attributes
+    end
+
+    def initialize_attributes
+      class_attributes = self.class.instance_variable_get(:@dmap_attributes)
+      attributes = {}
+      class_attributes.map do |key, value|
+        attributes[key] = DMAPAttribute.new(*value)
+      end
+      attributes
+    end
+
+    def dmap_tag
+      self.class.instance_variable_get(:@dmap_tag)
+    end
+  end
+end

data/lib/dacpclient/models/pair_info.rb

@@ -0,0 +1,15 @@
+module DACPClient
+  class PairInfo < Model
+    dmap_tag :cmpa
+
+    dmap_attribute :pairing_code, :cmpg
+    dmap_attribute :name, :cmnm
+    dmap_attribute :type, :cmty
+
+    # DMAPParser::Builder.cmpa do
+    #   cmpg pair
+    #   cmnm name
+    #   cmty device_type
+    # end.to_dmap
+  end
+end

data/lib/dacpclient/models/play_queue.rb

@@ -0,0 +1,11 @@
+module DACPClient
+  class PlayQueue < Model
+    dmap_tag :ceQR
+    dmap_attribute :status, :mstt
+    dmap_attribute :container_count, :mtco
+    dmap_attribute :shuffle_mode, :apsm
+    dmap_attribute :repeat_mode, :aprm
+    # ceQu (unknown (1): unknown): 0
+    dmap_container :items, :mlcl, DACPClient::PlayQueueItem
+  end
+end

data/lib/dacpclient/models/play_queue_item.rb

@@ -0,0 +1,17 @@
+module DACPClient
+  class PlayQueueItem < Model
+    dmap_tag :mlit
+    dmap_attribute :track_id, :ceQs
+    dmap_attribute :title, :ceQn
+    dmap_attribute :artist, :ceQr
+    dmap_attribute :album, :ceQa
+    dmap_attribute :genre, :ceQg
+    dmap_attribute :album_id, :asai
+
+    dmap_attribute :media_kind, :cmmk
+    dmap_attribute :song_time, :astm
+
+    # aeGs (com.apple.itunes.can-be-genius-seed: bool): true
+    # ceGS (com.apple.itunes.genius-selectable: bool): true
+  end
+end

data/lib/dacpclient/models/playlist.rb

@@ -0,0 +1,9 @@
+module DACPClient
+  class Playlist < Model
+    dmap_tag :mlit
+    dmap_attribute :item_id, :miid
+    dmap_attribute :name, :minm
+    dmap_attribute :base_playlist, :abpl
+    dmap_attribute :count, :mimc
+  end
+end

data/lib/dacpclient/models/playlists.rb

@@ -0,0 +1,10 @@
+module DACPClient
+  class Playlists < Model
+    dmap_tag :aply
+    dmap_attribute :status, :mstt
+    dmap_attribute :update_type, :myty
+    dmap_attribute :container_count, :mtco
+    dmap_attribute :returned_count, :mrco
+    dmap_container :items, :mlcl, DACPClient::Playlist
+  end
+end

data/lib/dacpclient/models/status.rb

@@ -0,0 +1,44 @@
+module DACPClient
+  class Status < Model
+    dmap_tag :cmst
+    dmap_attribute :media_revision, :cmsr
+    dmap_attribute :status_code, :mstt
+    dmap_attribute :play_status, :caps
+    dmap_attribute :shuffle_state, :cash
+    dmap_attribute :repeat_state, :carp
+    dmap_attribute :fullscreen, :cafs
+    dmap_attribute :visualizer, :cavs
+    dmap_attribute :volume_controllable, :cavc
+    dmap_attribute :album_shuffle, :caas
+    dmap_attribute :album_repeat, :caar
+    dmap_attribute :fullscreen_enabled, :cafe
+    dmap_attribute :visualizer_enabled, :cave
+    dmap_attribute :track_id, :canp
+    dmap_attribute :title, :cann
+    dmap_attribute :artist, :cana
+    dmap_attribute :album, :canl
+    dmap_attribute :album_id, :asai
+    dmap_attribute :media_kind, :cmmk
+    dmap_attribute :song_time, :astm
+    dmap_attribute :song_length, :cast
+    dmap_attribute :song_remaining_time, :cant
+
+    def song_position
+      return 0 unless song_length? && song_remaining_time?
+      song_length - song_remaining_time
+    end
+
+    def stopped?
+      play_status == 2
+    end
+
+    def playing?
+      play_status == 4
+    end
+
+    def paused?
+      !stopped? && !playing?
+    end
+    # casu (dacp.su: byte): 0
+  end
+end

data/lib/dacpclient/pairingserver.rb

@@ -2,19 +2,22 @@ require 'socket'
 require 'dnssd'
 require 'digest'
 require 'gserver'
+require 'dmapparser/builder'
 module DACPClient
   # The pairingserver handles pairing with iTunes
   class PairingServer < GServer
     attr_accessor :pin, :device_type
+    attr_reader :peer
 
     MDNS_TYPE = '_touch-remote._tcp'.freeze
 
-    def initialize(client, host, port = 1024)
-      @name = client.name
+    def initialize(name, guid, host = '0.0.0.0', port = 1024)
+      @name = name
       @port = port
       @host = host
-      @pair = client.guid
+      @pair = guid
       @pin = [0, 0, 0, 0]
+      @peer = nil
       @device_type = 'iPod'
       super port, host
     end
@@ -23,24 +26,33 @@ module DACPClient
       @pairing_string = generate_pairing_string(@pair, @name, @device_type)
       @expected = PairingServer.generate_pin_challenge(@pair, @pin)
       @service = DNSSD.register!(@name, MDNS_TYPE, 'local', @port, text_record)
-
+      @pairing_string
+      PairInfo.new(DMAPParser::Parser.parse(@pairing_string))
       super
       join
 
       @service.stop
 
       sleep 0.5 # sleep so iTunes accepts our login
+      peer
     end
 
     def self.generate_pin_challenge(pair, pin)
       pin_string = pin.map { |i| "#{i}\x00" }.join
-      Digest::MD5.hexdigest(pair.upcase + pin_string)
+      Digest::MD5.hexdigest(pair.upcase + pin_string).upcase
     end
 
     def serve(client)
-      if client.gets =~ /pairingcode=#{@expected}/i
-        client.print "HTTP/1.1 200 OK\r\n" +
-                     "Content-Length: #{@pairing_string.length}\r\n\r\n"
+      data = client.gets
+      peer_addr = client.peeraddr[2]
+      browser = DACPClient::Browser.new
+      browser.browse
+      @peer = browser.devices.find do |device|
+        device.host == peer_addr
+      end
+      if data =~ /pairingcode=#{@expected}/i && @peer
+        client.print "HTTP/1.1 200 OK\n" +
+                     "Content-Length: #{@pairing_string.length}\n\n"
         client.print @pairing_string
         client.close
         stop
@@ -64,11 +76,7 @@ module DACPClient
     end
 
     def generate_pairing_string(pair, name, device_type)
-      DMAPBuilder.cmpa do
-        cmpg pair
-        cmnm name
-        cmty device_type
-      end.to_dmap
+      PairInfo.build_dmap(pairing_code: pair, name: name, type: device_type)
     end
   end
 end

data/lib/dacpclient/version.rb

@@ -1,4 +1,4 @@
 # The DACPClient module
 module DACPClient
-  VERSION = '0.2.6'
+  VERSION = '0.2.9'
 end