android_parser 2.4.1

data/lib/android/dex/info.rb

@@ -0,0 +1,151 @@
+require_relative 'dex_object'
+
+module Android
+  class Dex
+    # class information in dex
+    # @!attribute [r] name
+    #  @return [String] class name
+    # @!attribute [r] super_class
+    #  @return [String] super class name
+    class ClassInfo
+      # no index flag
+      NO_INDEX = 0xffffffff
+
+      # @return [ClassAccessFlag]
+      attr_reader :access_flags
+      # @return [Array<FieldInfo>] static fields
+      attr_reader :static_fields
+      # @return [Array<FieldInfo>] instance fields
+      attr_reader :instance_fields
+      # @return [Array<MethodInfo>] direct methods
+      attr_reader :direct_methods
+      # @return [Array<MethodInfo>] virtual methods
+      attr_reader :virtual_methods
+
+      # @return [DexObject::ClassDataItem]
+      attr_reader :class_data
+      # @return [DexObject::ClassDefItem]
+      attr_reader :class_def
+
+      def name
+        @dex.type_resolve(@class_def[:class_idx])
+      end
+      def super_class
+        if @class_def[:superclass_idx] != NO_INDEX
+          @super_class = @dex.type_resolve(@class_def[:superclass_idx]) 
+        else
+          nil
+        end
+      end
+      # @param [Dex::ClassDefItem] class_def
+      # @param [Dex] dex dex class instance
+      def initialize(class_def, dex)
+        @class_def = class_def
+        @dex = dex
+        @access_flags = ClassAccessFlag.new(@class_def[:access_flags])
+        @class_data = @class_def.class_data_item
+        @static_fields = @instance_fields = @direct_methods = @virtual_methods = []
+        unless @class_data.nil?
+          @static_fields = cls2info(@class_data[:static_fields], FieldInfo, :field_idx_diff)
+          @instance_fields = cls2info(@class_data[:instance_fields], FieldInfo, :field_idx_diff)
+          @direct_methods = cls2info(@class_data[:direct_methods], MethodInfo, :method_idx_diff)
+          @virtual_methods = cls2info(@class_data[:virtual_methods], MethodInfo, :method_idx_diff)
+        end
+      end
+
+      # @return [String] class difinition
+      def definition
+        ret = "#{access_flags} class #{name}"
+        super_class.nil? ? ret : ret + " extends #{super_class}"
+      end
+
+      private
+      def cls2info(arr, cls, idx_key)
+        idx = 0
+        ret = []
+        arr.each do |item|
+          idx += item[idx_key]
+          ret << cls.new(item, idx, @dex)
+        end
+        ret
+      end
+    end
+
+    # field info object
+    # @!attribute [r] name
+    #  @return [String] field name
+    # @!attribute [r] type
+    #  @return [String] field type
+    class FieldInfo
+      # @return [ClassAccessFlag]
+      attr_reader :access_flags
+
+      def name
+        @dex.strings[@dex.field_ids[@field_id][:name_idx]]
+      end
+      def type
+        @dex.type_resolve(@dex.field_ids[@field_id][:type_idx])
+      end
+      def initialize(encoded_field, field_id, dex)
+        @dex = dex
+        @encoded_field = encoded_field
+        @field_id = field_id
+        @access_flags = ClassAccessFlag.new(encoded_field[:access_flags])
+      end
+
+      # @return [String] field definition
+      def definition
+        "#{@access_flags.to_s} #{type} #{name}"
+      end
+    end
+
+    # method info object
+    # @!attribute [r] name
+    #  @return [String] method name
+    # @!attribute [r] ret_type
+    #  @return [String] return type of the method
+    # @!attribute [r] parameters
+    #  @return [Array<String>] method parameters
+    class MethodInfo
+      # @return [MethodAccessFlag]
+      attr_reader :access_flags
+
+      def initialize(encoded_method, method_id, dex)
+        @encoded_method = encoded_method
+        @method_id = method_id
+        @dex = dex
+        @access_flags = MethodAccessFlag.new(encoded_method[:access_flags])
+      end
+      def name
+        @dex.strings[@dex.method_ids[@method_id][:name_idx]]
+      end
+      def ret_type
+        @dex.type_resolve(proto[:return_type_idx])
+      end
+      def parameters
+        unless proto[:parameters_off] == 0
+          list = DexObject::TypeList.new(@dex.data, proto[:parameters_off])
+          list[:list].map { |item| @dex.type_resolve(item) }
+        else
+          []
+        end
+      end
+
+      # @return [String] method definition string
+      def definition
+        "#{access_flags.to_s} #{ret_type} #{name}(#{parameters.join(', ')});"
+      end
+
+      # @return [DexObject::CodeItem]
+      def code_item
+        @encoded_method.code_item
+      end
+
+      private
+      def proto
+        @dex.proto_ids[@dex.method_ids[@method_id][:proto_idx]]
+      end
+    end
+
+  end
+end

data/lib/android/dex/utils.rb

