rubymtp 0.1

data/lib/mtp/object.rb

@@ -0,0 +1,122 @@
+module MTP
+  class Object
+    
+    attr_reader(:ph, :properties, :id, :format, :protection_status, :compressed_size, :thumb_format, :thumb_compressed_size,
+                :thumb_pix_width, :thumb_pix_height, :image_pix_with, :image_pix_height, :image_bit_depth,
+                :sequence_number)
+    attr_accessor :compressed_size, :filename, :date_created, :date_modified, :keywords, :association, :data
+    
+    PROTECTION_STATUS = { 0x0000 => "No protection", 0x0001 => "Read-only", 0x8002 => "Read-only Data", 0x8003 => "Non-transferable data"}
+      
+    def initialize
+      @properties = Properties.new(self)
+    end
+
+    def self.property_writer(*properties)
+      properties.each do |property|
+        Object.class_eval %{
+          def #{property}=(prop)
+            properties.#{property} = prop
+          end
+        }
+      end
+    end
+
+    def self.property_reader(*properties)
+      properties.each do |property|
+        Object.class_eval %{
+          def #{property}
+            properties.#{property}
+          end
+        }
+      end
+    end
+
+    def self.property_accessor(*properties)
+      Object.property_reader(*properties)
+      Object.property_writer(*properties)
+    end
+
+    def self.register_format(klass, code)
+      @@format_classes ||= Hash.new { |h,k| h[k] = Object }
+      @@format_classes[code.to_i] = klass
+    end
+
+    
+    def self.load(ph, id, storage = nil)
+      object = nil
+      t = ph.transaction.get_object_info(id)
+      t.expect("OK")
+      storage_id, format = t.data.payload.unpack("VK")
+      object = @@format_classes[format.to_i].new
+      object.load(ph, id, t.data.payload)
+    end
+    
+    def load(ph, id, payload, storage = nil)
+      @id = id
+      @ph = ph
+      @storage = storage
+      @sent = true
+      storage_id, @format, @protection_status, @compressed_size, @thumb_format,
+      @thumb_compressed_size, @thumb_pix_width, @thumb_pix_height, @image_pix_width, @image_pix_height, @image_bit_depth,
+      @parent_id, association_code, association_desc, @sequence_number, @filename, @date_created, @date_modified, @keywords =
+        payload.unpack("VKSIKIIIIIIISIIJDDJ")
+      @protection_status = Datacode.new(@protection_status, PROTECTION_STATUS)
+      @association = Association.load(association_code, association_desc)
+      self
+    end
+    
+    def inspect
+      "#<MTP::Object:0x%08x @format=#{@format.name.inspect} @filename=#{@filename.inspect} @parent_id=0x%08x>" % [ @id, @parent_id ]
+    end
+
+    def dump_properties
+      puts "0x%04x:%16s: %64s %s" % [ 0, "id", @id, "ro" ]
+      properties.supported.each do |property|
+        p = properties.get_value(property)
+        puts "0x%04x:%16s: %64s %s" % [ p.code.to_i, property, p.value, (p.writable? ? 'rw' : 'ro') ]
+      end
+    end
+      
+    def format=(code)
+      @format = (code.is_a?(Datacode) ? code : Datacode.new(code, nil, MTP::Datacode::Masks::OBJECT_FORMAT))
+    end
+    
+    def association
+      @association ||= Association.load(0, 0)
+    end
+    
+    def valid?
+      !@format.nil? and !@compressed_size.nil?
+    end
+    
+    
+    def pack
+      [ 0, @format, @protection_status || 0, @compressed_size || 0, @thumb_format || 0, # VKSIK
+        @thumb_compressed_size || 0, @thumb_pix_width || 0, @thumb_pix_height || 0,     #III
+        @image_pix_width || 0, @image_pix_height || 0, @image_bit_depth || 0,           #III
+        @parent_id || 0, association.code, association.desc, @sequence_number || 0,     #IKII
+        @filename, @date_created, @date_modified, @keywords || "" ].pack("VKSIKIIIIIIIKIIJDDJ")
+    end
+    
+    def new_object?
+      !@sent
+    end
+    
+    def before_sending(ph)
+      @ph = ph
+    end
+    
+    def after_sending
+      @sent = true
+    end
+
+    def <=>(object)
+      @id <=> object.id 
+    end
+    
+    def data
+      @data || Data.new("\0\0", @compressed_size)
+    end
+  end
+end

