rubymtp 0.1

data/lib/mtp/datatypes.rb

@@ -0,0 +1,51 @@
+module MTP
+  DATA_TYPES = {
+    0x0000 => "Undefined",
+    0x0001 => "INT8",
+    0x0002 => "UINT8",
+    0x0003 => "INT16",
+    0x0004 => "UINT16",
+    0x0005 => "INT32",
+    0x0006 => "UINT32",
+    0x0007 => "INT64",
+    0x0008 => "UINT64",
+    0x0009 => "INT128",
+    0x000A => "UINT128",
+    0x4001 => "AINT8",
+    0x4002 => "AUINT8",
+    0x4003 => "AINT16",
+    0x4004 => "AUINT16",
+    0x4005 => "AINT32",
+    0x4006 => "AUINT32",
+    0x4007 => "AINT64",
+    0x4008 => "AUINT64",
+    0x4009 => "AINT128",
+    0x400A => "AUINT128",
+    0xFFFF => "String"
+  }
+
+  DATA_TYPE_PACK = {
+    0x0000 => "",
+    0x0001 => "c",
+    0x0002 => "C",
+    0x0003 => "s",
+    0x0004 => "S",
+    0x0005 => "v",
+    0x0006 => "V",
+    0x0007 => "q",
+    0x0008 => "Q",
+    0x0009 => "y",
+    0x000A => "Y",
+    0x4001 => "c+",
+    0x4002 => "C+",
+    0x4003 => "s+",
+    0x4004 => "S+",
+    0x4005 => "v+",
+    0x4006 => "V+",
+    0x4007 => "q+",
+    0x4008 => "Q+",
+    0x4009 => "y+",
+    0x400A => "Y+",
+    0xFFFF => "J"
+  }
+end

data/lib/mtp/device.rb