@@ -0,0 +1,45 @@
+module Android
+  class Dex
+    class << self
+      # parse uleb128(unsigned integer) data
+      # @param [String] data target byte data
+      # @param [Integer] offset 
+      # @return [Integer, Integer] parsed value and parsed byte length
+      # @see http://en.wikipedia.org/wiki/LEB128
+      def uleb128(data, offset=0)
+        result = 0
+        shift = 0
+        d = data[offset...data.size]
+        (0..4).each do |i|
+          byte = d.getbyte(i)
+          result |= ((byte & 0x7f) << shift)
+          return result, i+1 if ((byte & 0x80) == 0)
+          shift += 7
+        end
+      end
+      # parse uleb128 + 1 data
+      # @param [String] data target byte data
+      # @param [Integer] offset 
+      # @return [Integer, Integer] parsed value and parsed byte length
+      def uleb128p1(data, offset=0)
+        ret, len = self.uleb128(data, offset)
+        return (ret - 1), len
+      end
+      # parse sleb128(signed integer) data
+      # @param [String] data target byte data
+      # @param [Integer] offset 
+      # @return [Integer, Integer] parsed value and parsed byte length
+      def sleb128(data, offset=0)
+        result  = 0
+        shift = 0
+        d = data[offset...data.size]
+        (0..4).each do |i|
+          byte  = d.getbyte(i)
+          result  |=((byte & 0x7F) << shift)
+          return (0 == (byte & 0x40) ? result : result - (1 << (shift+7))), i+1 if ((byte & 0x80) == 0)
+          shift += 7
+        end
+      end
+    end
+  end
+end

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_apk'
+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,350 @@
+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 = ['activity', 'activity-alias', 'service', 'receiver', 'provider', 'application']
+
+      # 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 [String] icon id - use apk.icon_by_id(icon_id) to retrieve it's corresponding data.
+      attr_reader :icon_id
+      # @return [Array<Manifest::IntentFilters<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']
+        @icon_id = elem.attributes['icon']
+
+        @intent_filters = []
+        unless elem.elements['intent-filter'].nil?
+          elem.each_element('intent-filter') do |filters|
+            intent_filters = []
+            filters.elements.each do |filter|
+              next unless IntentFilter.valid?(filter)
+
+              intent_filters << IntentFilter.parse(filter)
+            end
+            @intent_filters << intent_filters
+          end
+        end
+
+        @metas = []
+        elem.each_element('meta-data') do |e|
+          @metas << Meta.new(e)
+        end
+      end
+    end
+
+    class Activity < Component
+      # the element is valid Activity element or not
+      # @param [REXML::Element] elem xml element
+      # @return [Boolean]
+      def self.valid?(elem)
+        ['activity', 'activity-alias'].include?(elem.name.downcase)
+      rescue => e
+        false
+      end
+
+      def launcher_activity?
+        intent_filters.flatten.any? do |filter|
+          filter.type == 'category' && filter.name == 'android.intent.category.LAUNCHER'
+        end
+      end
+
+      # @return whether this instance is the default main launcher activity.
+      def default_launcher_activity?
+        intent_filters.any? do |intent_filter|
+          intent_filter.any? { |f| f.type == 'category' && f.name == 'android.intent.category.LAUNCHER' } &&
+            intent_filter.any? { |f| f.type == 'category' && f.name == 'android.intent.category.DEFAULT' }
+        end
+      end
+    end
+
+    class ActivityAlias < Activity
+      # @return [String] target activity name
+      attr_reader :target_activity
+
+      # @param [REXML::Element] elem target element
+      # @raise [ArgumentError] when elem is invalid.
+      def initialize(elem)
+        super
+        @target_activity = elem.attributes['targetActivity']
+      end
+    end
+
+    class Service < Component
+    end
+
+    class Receiver < Component
+    end
+
+    class Provider < Component
+    end
+
+    class Application < Component
+      def self.valid?(elem)
+        elem&.name == 'application'
+      end
+    end
+
+    # intent-filter element in components
+    module IntentFilter
+      # filter types
+      TYPES = ['action', 'category', 'data']
+
+      # the element is valid IntentFilter element or not
+      # @param [REXML::Element] elem xml element
+      # @return [Boolean]
+      def self.valid?(elem)
+        TYPES.include?(elem.name.downcase)
+      rescue => e
+        false
+      end
+
+      # 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
+
+    # Returns the manifest's application element or nil, if there isn't any.
+    # @return [Android::Manifest::Application] the manifest's application element
+    def application
+      element = @doc.elements['//application']
+      Application.new(element) if Application.valid?(element)
+    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
+
+    # @return [Array<Android::Manifest::Activity&ActivityAlias>] all activities in the apk
+    # @note return empty array when the manifest include no activities
+    def activities
+      activities = []
+      unless @doc.elements['/manifest/application'].nil?
+        @doc.elements['/manifest/application'].each do |elem|
+          next unless Activity.valid?(elem)
+
+          activities << (elem.name == 'activity-alias' ? ActivityAlias.new(elem) : Activity.new(elem))
+        end
+      end
+      activities
+    end
+
+    # @return [Array<Android::Manifest::Activity&ActivityAlias>] all activities that are launchers in the apk
+    # @note return empty array when the manifest include no activities
+    def launcher_activities
+      activities.select(&:launcher_activity?)
+    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