rubymtp 0.1

data/lib/mtp/protocol.rb

@@ -0,0 +1,298 @@
+require 'facet/string/camelize'
+
+module MTP
+  class Protocol
+    
+    @@logger = Logger.new(STDERR)
+    @@logger.level = Logger::INFO
+
+    def self.logger
+      @@logger
+    end
+    
+    class EndPoints
+      attr_reader :in, :out, :interrupt
+      def initialize(protocol)
+        protocol.interface.endpoints.each do |ep|
+          if (ep.bEndpointAddress & 0b10000000).zero?
+            @out = ep
+          else
+            if ep.bmAttributes == 0x02
+              @in = ep
+            elsif ep.bmAttributes == 0x03
+              @interrupt = ep
+            end            
+          end
+        end
+      end
+    end
+    
+    class Transaction
+      attr_accessor :request, :data, :io
+      attr_reader :response
+      def initialize(ph)
+        @ph = ph
+        @io = io
+      end
+      
+      def io?
+        !@io.nil?
+      end
+      
+      def send_data(&block)
+        @data.transaction_id = @request.transaction_id
+        @data.code = @request.code
+          
+        if @ph.split_data_packets?
+          Protocol.logger.debug(sprintf("=> %-8s: 0x%08x, 0x%04x - %s", "DATA", @data.transaction_id, @data.code, @data.code.name))
+          @ph.raw_send(@data.pack_header)
+          if io?
+            @ph.raw_send_io(@io, @data.size, &block)
+          else
+            @ph.raw_send(@data.pack_payload, &block)
+          end
+        else
+          @ph.send(@data) 
+        end        
+      end
+      
+      def read_data(&block)
+        @data = @response
+        if @ph.split_data_packets?
+          if io?
+            @data.payload = @ph.raw_read_io(@io, @data.length - 12, &block)
+          else
+            @data.payload = @ph.raw_read
+          end
+        end  
+      end
+      
+      def execute(&block)
+        @ph.send(@request)
+        send_data(&block) unless @data.nil?
+        @response = @ph.receive
+        if @response.is_a?(Data)
+          read_data(&block) 
+          @response = @ph.receive
+        end
+        self
+      end
+
+      def expect(*expects)
+        unless expects.empty? or @response.one_of?(*expects)
+          raise CommandError.new(@ph, @request, @response)
+        end
+      end
+      
+      def method_missing(method, *args, &block)
+        method = method.to_s
+        if method.match(/^(.*)_with_io$/)
+          method = $1
+          @io = args.shift 
+        end
+        @request = Request.for(method.to_s.camelize, *args)
+        execute(&block)
+        self
+      end
+    end
+    
+    def self.mtp?(usb_device, timeout = 1000)
+      ret = true
+      usb_device.open do |usb|
+        # check for MS OS descriptors
+        mod = usb.get_string_simple(238)
+        
+        if mod.nil? or mod[0,4] != "MSFT"
+          logger.debug("Microsoft OS Descriptor invalid")
+          ret = false 
+          break
+        end
+        bVendorCode = mod[7]
+        result = "\0" * 0x20
+        expd = usb.usb_control_msg(USB::USB_ENDPOINT_IN|USB::USB_RECIP_DEVICE|USB::USB_TYPE_VENDOR, bVendorCode, 0, 4, result, timeout)
+        unless expd > 0x15 and result[0x12,3] == "MTP"
+          logger.debug("Microsoft Extended Descriptor invalid")
+          ret = false
+          break
+        end
+        
+        result = "\0" * 0x20
+        expd = usb.usb_control_msg(USB::USB_ENDPOINT_IN|USB::USB_RECIP_DEVICE|USB::USB_TYPE_VENDOR, bVendorCode, 0, 5, result, timeout)
+        unless expd > 0x15 and result[0x12,3] == "MTP"
+          logger.debug("Microsoft Extended Descriptor invalid")
+          ret = false
+          break
+        end
+      end
+      ret
+    end
+
+    def logger
+      Protocol.logger
+    end
+
+    attr_reader :device
+    def initialize(device, usb_device)
+      @device = device
+      @transaction_id = 0
+      @split_data_packets = false
+      @usb_handle = nil
+      @usb_device = usb_device
+      @timeout = 10000
+      logger.info("new device #{@usb_device.product}")
+    end
+
+    def split_data_packets?
+      @split_data_packets
+    end
+    
+    def configuration
+      @usb_device.configurations.first
+    end
+    
+    def interface
+      @usb_device.interfaces.first
+    end
+
+    def transaction_id
+      tid = @transaction_id
+      @transaction_id = (tid % 0xffffffff) + 1
+      tid
+    end
+    
+    def raw_send(raw_packet, &block)
+      raw_packet = raw_packet.clone
+      if (raw_packet.length % @end_points.out.wMaxPacketSize).zero?
+        send_empty_packet = true
+        logger.warn("packet match max packet size, need to send NULL packet")
+      end
+      written, total = 0, raw_packet.length
+      until raw_packet.empty?
+        if (wrt = @usb_handle.usb_bulk_write(@end_points.out.bEndpointAddress, 
+                                      raw_packet.slice!(0, @end_points.out.wMaxPacketSize), @timeout)) < 0
+          raise WriteError.new(self)
+        end
+        written += wrt
+        yield written, total if block_given?
+      end
+    end      
+    
+    def raw_send_io(io, size, &block)
+      packet_size = @end_points.out.wMaxPacketSize
+      written = 0
+      until (str = io.read(packet_size)).nil?
+        if (wrt = @usb_handle.usb_bulk_write(@end_points.out.bEndpointAddress, str, @timeout)) < 0
+          raise WriteError.new(self)
+        end
+        written += wrt
+        yield written, size if block_given?
+      end
+    end
+
+    def send(request)
+      unless request.is_a?(Data) or request.code.name == "GetDeviceInfo"
+        raise UnsupportedRequest.new(self, request) unless @device.support?(request.code)
+        request.transaction_id = transaction_id 
+      end
+      
+      raw_send(request.pack)
+
+      logger.debug(sprintf("=> %-8s: 0x%08x, 0x%04x - %s", (request.is_a?(Data) ? "DATA" : "REQUEST"), request.transaction_id, request.code, request.code.name))
+      request
+    end
+
+    def raw_read
+      read = packet_size = @end_points.in.wMaxPacketSize
+      raw_packet = ""
+      
+      # packet is received when we receive an emtpy packet
+      # or a packet whose size is smaller than the packet size
+      while read == packet_size
+        buffer = "\0" * packet_size
+        read = @usb_handle.usb_bulk_read(@end_points.in.bEndpointAddress, buffer, @timeout)
+        if read.zero?
+          logger.warn("packet match max packet size, need to send NULL packet")
+        end
+        raw_packet << buffer[0, read]
+      end
+      raw_packet
+    end
+
+    def raw_read_io(io, size, &block)
+      read = packet_size = @end_points.in.wMaxPacketSize
+
+      total = 0
+      # packet is received when we receive an emtpy packet
+      # or a packet whose size is smaller than the packet size
+      while read == packet_size
+        buffer = "\0" * packet_size
+        read = @usb_handle.usb_bulk_read(@end_points.in.bEndpointAddress, buffer, @timeout)
+        if read.zero?
+          logger.warn("packet match max packet size, need to send NULL packet")
+        end
+        io.write(buffer[0, read])
+        total += read
+        yield total, size if block_given?
+      end
+    end
+
+    def receive
+      raw_packet = raw_read
+      response = Container.parse(raw_packet)
+      logger.debug(sprintf("<= %-8s: 0x%08x, 0x%04x - %s", (response.is_a?(Data) ? "DATA" : "RESPONSE"), 
+                               response.transaction_id, response.code, response.code.name))
+      response
+    end
+    
+    # do not use normal procedure as we need to determine if we use
+    # splitted header / data
+    def info
+      request = Request.for("GetDeviceInfo")
+      request.transaction_id = 0
+      send(request)
+      data = receive
+
+      raise CommandError.new(self, request, data, "expected a data packet") unless data.is_a?(Data)
+      
+      if data.payload.empty?
+        logger.debug("device split packet headers from payload")
+        @split_data_packets = true 
+        data.payload = raw_read
+      end
+      response = receive
+      yield data if block_given?
+    end
+    
+    def open
+      logger.debug("low level open")
+      @usb_handle = @usb_device.usb_open
+      begin
+        @usb_handle.set_configuration(configuration)
+        @usb_handle.claim_interface(interface.settings.first)
+        @end_points = EndPoints.new(self)
+      rescue Exception => e
+        close
+      end
+      self
+    end
+    
+    def reset_end_points
+      @usb_handle.usb_clear_halt(@end_points.out.bEndpointAddress)
+      @usb_handle.usb_clear_halt(@end_points.in.bEndpointAddress)
+      @usb_handle.usb_clear_halt(@end_points.interrupt.bEndpointAddress)
+    end
+    
+    def close
+      logger.debug("low level close")
+      reset_end_points
+      @usb_handle.release_interface(interface.settings.first)
+      @usb_handle.usb_reset
+      @usb_handle.usb_close
+    end
+
+    def transaction
+      Transaction.new(self)
+    end
+    
+  end
+end