@@ -0,0 +1,270 @@
+module MTP
+  class Device
+    class << self
+      
+      # discover connected usb devices
+      def find
+        ary = Array.new
+        USB.devices.find_all do |usbdev|
+          ary << Device.new(usbdev) if Protocol.mtp?(usbdev)
+        end
+        ary
+      end
+    end
+
+    FUNCTIONAL_MODES = { 0x0000 => "Undefined", 0x0001 => "Sleep state",
+      0xC001 => "Non-responsive playback", 0xC002 => "Responsive playback" }
+
+    attr_reader :manufacturer, :model
+    
+    private
+    # create a new MTP device from the corresponding USB device
+    def initialize(usb_device)
+      raise WrongDeviceType.new(self) unless Protocol.mtp?(usb_device)
+      @ph = Protocol.new(self, usb_device)
+      info
+    end
+
+    # parse the device info data set
+    def info
+      begin
+        @ph.open
+        @ph.info do |data|
+          @standard_version, @mtp_vendor_extension_id, @mtp_version, @mtp_extensions,
+          @functional_mode, @operations_supported, @events_supported, @device_properties_supported,
+          @capture_formats, @playback_formats, @manufacturer, @model, @device_version, @serial_number =
+            data.payload.unpack("SVSJSK+S+S+K+K+JJJJ")
+        end
+      ensure
+        @ph.close
+      end
+      #dump
+      self
+    end
+
+    # dump device info
+    def dump
+      puts "Device info:"
+      puts "   Manufacturer: #{@manufacturer}"
+      puts "   Model: #{@model}"
+      puts "   Device version: #{@device_version}"
+      puts "   Serial number: #{@serial_number}"
+      puts "   Standard version: #{@standard_version}"
+      puts "   Vendor extension description: #{@mtp_extensions}"
+      puts sprintf("   Vendor extension ID: 0x%08x", @mtp_vendor_extension_id)
+      puts "   Functional mode: " + FUNCTIONAL_MODES[@functional_mode]
+      puts "Supported operations"
+      @operations_supported.each { |o| puts sprintf("   0x%04x: %s", o, o.name) }
+      puts "Supported capture formats"
+      @capture_formats.each { |o| puts sprintf("   0x%04x: %s", o, o.name) }
+      puts "Supported playback formats"
+      @playback_formats.each { |o| puts sprintf("   0x%04x: %s", o, o.name) }
+    end
+    
+    public
+    def inspect #:nodoc:
+      "#<MTP::Device manufacturer=%s model=%s>" % [ @manufacturer.inspect, @model.inspect ]
+    end
+    
+    # check if the device support a particular request
+    def support?(request)
+      code = Datacode.new(request)
+      return @operations_supported.include?(code)
+    end
+      
+    # open the device
+    #
+    # If a block is given, the library will ensure that the device is
+    # correctly closed outside of the block, even if an exception is
+    # raised in it.
+    def open
+      MTP.logger.info("opening session")
+      @ph.open
+      begin
+        t = @ph.transaction.open_session(1)
+        unless t.response.one_of?("OK", "SessionAlreadyOpened")
+          reset
+          t = @ph.transaction.open_session(1)
+        end
+      rescue Exception => e
+        @ph.close
+        raise e
+      end
+
+      if block_given?
+        begin
+          yield self
+        ensure
+          begin
+            close
+          rescue Exception => e
+            MTP.logger.error(e)
+          end
+        end
+      else
+        self
+      end
+    end
+    
+    # close the device
+    def close
+      MTP.logger.info("closing session")
+      begin
+        @ph.transaction.close_session.expect("OK")
+      ensure
+        @ph.close
+      end
+    end
+
+    # reset the device (this will close all sessions
+    def reset
+      MTP.logger.info("reseting device")
+      @ph.transaction.reset_device.expect("OK", "SessionNotOpen")
+    end
+    
+    # clear cached data
+    def clear
+      @storages = @objects = @objects_by_filename = @tracks = @playlists = nil
+    end
+    
+    # return the available storages on the device
+    def storages
+      return @storages unless @storages.nil?
+      
+      MTP.logger.info("fetching storages")
+      t = @ph.transaction.get_storage_ids
+      t.expect("OK")
+      num, *ids = t.data.payload.unpack("I*")
+      @storages = ids.map { |id| Storage.load(@ph, id) }
+    end
+    
+    # return the MTP objects stored on the device
+    def objects
+      return @objects.values unless @objects.nil?
+
+      MTP.logger.info("fetching objects")
+      @objects = {}
+      @objects_by_filename = {}
+      
+      # fetch on each storage
+      storages.each do |storage|
+        t = @ph.transaction.get_object_handles(storage.id, 0, 0)
+        t.expect("OK")
+        
+        num, *objects = t.data.payload.unpack("I*")
+        
+        MTP.logger.info("retrieving #{num} objects")
+        objects.each do |id|
+          o = @objects[id] = Object.load(@ph, id, storage)
+          @objects_by_filename[o.filename] = o
+        end
+      end
+      @objects.values
+    end
+    
+    # call-seq:
+    #   device[id]             => object
+    #   device[filename]       => object
+    #
+    # retrieve an object from the device by its id or filename.
+    def [](id)
+      objects if @objects.nil?
+      if id.is_a?(String)
+        @objects_by_filename[id]
+      else
+        @objects[id]
+      end
+    end
+
+    # call-seq:
+    #   device.send(object)                                     => object
+    #   device.send(object, io)                                 => object
+    #   device.send(object, io) { |written, total| ... }        => object
+    #
+    # send object to the device
+    #
+    # If the io argument is given, the binary data to be send to the
+    # device will be read from it. If a block is given, each time a
+    # packet is send, it will be called with the number of bytes
+    # written and the total number of bytes to write.
+    def send(object, io = nil, &block)
+      raise InvalidObject.new(object) unless object.valid?
+      
+      MTP.logger.info("sending object #{object}")
+      t = @ph.transaction
+      t.data = Data.new(object.pack)
+      t.send_object_info(0, 0)
+      t.expect("OK")
+      storage_id, parent_id, object_id  = *t.response.parameters
+
+      storage = storages.detect { |s| s.id == storage_id }
+      object.instance_eval do
+        @storage, @parent_id, @id = storage, parent_id, object_id
+      end
+
+      object.before_sending(@ph)
+      
+      t = @ph.transaction
+      t.data = object.data
+      if io.nil?
+        t.send_object(&block)
+      else
+        t.send_object_with_io(io, &block)
+      end
+      t.expect("OK")
+      object.after_sending
+      @objects_by_filename[object.filename] = @objects[object.id] = object
+      if object.is_a?(Track)
+        tracks << object
+      elsif object.is_a?(Playlist)
+        playlists << object
+      end
+    end
+
+    # call-seq:
+    #   device.get(object)                                     => object
+    #   device.get(object, io)                                 => object
+    #   device.get(object, io) { |read, total| ... }           => object
+    #
+    # retrieve object to the device
+    #
+    # If the io argument is given, the binary data to be read from the
+    # device will be written to it. If a block is given, each time a
+    # packet is received, it will be called with the number of bytes
+    # read and the total number of bytes to read.
+    def get(object, io = nil, &block)
+      MTP.logger.info("receiving object #{object}")
+      t = @ph.transaction
+      if io.nil?
+        t.get_object(object.id, &block)
+      else
+        t.get_object_with_io(io, object.id, &block)
+      end
+      t.expect("OK")
+      return t.data.payload
+    end
+
+    # the list of tracks on the device
+    def tracks
+      @tracks ||= objects.select { |o| o.is_a?(Track) }
+    end
+
+    # the list of playlists on the device
+    def playlists
+      @playlists ||= objects.select { |o| o.is_a?(Playlist) }
+    end
+
+    # delete object from the device
+    def delete(object)
+      MTP.logger.info("deleting object #{object.id}")
+      @ph.transaction.delete_object(object.id, 0).expect("OK")
+      @objects_by_filename[object.filename] = @objects[object.id] = nil
+      if object.is_a?(Track)
+        tracks.delete(object)
+      elsif object.is_a?(Playlist)
+        playlists.delete(object)
+      end
+      object
+    end
+  end
+end