data/lib/mtp/playlist.rb

@@ -0,0 +1,60 @@
+module MTP
+  class Playlist < Object
+    include Enumerable
+    
+    register_format self, Datacode.new("AbstractAudioVideoPlaylist")
+    property_accessor :name
+
+    def initialize
+      super
+      self.format = "AbstractAudioVideoPlaylist"
+      self.compressed_size = 0
+      @data = Data.new("\0\0")
+    end
+    
+    def load(ph, id, payload)
+      super(ph, id, payload)
+    end
+
+    def each
+      MTP.logger.info("retrieving playlist reference")
+      t = @ph.transaction.get_object_references(id)
+      t.expect("OK")
+      t.data.payload.unpack("V+").first.each do |object_id|
+        yield @ph.device[object_id] unless @ph.device[object_id].nil?
+      end
+    end
+    
+    def <<(object)
+      current_ids = map { |o| o.id }
+      current_ids << object.id
+      store_references(current_ids)
+    end
+
+    def delete(object)
+      current_ids = select { |o| o.id != object.id }
+      current_ids.map! { |o| o.id }
+      store_references(current_ids)
+    end
+    
+    def sort!(&block)
+      current_ids = sort(&block).map { |o| o.id }
+      store_references(current_ids)
+    end
+
+    def sort_by!(&block)
+      current_ids = sort_by(&block).map { |o| o.id }
+      store_references(current_ids)
+    end
+
+    private 
+    def store_references(ids)
+      t = @ph.transaction
+      t.data = Data.new([ ids ].pack("V+"))
+      t.set_object_references(id)
+      t.expect("OK")
+      self
+    end
+      
+  end
+end

data/lib/mtp/podcast.rb

@@ -0,0 +1,162 @@
+require 'mtp'
+require 'yaml'
+require 'syndication/rss'
+require 'syndication/podcast'
+require 'open-uri'
+require 'fileutils'
+require 'facets/more/times'
+require 'facet/date/to_time'
+
+class Syndication::RSS::Item
+  attr_accessor :keep
+end
+
+
+module MTP
+  class Podcast
+    @@logger = Logger.new(STDERR)
+    def self.logger
+      @@logger
+    end
+    
+    def logger
+      @@logger
+    end
+    
+    class Feed
+      attr_accessor :title, :url, :keep
+      def initialize(title, options = {})
+        @title = title
+        @url = options["url"] || options[:url]
+        @keep = options["keep"] || options[:keep]
+      end
+     
+      def items
+        content = nil
+        open(@url) { |s| content = s.read }
+        parser = Syndication::RSS::Parser.new
+        rss = parser.parse(content)
+        rss.items.select { |i| i.keep = @keep; i.pubdate.to_time > @keep.days.ago }
+      end
+    end
+    
+    def initialize(device, options = {})
+      @device = device
+      @playlist_name = options[:playlist] || "podcasts"
+      @configuration_dir = File.join(ENV['HOME'], '.mtp-podcast')
+      @configuration_file = options[:configuration] || File.join(@configuration_dir, 'config.yml')
+    end
+    
+    def playlist
+      return @playlist unless @playlist.nil?
+      
+      @playlist = @device.playlists.detect { |p| p.name == @playlist_name }
+      
+      if @playlist.nil?
+        @playlist = Playlist.new
+        @device.send(@playlist)
+        @playlist.name = @playlist_name
+      end
+        
+      @playlist
+    end
+    
+    def default_configuration
+      [ "feeds" => [] ]
+    end
+    
+    def configuration
+      return @configuration unless @configuration.nil?
+
+      Dir.mkdir(@configuration_dir) unless File.exists?(@configuration_dir)
+      if File.exists?(@configuration_file)
+        File.open(@configuration_file, 'r') do |f|
+          @configuration = YAML.load(f)
+        end
+      else
+        @configuration = default_configuration
+      end
+      @configuration
+    end
+    
+    def feeds
+      @feeds ||= configuration["feeds"].keys.map do |k| 
+        options = configuration["feeds"][k]
+        options["directory"] = File.join(@configuration_dir, 'feeds', k) if options["directory"].nil?
+        Feed.new(k, options)
+      end
+    end
+    
+    def update
+      items = feeds.inject([]) { |ary, feed| ary + feed.items }
+      items.sort! { |a, b| a.pubdate <=> b.pubdate }
+
+      
+      playlist.each do |track|
+        in_rss_list = nil
+        items.each do |item|
+          if File.basename(item.enclosure.url) == track.filename
+            in_rss_list = item
+            break
+          end
+        end
+
+        # remove from device the tracks which aren't in rss or which are too old
+        if in_rss_list.nil? or in_rss_list.pubdate.to_time < in_rss_list.keep.days.ago
+          puts "removing #{track.filename}"
+          playlist.delete(track)
+          @device.delete(track)
+        else
+          puts "skipping #{track.filename}"
+          items.delete(in_rss_list)
+        end
+      end
+      
+      # download missing items
+      items.each do |item|
+        puts "downloading #{File.basename(item.enclosure.url)}"
+        uri = URI.parse(item.enclosure.url)
+        
+        # connect to server
+        Net::HTTP.start(uri.host, uri.port) do |http|
+          
+          # big hack to access socket io
+          netio = http.instance_variable_get(:@socket)
+          if netio.respond_to?(:io)
+            sock = netio.io # 1.9
+          else
+            sock = netio.instance_variable_get(:@socket) # 1.8
+          end
+          
+          # execute request
+          request = Net::HTTP::Get.new(uri.path)
+          request["host"] = (uri.port ? "#{uri.host}:#{uri.port}" : uri.host)
+          request.exec(sock, Net::HTTP::HTTPVersion, request.path)
+          
+          # fetch headers
+          while (str = sock.readline) != "\r\n"
+            if str.match(/^Content-Length:\s*(\d+)\s*$/)
+              length = $1.to_i
+            end
+          end
+
+          # store object
+          object = MP3Track.new
+          object.filename = File.basename(item.enclosure.url)
+          object.compressed_size = length
+          @device.send(object, sock) do |written, total|
+            printf("%02u%% %u/%u\r", written * 100/total, written, total)
+          end
+          printf("\n")
+          object.name = item.title
+          object.artist = item.itunes_author
+          object.duration = item.itunes_duration * 1000
+          playlist << object
+        end
+      end
+    end
+  end
+end
+
+
+

