ruby_android 0.0.2 → 0.7.2

data/lib/android/dex.rb

@@ -0,0 +1,92 @@
+require_relative 'dex/dex_object'
+require_relative 'dex/info'
+require_relative 'dex/access_flag'
+require_relative 'dex/utils'
+
+module Android
+  # parsed dex object
+  # @see http://source.android.com/devices/tech/dalvik/dex-format.html
+  # @attr_reader strings [Array<String>] strings in dex file.
+  class Dex
+    # @return [Dex::Header] dex header information
+    attr_reader :header
+    alias :h :header
+
+    # @return [String] dex binary data
+    attr_reader :data
+    # @return [Array<Dex::ClassInfo>] array of class information
+    attr_reader :classes
+
+    attr_reader :field_ids, :method_ids, :proto_ids
+    # @param [String] data dex binary data
+    def initialize(data)
+      @data = data
+      @data.force_encoding(Encoding::ASCII_8BIT)
+      @classes = []
+      parse()
+    end
+
+    def strings
+      @strings ||= @string_data_items.map{|item| item.to_s }
+    end
+
+    def inspect
+      "<Android::Dex @classes => #{@classes.size}, datasize => #{@data.size}>"
+    end
+
+
+    # @private
+    TYPE_DESCRIPTOR = { 
+      'V' => 'void',
+      'Z' => 'boolean',
+      'B' => 'byte',
+      'S' => 'short',
+      'C' => 'short',
+      'I' => 'int',
+      'J' => 'long',
+      'F' => 'float',
+      'D' => 'double'
+    }
+
+
+    def type_resolve(typeid)
+      type = strings[@type_ids[typeid]]
+      if type.start_with? '['
+        type = type[1..type.size]
+        return TYPE_DESCRIPTOR.fetch(type, type) + "[]" # TODO: recursive
+      else
+        return TYPE_DESCRIPTOR.fetch(type, type)
+      end
+    end
+
+
+    private
+    def parse
+      @header = DexObject::Header.new(@data)
+      @map_list = DexObject::MapList.new(@data, h[:map_off])
+
+      # parse strings
+      @string_ids = DexObject::StringIdItem.new(@data, h[:string_ids_off], h[:string_ids_size])
+      @string_data_items = []
+      @string_ids[:string_data_off].each { |off| @string_data_items << DexObject::StringDataItem.new(@data, off) }
+
+      @type_ids = DexObject::TypeIdItem.new(@data, h[:type_ids_off], h[:type_ids_size])
+      @proto_ids = ids_list_array(DexObject::ProtoIdItem, h[:proto_ids_off], h[:proto_ids_size])
+      @field_ids = ids_list_array(DexObject::FieldIdItem, h[:field_ids_off], h[:field_ids_size])
+      @method_ids = ids_list_array(DexObject::MethodIdItem, h[:method_ids_off], h[:method_ids_size])
+      @class_defs = ids_list_array(DexObject::ClassDefItem, h[:class_defs_off], h[:class_defs_size])
+
+      @classes = []
+      @class_defs.each do |cls_def|
+        @classes << ClassInfo.new(cls_def, self)
+      end
+    end
+
+    def ids_list_array(cls, offset, size)
+      ret_array = []
+      size.times { |i| ret_array << cls.new(@data, offset + cls.size * i) }
+      ret_array
+    end
+  end
+end
+

data/lib/android/layout.rb