data/lib/mtp/storage.rb

@@ -0,0 +1,39 @@
+module MTP
+  class Storage
+    attr_reader(:id, :type, :file_system, :access_capability, :max_capability, :free_space_in_bytes, :free_space_in_objects,
+                :description, :volume_label)
+
+    TYPES = { 
+      0x0000 => "Undefined", 0x0001 => "Fixed ROM", 0x0002 => "Removable ROM",
+      0x0003 => "Fixed RAM", 0x0004 => "Removable RAM"
+    }
+    
+    FILE_SYSTEMS = {
+      0x0000 => "Undefined", 0x0001 => "Generic Flat", 0x0002 => "Generic Hierarchical", 0x0003 => "DCF"
+    }
+
+      
+    def self.load(ph, id)
+      storage = Storage.new
+      t = ph.transaction.get_storage_info(id)
+      t.expect("OK")
+      storage.instance_eval do
+        @id = id
+        @type, @file_system, @access_capability, @max_capability, @free_space_in_bytes,
+        @free_space_in_objects, @description, @volume_label =
+          t.data.payload.unpack("SSSQQIJJ")
+        @type = Datacode.new(@type, TYPES)
+        @file_system = Datacode.new(@file_system, FILE_SYSTEMS)
+      end
+      storage
+    end
+    
+    def type_description
+      TYPES[@type]
+    end
+    
+    def file_system_description
+      FILE_SYSTEMS[@file_system]
+    end
+  end
+end

