fastlane-plugin-analyze_apk 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1cffa2a4628a19bbda3325cc00861407830e8466
+  data.tar.gz: a6a43083421a0844923d476a71f611b9d2d1c662
+SHA512:
+  metadata.gz: 136d4a66fa17033e1a20bbce2e20f6d4a8e461dd115fb9307c9d743ed83a9b23f595f7edaaca792737ad2a6434a49d3d044429aaf29578d84b23aada74c384ca
+  data.tar.gz: 49e79a58441672ad60ddb4caaf53f17fb5ce36ac9f61e8a916cdd5640f29ddee540954c03e26d5c4912bad2543def1c0a8e5b2e3da15e14686bc6334911ef27f

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 Daniel Kochavi <>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,81 @@
+# analyze_apk plugin
+
+[![fastlane Plugin Badge](https://rawcdn.githack.com/fastlane/fastlane/master/fastlane/assets/plugin-badge.svg)](https://rubygems.org/gems/fastlane-plugin-analyze_apk)
+
+## Getting Started
+
+This project is a [_fastlane_](https://github.com/fastlane/fastlane) plugin. To get started with `fastlane-plugin-analyze_apk`, add it to your project by running:
+
+```bash
+fastlane add_plugin analyze_apk
+```
+
+## About analyze_apk
+Analyze APK extracts usefull information about your generated APK.
+
+**Options:**
+
+**Key**|**Description**
+-----|-----
+apk\_path|Path to the apk you want to inspect
+android\_home|Path to the root of your Android SDK installation, e.g. ~/tools/android-sdk-macosx
+build\_tools\_version|The Android build tools version to use e.g. '23.0.2'
+
+**Output variables:**
+
+**SharedValue**|**Description**
+-----|-----
+ANALYZE\_APK\_PACKAGE\_NAME|APK's package name
+ANALYZE\_APK\_VERSION\_CODE|APK's version code
+ANALYZE\_APK\_VERSION\_NAME|APK's version name
+ANALYZE\_APK\_APP\_NAME|App's name
+ANALYZE\_APK\_MIN\_SDK|APK's minimal sdk version
+ANALYZE\_APK\_SIZE|APK's size (bytes)
+
+* You can access these values using: ```lane_context[SharedValues::VARIABLE_NAME]```
+
+## Example
+The following lane creates an apk using the [gradle action](https://docs.fastlane.tools/actions/#gradle) then it takes the generated apk and runs ```analyze_apk``` on it (using a ```SharedValue``` set by the gradle action):
+
+```ruby
+fastlane_version "2.39.2"
+
+default_platform :android
+
+platform :android do
+
+  desc "Create an apk and print information about it"
+  lane :apk do
+    gradle( #builds your apk
+      task: "assembleRelease"
+    )
+    analyze_apk(
+      android_home: 'path/to/your/Android/sdk',
+      build_tools_version: '23.0.2',
+      apk_path: lane_context[SharedValues::GRADLE_APK_OUTPUT_PATH]
+    )
+    puts("Version name: #{lane_context[SharedValues::ANALYZE_APK_VERSION_NAME]}")
+    puts("Package name: #{lane_context[SharedValues::ANALYZE_APK_PACKAGE_NAME]}")
+    puts("Version code: #{lane_context[SharedValues::ANALYZE_APK_VERSION_CODE]}")
+    puts("App name: #{lane_context[SharedValues::ANALYZE_APK_APP_NAME]}")
+    puts("Minimum sdk: #{lane_context[SharedValues::ANALYZE_APK_MIN_SDK]}")
+    puts("Apk size: #{lane_context[SharedValues::ANALYZE_APK_SIZE]} bytes")
+  end
+end
+```
+
+## Issues and Feedback
+
+For any other issues and feedback about this plugin, please submit it to this repository.
+
+## Troubleshooting
+
+If you have trouble using plugins, check out the [Plugins Troubleshooting](https://docs.fastlane.tools/plugins/plugins-troubleshooting/) guide.
+
+## Using _fastlane_ Plugins
+
+For more information about how the `fastlane` plugin system works, check out the [Plugins documentation](https://docs.fastlane.tools/plugins/create-plugin/).
+
+## About _fastlane_
+
+_fastlane_ is the easiest way to automate beta deployments and releases for your iOS and Android apps. To learn more, check out [fastlane.tools](https://fastlane.tools).

data/lib/fastlane/plugin/analyze_apk.rb

@@ -0,0 +1,16 @@
+require 'fastlane/plugin/analyze_apk/version'
+
+module Fastlane
+  module AnalyzeApk
+    # Return all .rb files inside the "actions" and "helper" directory
+    def self.all_classes
+      Dir[File.expand_path('**/{actions,helper}/*.rb', File.dirname(__FILE__))]
+    end
+  end
+end
+
+# By default we want to import all available actions and helpers
+# A plugin can contain any number of actions and plugins
+Fastlane::AnalyzeApk.all_classes.each do |current|
+  require current
+end

data/lib/fastlane/plugin/analyze_apk/actions/analyze_apk_action.rb

@@ -0,0 +1,102 @@
+# Code inspired by Bitrise Deploy Step - https://github.com/bitrise-io/steps-deploy-to-bitrise-io
+module Fastlane
+  module Actions
+    module SharedValues
+      ANALYZE_APK_PACKAGE_NAME = :ANALYZE_APK_PACKAGE_NAME
+      ANALYZE_APK_VERSION_CODE = :ANALYZE_APK_VERSION_CODE
+      ANALYZE_APK_VERSION_NAME = :ANALYZE_APK_VERSION_NAME
+      ANALYZE_APK_APP_NAME = :ANALYZE_APK_APP_NAME
+      ANALYZE_APK_MIN_SDK = :ANALYZE_APK_MIN_SDK
+      ANALYZE_APK_SIZE = :ANALYZE_APK_SIZE
+    end
+    class AnalyzeApkAction < Action
+      def self.run(params)
+
+        app_apk_path = params[:apk_path]
+        android_home = params[:android_home]
+
+        UI.user_error!("Couldn't find Android SDK at path '#{android_home}'") if android_home.nil? || !File.directory?(android_home)
+
+        android_env = Fastlane::Helper::AndroidEnvironment.new(params[:android_home],
+                                                               params[:build_tools_version])
+
+        helper = Helper::AnalyzeApkHelper
+        executor = FastlaneCore::CommandExecutor
+
+        aapt_path = android_env.aapt_path
+
+        aapt_info = executor.execute(command: "#{aapt_path} dump badging #{app_apk_path}",
+                                     print_all: false,
+                                     print_command: false)
+
+        package_name, version_code, version_name = helper.filter_package_infos(aapt_info)
+        app_name = helper.filter_app_label(aapt_info)
+        min_sdk = helper.filter_min_sdk_version(aapt_info)
+        apk_file_size = File.size(app_apk_path)
+
+        Actions.lane_context[SharedValues::ANALYZE_APK_PACKAGE_NAME] = package_name if package_name
+        Actions.lane_context[SharedValues::ANALYZE_APK_VERSION_CODE] = version_code if version_code
+        Actions.lane_context[SharedValues::ANALYZE_APK_VERSION_NAME] = version_name if version_name
+
+        Actions.lane_context[SharedValues::ANALYZE_APK_APP_NAME] = app_name if app_name
+        Actions.lane_context[SharedValues::ANALYZE_APK_MIN_SDK] = min_sdk if min_sdk
+        Actions.lane_context[SharedValues::ANALYZE_APK_SIZE] = apk_file_size if apk_file_size
+      end
+
+      def self.description
+        'Analyzes an apk to fetch: versionCode, versionName, apk size, permissions, etc.'
+      end
+
+      def self.authors
+        ['kochavi-daniel']
+      end
+
+      def self.output
+        [
+          ['ANALYZE_APK_VERSION_NAME', 'Apk\'s version name'],
+          ['ANALYZE_APK_VERSION_CODE', 'Apk\'s version code'],
+          ['ANALYZE_APK_PACKAGE_NAME', 'Apk\'s package name'],
+          ['ANALYZE_APK_APP_NAME', 'App name'],
+          ['ANALYZE_APK_MIN_SDK', 'Apk\'s min sdk version'],
+          ['ANALYZE_APK_SIZE', 'Apk\'s size (bytes)']
+        ]
+      end
+
+      def self.return_value
+        # If your method provides a return value, you can describe here what it does
+      end
+
+      def self.details
+        "Using this plugin will enable you to extract the following info about your generated apk: versionName, versionCode, package name, app name, minSdkVersion, apk size"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(key: :apk_path,
+                                       env_name: 'FL_APK_PATH',
+                                       description: 'Path to the apk you want to inspect',
+                                       is_string: true,
+                                       optional: false,
+                                       verify_block: proc do |value|
+                                         UI.user_error!("Couldn't find apk file at path '#{value}'") unless File.exist?(value)
+                                       end),
+          FastlaneCore::ConfigItem.new(key: :android_home,
+                                       env_name: 'FL_ANDROID_HOME',
+                                       description: 'Path to the root of your Android SDK installation, e.g. ~/tools/android-sdk-macosx',
+                                       is_string: true,
+                                       optional: true,
+                                       default_value: ENV['ANDROID_HOME'] || ENV['ANDROID_SDK']),
+          FastlaneCore::ConfigItem.new(key: :build_tools_version,
+                                       env_name: 'FL_BUILD_TOOLS_VERSION',
+                                       description: "The Android build tools version to use, e.g. '23.0.2'",
+                                       is_string: true,
+                                       optional: true)
+        ]
+      end
+
+      def self.is_supported?(platform)
+        platform == :android
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/analyze_apk/helper/analyze_apk_helper.rb

@@ -0,0 +1,47 @@
+module Fastlane
+  module Helper
+    class AnalyzeApkHelper
+      class << self
+        def filter_package_infos(infos)
+          package_name = ''
+          version_code = ''
+          version_name = ''
+
+          package_name_version_regex = 'package: name=\'(?<package_name>.*)\' versionCode=\'(?<version_code>.*)\' versionName=\'(?<version_name>.*)\' platformBuildVersionName='
+          package_name_version_match = infos.match(package_name_version_regex)
+
+          if package_name_version_match && package_name_version_match.captures
+            package_name = package_name_version_match.captures[0]
+            version_code = package_name_version_match.captures[1]
+            version_name = package_name_version_match.captures[2]
+          end
+
+          return [package_name, version_code, version_name]
+        end
+        def filter_app_label(infos)
+          app_label_regex = 'application: label=\'(?<label>.+)\' icon='
+          app_label_match = infos.match(app_label_regex)
+
+          return app_label_match.captures[0] if app_label_match && app_label_match.captures
+
+          app_label_regex = 'application-label:\'(?<label>.*)\''
+          app_label_match = infos.match(app_label_regex)
+
+          return app_label_match.captures[0] if app_label_match && app_label_match.captures
+
+          return ''
+        end
+
+        def filter_min_sdk_version(infos)
+          min_sdk = ''
+
+          min_sdk_regex = 'sdkVersion:\'(?<min_sdk_version>.*)\''
+          min_sdk_match = infos.match(min_sdk_regex)
+          min_sdk = min_sdk_match.captures[0] if min_sdk_match && min_sdk_match.captures
+
+          return min_sdk
+        end
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/analyze_apk/helper/android_environment.rb

@@ -0,0 +1,72 @@
+# Relevant code was copied from the Screengrab action (https://github.com/fastlane/fastlane/blob/master/screengrab/lib/screengrab/android_environment.rb)
+
+require 'fileutils'
+require 'fastlane_core'
+module Fastlane
+  module Helper
+    class AndroidEnvironment
+      attr_reader :android_home
+      attr_reader :build_tools_version
+
+      # android_home        - the String path to the install location of the Android SDK
+      # build_tools_version - the String version of the Android build tools that should be used
+      def initialize(android_home, build_tools_version)
+        @android_home = android_home
+        @build_tools_version = build_tools_version
+      end
+
+      def build_tools_path
+        @build_tools_path ||= find_build_tools(android_home, build_tools_version)
+      end
+
+      def aapt_path
+        @aapt_path ||= find_aapt(build_tools_path)
+      end
+
+      private
+
+      def find_build_tools(android_home, build_tools_version)
+        return nil unless android_home
+
+        build_tools_dir = File.join(android_home, 'build-tools')
+
+        return nil unless build_tools_dir && File.directory?(build_tools_dir)
+
+        return File.join(build_tools_dir, build_tools_version) if build_tools_version
+
+        version = select_build_tools_version(build_tools_dir)
+
+        version ? File.join(build_tools_dir, version) : nil
+      end
+
+      def select_build_tools_version(build_tools_dir)
+        # Collect the sub-directories of the build_tools_dir, rejecting any that start with '.' to remove . and ..
+        dir_names = Dir.entries(build_tools_dir).select { |e| !e.start_with?('.') && File.directory?(File.join(build_tools_dir, e)) }
+
+        # Collect a sorted array of Version objects from the directory names, handling the possibility that some
+        # entries may not be valid version names
+        versions = dir_names.map do |d|
+          begin
+            Gem::Version.new(d)
+          rescue
+            nil
+          end
+        end.reject(&:nil?).sort
+
+        # We'll take the last entry (highest version number) as the directory name we want
+        versions.last.to_s
+      end
+
+      def find_aapt(build_tools_path)
+        return FastlaneCore::CommandExecutor.which('aapt') unless build_tools_path
+
+        aapt_path = File.join(build_tools_path, 'aapt')
+        executable_command?(aapt_path) ? aapt_path : nil
+      end
+
+      def executable_command?(cmd_path)
+        cmd_path && File.executable?(cmd_path) && !File.directory?(cmd_path)
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/analyze_apk/version.rb

@@ -0,0 +1,5 @@
+module Fastlane
+  module AnalyzeApk
+    VERSION = "0.1.0"
+  end
+end

metadata

@@ -0,0 +1,134 @@
+--- !ruby/object:Gem::Specification
+name: fastlane-plugin-analyze_apk
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- kochavi-daniel
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-07-02 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: pry
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: fastlane
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.43.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 2.43.0
+description: 
+email: ''
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- lib/fastlane/plugin/analyze_apk.rb
+- lib/fastlane/plugin/analyze_apk/actions/analyze_apk_action.rb
+- lib/fastlane/plugin/analyze_apk/helper/analyze_apk_helper.rb
+- lib/fastlane/plugin/analyze_apk/helper/android_environment.rb
+- lib/fastlane/plugin/analyze_apk/version.rb
+homepage: https://github.com/kochavi-daniel/fastlane-plugin-analyze-apk
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.8
+signing_key: 
+specification_version: 4
+summary: 'Analyzes an apk to fetch: versionCode, versionName, apk size, etc.'
+test_files: []