data/lib/mtp/properties.rb

@@ -0,0 +1,226 @@
+module MTP
+  class Properties
+    def initialize(object)
+      @object = object
+    end
+    
+    def clear
+      @supported = nil
+    end
+    
+    def supported
+      return @supported unless @supported.nil?
+      
+      t = @object.ph.transaction.get_object_props_supported(@object.format)
+      t.expect("OK")
+      @supported = t.data.payload.unpack("K+").first
+    end
+
+    def writable
+      supported.select { |p| Property.description(@object, p).writable? }
+    end
+    
+    def supports?(code)
+      supported.include?(code)
+    end
+    
+    def get_value(code)
+      code = Property.code(code)
+      raise UnsupportedProperty.new(@object, code)  unless supports?(code)
+      Property.get(@object, code)
+    end
+
+    def set_value(code, value)
+      code = Property.code(code)
+      raise UnsupportedProperty.new(self, code) unless supports?(code)
+      Property.set(@object, code, value)
+    end  
+    
+    def method_missing(method, *args)
+      method = method.to_s
+      if method[-1,1] == '='
+        method.slice!(-1,1)
+        set_value(method.camelize, *args).value
+      else
+        get_value(method.camelize, *args).value
+      end
+    end
+    
+    class Property
+      @@descriptions = {}
+      
+      attr_reader :description, :code, :value
+      
+      def self.description(object, code)
+        raise UnsupportedProperty.new(object, code) unless object.properties.supports?(code)
+        @@descriptions[code.to_i] ||= PropertyDescription.load(object.ph, code, object.format)
+      end
+      
+      def self.code(code)
+        (code.is_a?(Datacode) ? code : Datacode.new(code, nil, MTP::Datacode::Masks::OBJECT_PROPERTY))
+      end
+      
+      def self.get(object, c)
+        raise MTPError.new("object is not stored on the device") if object.new_object?
+        prop = Property.new
+        prop.instance_eval do
+          @object = object
+          @code = Property.code(c)
+          @description = Property.description(object, @code)
+          t = object.ph.transaction.get_object_prop_value(object.id, @code)
+          t.expect("OK")
+          @value = @description.unpack(t.data.payload)
+        end
+        prop
+      end
+
+      def self.set(object, c, value)
+        raise MTPError.new("object is not stored on the device") if object.new_object?
+        prop = Property.new
+        prop.instance_eval do
+          @object = object
+          @code = Property.code(c)
+          @description = Property.description(object, @code)
+          t = object.ph.transaction
+          t.data = Data.new(@description.pack(value))
+          t.set_object_prop_value(object.id, @code)
+          t.expect("OK")
+          @value = value
+        end
+        prop
+      end
+      
+      def writable?
+        Property.description(@object, @code).writable?
+      end
+    end
+    
+    class PropertyDescription
+      attr_reader :datatype, :form
+      def self.load(ph, code, format)
+        prop_desc = PropertyDescription.new
+        t = ph.transaction.get_object_prop_desc(code, format)
+        t.expect("OK")
+        prop_desc.instance_eval do
+          @format = format
+          @code, @datatype, @access, str = t.data.payload.unpack("KSCa*")
+          @dts = Datacode.new(@datatype, MTP::DATA_TYPE_PACK)
+          @datatype = Datacode.new(@datatype, MTP::DATA_TYPES)
+          @default_value, group_code, form_flag, form =
+            str.unpack("#{@dts.name}VCa*")
+          @form = Forms.load(form_flag, form, @dts)
+        end
+        prop_desc
+      end
+      
+      def unpack(raw_value)
+        if raw_value.empty?
+          nil
+        else
+          @form.unpack(@datatype, @dts, raw_value)
+        end
+      end
+      
+      def pack(value)
+        @form.pack(@datatype, @dts, value)
+      end
+      
+      def writable?
+        @access == 1
+      end
+    end
+    
+    module Forms
+      def self.load(form_flag, form, dts)
+        FORM_FLAGS[form_flag].new(form, dts)
+      end
+      
+      class None
+        def initialize(form, dts)
+        end
+        
+        def unpack(datatype, dts, raw_value)
+          if datatype.name == "String"
+            raw_value.unpack("J").first
+          elsif (datatype & 0x4000) == 0x4000
+            raw_value.unpack("#{dts}+").first
+          else
+            raw_value.unpack("#{dts}").first
+          end
+        end
+        
+        def pack(datatype, dts, value)
+          if datatype.name == "String"
+            [ value ].pack("J")
+          elsif (datatype & 0x4000) == 0x4000
+            [ value ].pack("#{dts}+")
+          else
+            [ value ].pack("#{dts}")
+          end
+        end
+      end
+        
+      class Range < None
+        attr_reader :minimum_value, :maximum_value, :step_size
+        def initialize(form, dts)
+          @minimum_value, @maximum_value, @step_size = form.unpack(dts.name * 3)
+        end
+      end
+      
+      class Enumeration < None
+        attr_reader :values
+        def initialize(form, dts)
+          num, *@values = form.unpack("S#{dts.name}*")
+        end
+      end
+      
+      class DateTime < None
+        def initialize(form, dts)
+        end
+        
+        def unpack(datatype, dts, raw_value)
+          raw_value.unpack("D").first
+        end
+        
+        def pack(datatype, dts, value)
+          [ value ].pack("D")
+        end
+      end
+      
+      class FixedLengthArray < None
+        attr_reader :size
+        def initialize(form, dts)
+          @size = form.unpack("S")
+        end
+      end
+      
+      class RegularExpression < None
+        attr_reader :regexp
+        def initialize(form, dts)
+          @regexp = Regexp.new(form.unpack("J")) unless form.empty?
+        end
+      end
+      
+      class ByteArray < None
+        attr_reader :max_length
+        def initialize(form, dts)
+          @max_length = form.unpack("S")
+        end
+      end
+      
+      class LongString < None
+        attr_reader :max_length
+        def initialize(form, dts)
+          @max_length = form.unpack("S")
+        end
+      end
+      
+      FORM_FLAGS = { 
+        0x00 => None, 0x01 => Range, 0x02 => Enumeration, 0x03 => DateTime,
+        0x04 => FixedLengthArray, 0x05 => RegularExpression, 0x06 => ByteArray, 0xFF => String
+      }
+    end
+  end
+  
+
+end