data/lib/mtp/track.rb

@@ -0,0 +1,74 @@
+require 'mp3info'
+
+module MTP
+  class Track < Object
+  end
+  
+  class MP3Track < Track
+    register_format self, Datacode.new("MP3")
+    property_writer :artist, :track, :genre, :original_release_date, :name, :album_name
+    property_accessor :duration
+    
+    def initialize(localname = nil)
+      super()
+      self.format = "MP3"
+      self.localname = localname unless localname.nil?
+    end
+
+    def load(ph, id, payload)
+      super(ph, id, payload)
+    end
+
+    # read track data and info from a local file
+    def localname=(localname)
+      @localname = localname
+      @info = Mp3Info.new(localname)
+      @info.close
+      self.filename = File.basename(@localname)
+      self.compressed_size = File.size(@localname)
+    end
+    
+    def artist
+      new_object? ? @info.tag.artist : properties.artist
+    end
+
+    def name
+      new_object? ? @info.tag.title : properties.name
+    end
+    
+    def track
+      new_object? ? @info.tag.tracknum : properties.track
+    end
+    
+    def genre
+      new_object? ? @info.tag.genre_s : properties.genre
+    end
+    
+    def original_release_date
+      new_object? ? Time.local(@info.tag.year) : properties.original_release_date
+    end
+    
+    def album_name
+      new_object? ? @info.tag.album : properties.album_name
+    end
+
+    def inspect
+      "#<MTP::MP3Track:0x%08x @parent_id=0x%08x @artist=%s @track=%u @name=%s @genre=%s @album_name%s>" % 
+        [ @id, @parent_id, artist.inspect, track, name, genre.inspect, album_name.inspect]  
+    end
+
+    def set_properties_from_mp3info(info)
+      self.artist = info.tag.artist
+      self.name = info.tag.title
+      self.track = info.tag.tracknum
+      self.genre = info.tag.genre_s
+      self.original_release_date = Time.local(info.tag.year) unless info.tag.year.nil?
+      self.album_name = info.tag.album
+    end
+    
+    def after_sending
+      super
+      set_properties_from_mp3info(@info) unless @info.nil?
+    end
+  end
+end