@@ -0,0 +1,44 @@
+# encoding: utf-8
+require 'ruby_android'
+require 'rexml/document'
+
+module Android
+  class Layout
+    # @return [Hash] { path => Layout }
+    def self.collect_layouts(apk)
+      targets = apk.find {|name, data| name =~ /^res\/layout\/*/ }
+      ret = {}
+      targets.each do |path| 
+        data = apk.file(path)
+        data.force_encoding(Encoding::ASCII_8BIT)
+        ret[path] = nil
+        begin
+          ret[path] = Layout.new(data, path) if AXMLParser.axml?(data)
+        rescue => e
+          $stderr.puts e
+        end
+      end
+      ret
+    end
+
+    # @return [String] layout file path
+    attr_reader :path
+    # @return [REXML::Document] xml document object
+    attr_reader :doc
+
+    def initialize(data, path=nil)
+      @data = data
+      @path = path
+      @doc = AXMLParser.new(data).parse
+    end
+
+    # @return [String] xml string
+    def to_xml(indent=4)
+      xml = ''
+      formatter = REXML::Formatters::Pretty.new(indent)
+      formatter.write(@doc.root, xml)
+      xml
+    end
+  end
+end
+

data/lib/android/manifest.rb

@@ -0,0 +1,249 @@
+require 'rexml/document'
+
+module Android
+  # parsed AndroidManifest.xml class
+  # @see http://developer.android.com/guide/topics/manifest/manifest-intro.html
+  class Manifest
+    APPLICATION_TAG = '/manifest/application'
+
+    # <activity>, <service>, <receiver> or <provider> element in <application> element of the manifest file.
+    class Component
+      # component types
+      TYPES = ['service', 'activity', 'receiver', 'provider']
+
+      # the element is valid Component element or not
+      # @param [REXML::Element] elem xml element
+      # @return [Boolean]
+      def self.valid?(elem)
+        TYPES.include?(elem.name.downcase)
+      rescue => e
+        false
+      end
+
+      # @return [String] type string in TYPES
+      attr_reader :type
+      # @return [String] component name
+      attr_reader :name
+      # @return [Array<Manifest::IntentFilter>]
+      attr_reader :intent_filters
+      # @return [Array<Manifest::Meta>]
+      attr_reader :metas
+      # @return [REXML::Element]
+      attr_reader :elem
+
+
+      # @param [REXML::Element] elem target element
+      # @raise [ArgumentError] when elem is invalid.
+      def initialize(elem)
+        raise ArgumentError unless Component.valid?(elem)
+        @elem = elem
+        @type = elem.name
+        @name = elem.attributes['name']
+        @intent_filters = []
+        unless elem.elements['intent-filter'].nil?
+          elem.elements['intent-filter'].each do |e|
+            next unless e.instance_of? REXML::Element
+            @intent_filters << IntentFilter.parse(e)
+          end
+        end
+        @metas = []
+        elem.each_element('meta-data') do |e|
+          @metas << Meta.new(e)
+        end
+      end
+    end
+
+    # intent-filter element in components
+    module IntentFilter
+      # parse inside of intent-filter element
+      # @param [REXML::Element] elem target element
+      # @return [IntentFilter::Action, IntentFilter::Category, IntentFilter::Data]
+      #    intent-filter element
+      def self.parse(elem)
+        case elem.name
+        when 'action'
+          Action.new(elem)
+        when 'category'
+          Category.new(elem)
+        when 'data'
+          Data.new(elem)
+        else
+          nil
+        end
+      end
+
+      # intent-filter action class
+      class Action
+      # @return [String] action name of intent-filter
+        attr_reader :name
+      # @return [String] action type of intent-filter
+        attr_reader :type
+
+        def initialize(elem)
+          @type = 'action'
+          @name = elem.attributes['name']
+        end
+      end
+
+      # intent-filter category class
+      class Category
+      # @return [String] category name of intent-filter
+        attr_reader :name
+      # @return [String] category type of intent-filter
+        attr_reader :type
+
+        def initialize(elem)
+          @type = 'category'
+          @name = elem.attributes['name']
+        end
+      end
+
+      # intent-filter data class
+      class Data
+        # @return [String]
+        attr_reader :type
+        # @return [String]
+        attr_reader :host
+        # @return [String]
+        attr_reader :mime_type
+        # @return [String]
+        attr_reader :path
+        # @return [String]
+        attr_reader :path_pattern
+        # @return [String]
+        attr_reader :path_prefix
+        # @return [String]
+        attr_reader :port
+        # @return [String]
+        attr_reader :scheme
+
+        def initialize(elem)
+          @type = 'data'
+          @host = elem.attributes['host']
+          @mime_type = elem.attributes['mimeType']
+          @path = elem.attributes['path']
+          @path_pattern = elem.attributes['pathPattern']
+          @path_prefix = elem.attributes['pathPrefix']
+          @port = elem.attributes['port']
+          @scheme = elem.attributes['scheme']
+        end
+      end
+    end
+
+    # meta information class
+    class Meta
+      # @return [String]
+      attr_reader :name
+      # @return [String]
+      attr_reader :resource
+      # @return [String]
+      attr_reader :value
+      def initialize(elem)
+        @name = elem.attributes['name']
+        @resource = elem.attributes['resource']
+        @value = elem.attributes['value']
+      end
+    end
+
+    #################################
+    # Manifest class definitions
+    #################################
+    #
+    # @return [REXML::Document] manifest xml
+    attr_reader :doc
+
+    # @param [String] data binary data of AndroidManifest.xml
+    def initialize(data, rsc=nil)
+      parser = AXMLParser.new(data)
+      @doc = parser.parse
+      @rsc = rsc
+    end
+
+    # used permission array
+    # @return [Array<String>] permission names
+    # @note return empty array when the manifest includes no use-parmission element
+    def use_permissions
+      perms = []
+      @doc.each_element('/manifest/uses-permission') do |elem|
+        perms << elem.attributes['name']
+      end
+      perms.uniq
+    end
+
+    # @return [Array<Android::Manifest::Component>] all components in apk
+    # @note return empty array when the manifest include no components
+    def components
+      components = []
+      unless @doc.elements['/manifest/application'].nil?
+        @doc.elements['/manifest/application'].each do |elem|
+          components << Component.new(elem) if Component.valid?(elem)
+        end
+      end
+      components
+    end
+
+    # application package name
+    # @return [String]
+    def package_name
+      @doc.root.attributes['package']
+    end
+
+    # application version code
+    # @return [Integer]
+    def version_code
+      @doc.root.attributes['versionCode'].to_i
+    end
+
+    # application version name
+    # @return [String]
+    def version_name(lang=nil)
+      vername = @doc.root.attributes['versionName']
+      unless @rsc.nil?
+        if /^@(\w+\/\w+)|(0x[0-9a-fA-F]{8})$/ =~ vername
+          opts = {}
+          opts[:lang] = lang unless lang.nil?
+          vername = @rsc.find(vername, opts)
+        end
+      end
+      vername
+    end
+
+    # @return [Integer] minSdkVersion in uses element
+    def min_sdk_ver
+      @doc.elements['/manifest/uses-sdk'].attributes['minSdkVersion'].to_i
+    end
+
+    # application label
+    # @param [String] lang language code like 'ja', 'cn', ...
+    # @return [String] application label string(if resouce is provided), or label resource id
+    # @return [nil] when label is not found
+    # @since 0.5.1
+    def label(lang=nil)
+      label = @doc.elements['/manifest/application'].attributes['label']
+      if label.nil?
+        # application element has no label attributes.
+        # so looking for activites that has label attribute.
+        activities = @doc.elements['/manifest/application'].find{|e| e.name == 'activity' && !e.attributes['label'].nil? }
+        label = activities.nil? ? nil : activities.first.attributes['label']
+      end
+      unless @rsc.nil?
+        if /^@(\w+\/\w+)|(0x[0-9a-fA-F]{8})$/ =~ label
+          opts = {}
+          opts[:lang] = lang unless lang.nil?
+          label = @rsc.find(label, opts)
+        end
+      end
+      label
+    end
+
+    # return xml as string format
+    # @param [Integer] indent size(bytes)
+    # @return [String] raw xml string
+    def to_xml(indent=4)
+      xml =''
+      formatter = REXML::Formatters::Pretty.new(indent)
+      formatter.write(@doc.root, xml)
+      xml
+    end
+  end
+end