data/lib/mtp/fuse.rb

@@ -0,0 +1,368 @@
+require 'logger'
+require 'fusefs'
+require 'mtp'
+require 'stringio'
+$DEBUG=1
+
+module MTP
+  class FileSystem < FuseFS::FuseDir
+    @@logger = Logger.new(STDERR)
+    @@logger.level = Logger::INFO
+    
+    def self.logger
+      @@logger
+    end
+    
+    def logger
+      @@logger
+    end
+
+    @@roots = {}
+    def self.register_root(name, klass)
+      @@roots[name] = klass
+    end
+    
+    def initialize(device)
+      @device = device
+      @device.objects
+    end
+    
+    def dispatch(method, *args, &block)
+      ps = scan_path(args.shift)
+      
+      if ps.empty?
+        yield ps, *args
+      else
+        type = ps.shift
+        klass = @@roots[type]
+        handler = (klass.nil? ? nil : klass.new(@device))
+        if !handler.nil? and handler.respond_to?(method)
+          handler.send(method, ps, *args)
+        else
+          yield ps.unshift(type), *args
+        end
+      end
+    end
+        
+    def directory?(path)
+      logger.debug("#{path}: directory?")
+      dispatch(:directory?, path) do |path|
+        @@roots.keys.include?(path)
+      end
+    end
+    
+    def file?(path)
+      logger.debug("#{path}: file?")
+      dispatch(:file?, path) do |path|
+        false
+      end
+    end
+    
+    def executable?(path)
+      logger.debug("#{path}: executable?")
+      false
+    end
+    
+    def size(path)
+      logger.debug("#{path}: size")
+      dispatch(:size, path) do |path|
+        0
+      end
+    end
+
+    def contents(path)
+      logger.debug("#{path}: contents")
+      dispatch(:contents, path) do |path|
+        @@roots.keys
+      end
+    end
+    
+    def read_file(path)
+      dispatch(:read_file, path) do |path|
+        track = @device[path.last]
+        @device.get(track)
+      end
+    end
+
+    def can_write?(path)
+      dispatch(:can_write?, path) do |path|
+        @device[path.last].nil?
+      end
+    end
+    
+    def write_to(path, str)
+      dispatch(:write_to, path, str) do |path, str|
+        track = MTP::MP3Track.new
+        track.filename = path.last
+        track.compressed_size = str.length
+        track.data = MTP::Data.new(str)
+        @device.send(track)
+        StringIO.open(str, 'r') do |io|
+          info = Mp3Info.new(io)
+          track.set_properties_from_mp3info(info)
+        end
+      end
+    end
+    
+    def can_delete?(path)
+      dispatch(:can_delete?, path) do |path|
+        true
+      end
+    end
+      
+    def delete(path)
+      dispatch(:delete, path) do |path|
+        @device.delete(@device[path.last])
+      end
+    end
+    
+    def can_mkdir?(path)
+      dispatch(:can_mkdir?, path) do |path|
+        false
+      end
+    end
+    
+    def mkdir(path)
+      dispatch(:mkdir, path) do |path|
+        false
+      end
+    end
+    
+    def can_rmdir?(path)
+      dispatch(:can_rmdir?, path) do |path|
+        false
+      end
+    end
+    
+    def rmdir(path)
+      dispatch(:rmdir, path) do |path|
+      end
+    end
+    
+    class Albums
+      FileSystem.register_root("albums", self)
+      
+      def initialize(device, artist = nil)
+        @device = device
+        @artist = artist
+      end
+
+      def directory?(path)
+        path.size <= 1
+      end
+
+      def file?(path)
+        path.size == 2
+      end
+
+      def size(path)
+        @device[path.last].compressed_size
+      end
+    
+      def can_rmdir?(path)
+        !path.empty?
+      end
+      
+      def rmdir(path)
+        @device.objects.each do |object|
+          @device.delete(object) if object.is_a?(Track) and (@artist.nil? or @artist == object.artist) and object.album_name == path.first
+        end
+      end
+      
+      def contents(path)
+        if path.empty?
+          if @artist.nil?
+            @device.tracks.map { |t| t.album_name }.uniq
+          else
+            albums = []
+            @device.objects.each do |o|
+              if o.is_a?(Track) and o.artist == @artist and !albums.include?(o.album_name)
+                albums << o.album_name
+              end
+            end
+            albums
+          end
+        elsif path.size == 1
+          @device.objects.select { |o| o.is_a?(Track) and o.album_name == path[0] }.map { |t| t.filename }
+        else
+          []
+        end
+      end
+    end
+    
+    class Artists
+      FileSystem.register_root("artists", self)
+      
+      def initialize(device, genre = nil)
+        @device = device
+        @genre = genre
+      end
+
+      def dispatch(method, path, &block)
+        if path.size > 1 or (path.size == 1 and method == :contents)
+          Albums.new(@device, path.shift).send(method, path)
+        else
+          yield path
+        end
+      end	
+        
+      def directory?(path)
+        path.size <= 2
+      end
+
+      def file?(path)
+        path.size == 3
+      end
+    
+      def size(path)
+        @device[path.last].compressed_size
+      end
+    
+      def can_rmdir?(path)
+        dispatch(:can_rmdir?, path) do |path|
+          !path.empty?
+        end          
+      end
+
+      def rmdir(path)
+        dispatch(:rmdir, path) do |path|
+          @device.objects.each do |object|
+            @device.delete(object) if object.is_a?(Track) and path.first == object.artist
+          end
+        end
+      end
+
+      def contents(path)
+        dispatch(:contents, path) do |path|
+          if @genre.nil?
+            @device.tracks.map { |t| t.artist }.uniq      
+          else
+            artists = []
+            @device.objects.each do |o|
+              if o.is_a?(Track) and o.genre == @genre and !artists.include?(o.artist)
+                artists << o.artist
+              end
+            end
+            artists
+          end
+        end
+      end
+    end
+    
+    class Genres
+      FileSystem.register_root("genres", self)
+      
+      def initialize(device)
+        @device = device
+      end
+
+      def dispatch(method, path, &block)
+        if path.size > 1 or (path.size == 1 and method == :contents)
+          Artists.new(@device, path.shift).send(method, path)
+        else
+          yield path
+        end
+      end	
+        
+      def directory?(path)
+        path.size <= 3
+      end
+
+      def file?(path)
+        path.size == 4
+      end
+    
+      def size(path)
+        @device[path.last].compressed_size
+      end
+    
+      def can_rmdir?(path)
+        dispatch(:can_rmdir?, path) do |path|
+          !path.empty?
+        end          
+      end
+
+      def rmdir(path)
+        dispatch(:rmdir, path) do |path|
+          @device.objects.each do |object|
+            @device.delete(object) if object.is_a?(Track) and path.first == object.genre
+          end
+        end
+      end
+      
+      def contents(path)
+        dispatch(:contents, path) do |path|
+          @device.tracks.map { |t| t.genre }.uniq
+        end
+      end
+    end
+    
+    class Playlists
+      FileSystem.register_root("playlists", Playlists)
+      
+      def initialize(device)
+        @device = device
+      end
+
+      def playlist(name)
+        @device.playlists.detect { |p| p.name == name }
+      end
+      
+      def directory?(path)
+        path.size.zero? or (path.size == 1 and !playlist(path.first).nil?)
+      end
+
+      def file?(path)
+        path.size == 2
+      end
+    
+      def size(path)
+        @device[path.last].compressed_size
+      end
+
+      def can_write?(path)
+        path.size == 2
+      end
+    
+      def write_to(path, str)
+        playlist(path.first) << @device[path.last] unless @device[path.last].nil? or playlist.include?(@device[path.last])
+      end
+
+      def can_delete?(path)
+        !path.empty?
+      end
+      
+      def delete(path)
+        playlist(path.first).delete(@device[path.last])
+      end
+
+      def can_mkdir?(path)
+        path.size == 1 and playlist(path.first).nil?
+      end
+      
+      def mkdir(path)
+        playlist = MTP::Playlist.new
+        @device.send(playlist)
+        playlist.name = path.first
+        puts "haha #{playlist.name}"
+      end
+
+      def can_rmdir?(path)
+        !path.empty?
+      end
+
+      def rmdir(path)
+        @device.delete(playlist(path.first))
+      end
+      
+      def contents(path)
+        if path.empty?
+          @device.playlists.map { |p| p.name }
+        else
+          playlist(path.first).to_a.map { |o| o.filename }
+        end
+      end
+    end
+      
+  end
+end