data/patches/ruby-mp3info-0.5.diff

@@ -0,0 +1,80 @@
+diff -ur ruby-mp3info-0.5/lib/mp3info.rb /var/lib/gems/1.8/gems/ruby-mp3info-0.5/lib/mp3info.rb
+--- ruby-mp3info-0.5/lib/mp3info.rb	2005-12-05 23:30:22.000000000 +0100
++++ /var/lib/gems/1.8/gems/ruby-mp3info-0.5/lib/mp3info.rb	2007-02-14 13:48:48.000000000 +0100
+@@ -155,8 +155,6 @@
+   # Instantiate a new Mp3Info object with name +filename+
+   def initialize(filename)
+     $stderr.puts("#{self.class}::new() does not take block; use #{self.class}::open() instead") if block_given?
+-    raise(Mp3InfoError, "empty file") unless File.stat(filename).size? #FIXME
+-    @filename = filename
+     @hastag1 = false
+     
+     @tag1 = {}
+@@ -164,7 +162,15 @@
+ 
+     @tag2 = ID3v2.new
+ 
+-    @file = File.new(filename, "rb")
++    if filename.is_a?(String)
++      raise(Mp3InfoError, "empty file") unless File.stat(filename).size? #FIXME
++      @filename = filename
++      @file = File.new(filename, "rb")
++      @is_io = false
++    else
++      @is_io = true
++      @file = filename
++    end
+     @file.extend(Mp3FileMethods)
+     
+     begin
+@@ -245,7 +251,8 @@
+ 	@vbr = true
+       else
+ 	# for cbr, calculate duration with the given bitrate
+-	@streamsize = @file.stat.size - (@hastag1 ? TAGSIZE : 0) - (@tag2.valid? ? @tag2.io_position : 0)
++        size = (@file.respond_to?(:stat) ? @file.stat.size : @file.size)
++	@streamsize = size - (@hastag1 ? TAGSIZE : 0) - (@tag2.valid? ? @tag2.io_position : 0)
+ 	@length = ((@streamsize << 3)/1000.0)/@bitrate
+ 	if @tag2["TLEN"]
+ 	  # but if another duration is given and it isn't close (within 5%)
+@@ -313,7 +320,7 @@
+ 
+   # write to another filename at close()
+   def rename(new_filename)
+-    @filename = new_filename
++    @filename = new_filename unless @is_io
+   end
+ 
+   # Flush pending modifications to tags and close the file
+@@ -332,7 +339,7 @@
+ 
+     if @tag1 != @tag1_orig
+       puts "@tag1 has changed" if $DEBUG
+-      raise(Mp3InfoError, "file is not writable") unless File.writable?(@filename)
++      raise(Mp3InfoError, "file is not writable") if @is_io or !File.writable?(@filename)
+       @tag1_orig.update(@tag1)
+       #puts "@tag1_orig: #{@tag1_orig.inspect}"
+       File.open(@filename, 'rb+') do |file|
+@@ -405,7 +412,7 @@
+   
+   ### parses the id3 tags of the currently open @file
+   def parse_tags
+-    return if @file.stat.size < TAGSIZE  # file is too small
++    #return if @file.stat.size < TAGSIZE  # file is too small
+     @file.seek(0)
+     f3 = @file.read(3)
+     gettag1 if f3 == "TAG"  # v1 tag at beginning
+@@ -467,7 +474,12 @@
+     #   is a id3v2 tag.
+ 
+     #dummyproof = @file.stat.size - @file.pos => WAS TOO MUCH
+-    dummyproof = [ @file.stat.size - @file.pos, 2000000 ].min
++    if @file.respond_to?(:stat)
++      size = @file.stat.size
++    else
++      size = @file.size
++    end
++    dummyproof = [ size - @file.pos, 2000000 ].min
+     dummyproof.times do |i|
+       if @file.getc == 0xff
+         data = @file.read(3)