From f21a87fa42176f4bf03bf4744300400e86994dcf Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Kriszti=C3=A1n=20G=C3=B6drei?= <krisztian.godrei@bitrise.io>
Date: Thu, 19 Sep 2019 15:54:26 +0200
Subject: [PATCH] send android artifact's module, product flavour and build
 type (#100)

* send android artifct's module, product flavour and build type

* new tests

* parse multiple falvours

* PR fix

* better example for parseAppPath

* handle -unsigned suffix in artifact path

* parse android artifacts, include split meta

* artifact info models

* mark bundle of the split

* aab support in artifact meta

* refactors + dep update

* introduce Artifact

* always return split meta

* pr fix, bundle's universal apk name fix, bundle's universal apk name test, loging updates

* wire in renameUniversalAPK func

* generating apk from aab mooved to the main package; generate or find universal apk pairs for aabs; android artifact path parsing logic moved to the androidartifact package

* improved FindSameArtifact and tests

* new tests

* pr fixes

* pr fixes

* BundleTool fixes

* PR fixes
---
 Gopkg.lock                                    |  22 +-
 aabutil.go                                    | 100 ++++
 androidartifact/apk_info.go                   | 111 ++++
 .../apk_info_test.go                          |  12 +-
 androidartifact/file_name.go                  | 289 +++++++++
 androidartifact/file_name_test.go             | 562 ++++++++++++++++++
 bitrise.yml                                   |   9 +
 bundletool/bundletool.go                      |  24 +-
 main.go                                       |  97 ++-
 main_test.go                                  |  38 ++
 uploaders/aabuploader.go                      | 121 +---
 uploaders/apkuploader.go                      | 119 +---
 .../bitrise-io/bitrise/models/models.go       |   3 +-
 .../bitrise/models/models_methods.go          |   6 +
 .../go-steputils/stepconf/stepconf.go         | 311 +++++++++-
 .../go-utils/sliceutil/sliceutil.go           |  32 +
 16 files changed, 1599 insertions(+), 257 deletions(-)
 create mode 100644 aabutil.go
 create mode 100644 androidartifact/apk_info.go
 rename uploaders/apkuploader_test.go => androidartifact/apk_info_test.go (85%)
 create mode 100644 androidartifact/file_name.go
 create mode 100644 androidartifact/file_name_test.go
 create mode 100644 main_test.go
 create mode 100644 vendor/github.com/bitrise-io/go-utils/sliceutil/sliceutil.go

diff --git a/Gopkg.lock b/Gopkg.lock
index 4795297b..4b3bfebd 100644
--- a/Gopkg.lock
+++ b/Gopkg.lock
@@ -3,11 +3,11 @@
 
 [[projects]]
   branch = "master"
-  digest = "1:f006631e21e1ebecc5bd025f272197c6d1ee0102bc46006cf2e527b57be5e884"
+  digest = "1:5e3bbc74fb2d9b11f52377c6cf4310c084aa8f3dc1995a16f46da52862651ccd"
   name = "github.com/bitrise-io/bitrise"
   packages = ["models"]
   pruneopts = "UT"
-  revision = "85fcf1f508cb6d92ddd2ddf788988fde6cf5178f"
+  revision = "099ec60f02cc67ebd8b086e71abe0c2bd6a58c03"
 
 [[projects]]
   branch = "master"
@@ -15,7 +15,7 @@
   name = "github.com/bitrise-io/envman"
   packages = ["models"]
   pruneopts = "UT"
-  revision = "b62ffe18bb760bf14002dd1a80b059180ef910f1"
+  revision = "7698fc58b190e022c2a8ca667b539ce48c3ed1c9"
 
 [[projects]]
   branch = "master"
@@ -23,22 +23,22 @@
   name = "github.com/bitrise-io/go-android"
   packages = ["sdk"]
   pruneopts = "UT"
-  revision = "8082fe069ed29f394c2fd0724dd6bdc64e5cf6b4"
+  revision = "34d6f20488bf0e2256c034c03a2a589a4a608e3f"
 
 [[projects]]
   branch = "master"
-  digest = "1:e875a94349b121ca6fa86bd72f7593f7f0e6f0d07a7d664f31fc000d80eaeec3"
+  digest = "1:8f5fdb79a7a38f6b7dafbc47f620322f384a0cb06858cb28df0e5635e5bb4df4"
   name = "github.com/bitrise-io/go-steputils"
   packages = [
     "stepconf",
     "tools",
   ]
   pruneopts = "UT"
-  revision = "cecc766da84859e37e780d9d1c416f0f3993e6b1"
+  revision = "f540824d77dfd382ce84fd0ee0a9da2fba1cce0a"
 
 [[projects]]
   branch = "master"
-  digest = "1:c752648f9ec1c0f43af891ef888a43831d99573e4cabec34b89a74f0e1497e9f"
+  digest = "1:16fce352370acaddbf2e658b37ed0870b9490310bed5b55bbd6b47a546f5ca93"
   name = "github.com/bitrise-io/go-utils"
   packages = [
     "colorstring",
@@ -52,11 +52,12 @@
     "pkcs12/internal/rc2",
     "pointers",
     "retry",
+    "sliceutil",
     "urlutil",
     "ziputil",
   ]
   pruneopts = "UT"
-  revision = "cb35044c1bab53fdbfa1e6ea3b56478c25275c9c"
+  revision = "ad86bf775472ce1934affb9d3cb7d5ea3dffd16f"
 
 [[projects]]
   branch = "master"
@@ -81,7 +82,7 @@
   name = "github.com/bitrise-io/stepman"
   packages = ["models"]
   pruneopts = "UT"
-  revision = "605a625dade4553d2e2c5dcc9e3459844cd2f5b4"
+  revision = "8138843b694ce731d58a1754b57ac250a9dec9e6"
 
 [[projects]]
   branch = "master"
@@ -89,7 +90,7 @@
   name = "github.com/bitrise-io/xcode-project"
   packages = ["serialized"]
   pruneopts = "UT"
-  revision = "5929ad85d89233b3296d2d795e068a656db7fb25"
+  revision = "e74e748ca5af39e2bd2b24ed4e9476bc4abd1a50"
 
 [[projects]]
   digest = "1:26e714e21bef4fc07640fb796ccce6d4f9423e15b2d660e131a8e61a0ee576d5"
@@ -162,6 +163,7 @@
     "github.com/bitrise-io/go-utils/log",
     "github.com/bitrise-io/go-utils/pathutil",
     "github.com/bitrise-io/go-utils/retry",
+    "github.com/bitrise-io/go-utils/sliceutil",
     "github.com/bitrise-io/go-utils/urlutil",
     "github.com/bitrise-io/go-utils/ziputil",
     "github.com/bitrise-io/go-xcode/exportoptions",
diff --git a/aabutil.go b/aabutil.go
new file mode 100644
index 00000000..0e7fe99c
--- /dev/null
+++ b/aabutil.go
@@ -0,0 +1,100 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/bitrise-io/go-utils/command"
+	"github.com/bitrise-io/go-utils/errorutil"
+	"github.com/bitrise-io/go-utils/pathutil"
+	"github.com/bitrise-steplib/steps-deploy-to-bitrise-io/androidartifact"
+	"github.com/bitrise-steplib/steps-deploy-to-bitrise-io/bundletool"
+)
+
+// handleError creates error with layout: `<cmd> failed (status: <status_code>): <cmd output>`.
+func handleError(cmd, out string, err error) error {
+	if err == nil {
+		return nil
+	}
+
+	msg := fmt.Sprintf("%s failed", cmd)
+	if status, exitCodeErr := errorutil.CmdExitCodeFromError(err); exitCodeErr == nil {
+		msg += fmt.Sprintf(" (status: %d)", status)
+	}
+	if len(out) > 0 {
+		msg += fmt.Sprintf(": %s", out)
+	}
+	return errors.New(msg)
+}
+
+// run executes a given command.
+func run(cmd *command.Model) error {
+	out, err := cmd.RunAndReturnTrimmedCombinedOutput()
+	return handleError(cmd.PrintableCommandArgs(), out, err)
+}
+
+// generateKeystore creates a debug keystore.
+func generateKeystore(tmpPth string) (string, error) {
+	pth := filepath.Join(tmpPth, "debug.keystore")
+	return pth, run(command.New("keytool", "-genkey", "-v",
+		"-keystore", pth,
+		"-storepass", "android",
+		"-alias", "androiddebugkey",
+		"-keypass", "android",
+		"-keyalg", "RSA",
+		"-keysize", "2048",
+		"-validity", "10000",
+		"-dname", "C=US, O=Android, CN=Android Debug",
+	))
+}
+
+// buildApksArchive generates universal apks from an aab file.
+func buildApksArchive(bundleTool bundletool.Path, tmpPth, aabPth, keystorePath string) (string, error) {
+	pth := filepath.Join(tmpPth, "universal.apks")
+	return pth, run(bundleTool.Command("build-apks", "--mode=universal",
+		"--bundle", aabPth,
+		"--output", pth,
+		"--ks", keystorePath,
+		"--ks-pass", "pass:android",
+		"--ks-key-alias", "androiddebugkey",
+		"--key-pass", "pass:android",
+	))
+}
+
+// unzipUniversalAPKsArchive unzips an universal apks archive.
+func unzipUniversalAPKsArchive(archive, destDir string) (string, error) {
+	return filepath.Join(destDir, "universal.apk"), run(command.New("unzip", archive, "-d", destDir))
+}
+
+// GenerateUniversalAPK generates universal apks from an aab file.
+func GenerateUniversalAPK(aabPth string) (string, error) {
+	r, err := bundletool.New()
+	if err != nil {
+		return "", err
+	}
+
+	tmpPth, err := pathutil.NormalizedOSTempDirPath("aab-bundle")
+	if err != nil {
+		return "", err
+	}
+
+	keystorePath, err := generateKeystore(tmpPth)
+	if err != nil {
+		return "", err
+	}
+
+	apksPth, err := buildApksArchive(r, tmpPth, aabPth, keystorePath)
+	if err != nil {
+		return "", err
+	}
+
+	universalAPKPath, err := unzipUniversalAPKsArchive(apksPth, tmpPth)
+	if err != nil {
+		return "", err
+	}
+
+	renamedUniversalAPKPath := filepath.Join(tmpPth, androidartifact.UniversalAPKBase(aabPth))
+	return renamedUniversalAPKPath, os.Rename(universalAPKPath, renamedUniversalAPKPath)
+}
diff --git a/androidartifact/apk_info.go b/androidartifact/apk_info.go
new file mode 100644
index 00000000..3c6eda7c
--- /dev/null
+++ b/androidartifact/apk_info.go
@@ -0,0 +1,111 @@
+package androidartifact
+
+import (
+	"errors"
+	"fmt"
+	"os"
+	"regexp"
+	"strings"
+
+	"github.com/bitrise-io/go-android/sdk"
+	"github.com/bitrise-io/go-utils/command"
+)
+
+// ApkInfo ...
+type ApkInfo struct {
+	AppName           string
+	PackageName       string
+	VersionCode       string
+	VersionName       string
+	MinSDKVersion     string
+	RawPackageContent string
+}
+
+// parseAppName parses the application name from `aapt dump badging` command output.
+func parseAppName(aaptOut string) string {
+	pattern := `application: label=\'(?P<label>.+)\' icon=`
+	re := regexp.MustCompile(pattern)
+	if matches := re.FindStringSubmatch(aaptOut); len(matches) == 2 {
+		return matches[1]
+	}
+
+	pattern = `application-label:\'(?P<label>.*)\'`
+	re = regexp.MustCompile(pattern)
+	if matches := re.FindStringSubmatch(aaptOut); len(matches) == 2 {
+		return matches[1]
+	}
+
+	return ""
+}
+
+// parseMinSDKVersion parses the min sdk version from `aapt dump badging` command output.
+func parseMinSDKVersion(aaptOut string) string {
+	pattern := `sdkVersion:\'(?P<min_sdk_version>.*)\'`
+	re := regexp.MustCompile(pattern)
+	if matches := re.FindStringSubmatch(aaptOut); len(matches) == 2 {
+		return matches[1]
+	}
+	return ""
+}
+
+// parsePackageField parses fields from `aapt dump badging` command output.
+func parsePackageField(aaptOut, key string) string {
+	pattern := fmt.Sprintf(`%s=['"](.*?)['"]`, key)
+
+	re := regexp.MustCompile(pattern)
+	if matches := re.FindStringSubmatch(aaptOut); len(matches) == 2 {
+		return matches[1]
+	}
+
+	return ""
+}
+
+// ParsePackageInfos parses package name, version code and name from `aapt dump badging` command output.
+func ParsePackageInfos(aaptOut string) (string, string, string) {
+	return parsePackageField(aaptOut, "name"),
+		parsePackageField(aaptOut, "versionCode"),
+		parsePackageField(aaptOut, "versionName")
+}
+
+// GetAPKInfo returns infos about the APK.
+func GetAPKInfo(apkPth string) (ApkInfo, error) {
+	androidHome := os.Getenv("ANDROID_HOME")
+	if androidHome == "" {
+		return ApkInfo{}, errors.New("ANDROID_HOME environment not set")
+	}
+
+	sdkModel, err := sdk.New(androidHome)
+	if err != nil {
+		return ApkInfo{}, fmt.Errorf("failed to create sdk model, error: %s", err)
+	}
+
+	aaptPth, err := sdkModel.LatestBuildToolPath("aapt")
+	if err != nil {
+		return ApkInfo{}, fmt.Errorf("failed to find latest aapt binary, error: %s", err)
+	}
+
+	aaptOut, err := command.New(aaptPth, "dump", "badging", apkPth).RunAndReturnTrimmedCombinedOutput()
+	if err != nil {
+		return ApkInfo{}, fmt.Errorf("failed to get apk infos, output: %s, error: %s", aaptOut, err)
+	}
+
+	appName := parseAppName(aaptOut)
+	packageName, versionCode, versionName := ParsePackageInfos(aaptOut)
+	minSDKVersion := parseMinSDKVersion(aaptOut)
+
+	packageContent := ""
+	for _, line := range strings.Split(aaptOut, "\n") {
+		if strings.HasPrefix(line, "package:") {
+			packageContent = line
+		}
+	}
+
+	return ApkInfo{
+		AppName:           appName,
+		PackageName:       packageName,
+		VersionCode:       versionCode,
+		VersionName:       versionName,
+		MinSDKVersion:     minSDKVersion,
+		RawPackageContent: packageContent,
+	}, nil
+}
diff --git a/uploaders/apkuploader_test.go b/androidartifact/apk_info_test.go
similarity index 85%
rename from uploaders/apkuploader_test.go
rename to androidartifact/apk_info_test.go
index 90c2183f..9d288ffd 100644
--- a/uploaders/apkuploader_test.go
+++ b/androidartifact/apk_info_test.go
@@ -1,8 +1,8 @@
-package uploaders
+package androidartifact
 
 import "testing"
 
-func Test_filterPackageInfos(t *testing.T) {
+func TestParsePackageInfos(t *testing.T) {
 
 	tests := []struct {
 		name    string
@@ -63,15 +63,15 @@ func Test_filterPackageInfos(t *testing.T) {
 	}
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
-			got, got1, got2 := filterPackageInfos(tt.aaptOut)
+			got, got1, got2 := ParsePackageInfos(tt.aaptOut)
 			if got != tt.want {
-				t.Errorf("filterPackageInfos() got = %v, want %v", got, tt.want)
+				t.Errorf("ParsePackageInfos() got = %v, want %v", got, tt.want)
 			}
 			if got1 != tt.want1 {
-				t.Errorf("filterPackageInfos() got1 = %v, want %v", got1, tt.want1)
+				t.Errorf("ParsePackageInfos() got1 = %v, want %v", got1, tt.want1)
 			}
 			if got2 != tt.want2 {
-				t.Errorf("filterPackageInfos() got2 = %v, want %v", got2, tt.want2)
+				t.Errorf("ParsePackageInfos() got2 = %v, want %v", got2, tt.want2)
 			}
 		})
 	}
diff --git a/androidartifact/file_name.go b/androidartifact/file_name.go
new file mode 100644
index 00000000..0ec75718
--- /dev/null
+++ b/androidartifact/file_name.go
@@ -0,0 +1,289 @@
+package androidartifact
+
+import (
+	"fmt"
+	"path/filepath"
+	"strings"
+	"unicode"
+
+	"github.com/bitrise-io/go-utils/log"
+	"github.com/bitrise-io/go-utils/sliceutil"
+	"github.com/bitrise-steplib/steps-xcode-test/pretty"
+)
+
+const universalSplitParam = "universal"
+
+// The order of split params matter, while the artifact path parsing is done, we remove the split params in this order.
+// If we would remove `xhdpi` from app-xxxhdpi-debug.apk, the remaining part would be: app-xx-debug.apk.
+var (
+	// based on: https://developer.android.com/ndk/guides/abis.html#sa
+	abis            = []string{"armeabi-v7a", "arm64-v8a", "x86_64", "x86", universalSplitParam}
+	unsupportedAbis = []string{"mips64", "mips", "armeabi"}
+
+	// based on: https://developer.android.com/studio/build/configure-apk-splits#configure-density-split
+	screenDensities = []string{"xxxhdpi", "xxhdpi", "xhdpi", "hdpi", "mdpi", "ldpi", "280", "360", "420", "480", "560"}
+)
+
+// ArtifactSigningInfo ...
+type ArtifactSigningInfo struct {
+	Unsigned      bool
+	BitriseSigned bool
+}
+
+const bitriseSignedSuffix = "-bitrise-signed"
+const unsignedSuffix = "-unsigned"
+
+// parseSigningInfo parses android artifact path
+// and returns codesigning info and the artifact's base name without signing params.
+func parseSigningInfo(pth string) (ArtifactSigningInfo, string) {
+	info := ArtifactSigningInfo{}
+
+	ext := filepath.Ext(pth)
+	base := filepath.Base(pth)
+	base = strings.TrimSuffix(base, ext)
+
+	// a given artifact is either:
+	// signed: no suffix
+	// unsigned: `-unsigned` suffix
+	// bitrise signed: `-bitrise-signed` suffix: https://github.com/bitrise-steplib/steps-sign-apk/blob/master/main.go#L411
+	if strings.HasSuffix(base, bitriseSignedSuffix) {
+		base = strings.TrimSuffix(base, bitriseSignedSuffix)
+		info.BitriseSigned = true
+	}
+
+	if strings.HasSuffix(base, unsignedSuffix) {
+		base = strings.TrimSuffix(base, unsignedSuffix)
+		info.Unsigned = true
+	}
+
+	return info, base
+}
+
+// ArtifactSplitInfo ...
+type ArtifactSplitInfo struct {
+	SplitParams []string
+	Universal   bool
+}
+
+// firstLetterUpper makes the given string's first letter uppercase.
+func firstLetterUpper(str string) string {
+	for i, v := range str {
+		return string(unicode.ToUpper(v)) + str[i+1:]
+	}
+	return ""
+}
+
+// parseSplitInfo parses the flavour candidate part of the artifact's base name
+// and returns APK split info and the flavour without split params.
+func parseSplitInfo(flavour string) (ArtifactSplitInfo, string) {
+	// 2 flavours + density split: minApi21-full-hdpi
+	// density and abi split: hdpiArmeabi
+	// flavour + density and abi split: demo-hdpiArm64-v8a
+	var info ArtifactSplitInfo
+
+	var splitParams []string
+	splitParams = append(splitParams, abis...)
+	splitParams = append(splitParams, unsupportedAbis...)
+	splitParams = append(splitParams, screenDensities...)
+
+	for _, splitParam := range splitParams {
+		// in case of density + ABI split the 2. split param starts with upper case letter: demo-hdpiArm64-v8a
+		for _, param := range []string{splitParam, firstLetterUpper(splitParam)} {
+			if strings.Contains(flavour, param) {
+				flavour = strings.Replace(flavour, param, "", 1)
+
+				info.SplitParams = append(info.SplitParams, splitParam)
+				if splitParam == universalSplitParam {
+					info.Universal = true
+				}
+
+				break
+			}
+		}
+	}
+
+	// after removing split params, may leading/trailing - char remains: demo-hdpiArm64-v8a
+	flavour = strings.TrimPrefix(flavour, "-")
+	return info, strings.TrimSuffix(flavour, "-")
+}
+
+// ArtifactInfo ...
+type ArtifactInfo struct {
+	Module         string
+	ProductFlavour string
+	BuildType      string
+
+	SigningInfo ArtifactSigningInfo
+	SplitInfo   ArtifactSplitInfo
+}
+
+// ParseArtifactPath parses an android artifact path.
+func ParseArtifactPath(pth string) ArtifactInfo {
+	info := ArtifactInfo{}
+
+	var base string
+	info.SigningInfo, base = parseSigningInfo(pth)
+
+	// based on: https://developer.android.com/studio/build/build-variants
+	// - <build variant> = <product flavor> + <build type>
+	// - debug and release build types always exists
+	// - APK/AAB base name layout: <module>-<product flavor?>-<build type>.<apk|aab>
+	// - Sample APK path: $BITRISE_DEPLOY_DIR/app-minApi21-demo-hdpi-debug.apk
+	s := strings.Split(base, "-")
+	if len(s) < 2 {
+		// unknown app base name
+		// app artifact name can be customized: https://stackoverflow.com/a/28250257
+		return info
+	}
+
+	info.Module = s[0]
+	info.BuildType = s[len(s)-1]
+	if len(s) > 2 {
+		productFlavourWithSplitParams := strings.Join(s[1:len(s)-1], "-")
+		info.SplitInfo, info.ProductFlavour = parseSplitInfo(productFlavourWithSplitParams)
+
+	}
+	return info
+}
+
+// ArtifactMap module/buildType/flavour/artifacts
+type ArtifactMap map[string]map[string]map[string]Artifact
+
+// Artifact ...
+type Artifact struct {
+	APK string // set if a single APK represents the app
+
+	AAB          string
+	Split        []string // split apk paths including the universal apk path, excluding the bundle path
+	UniversalApk string
+}
+
+// FindSameArtifact returns the first artifact which is the same variant as the reference artifact,
+// code signing differences does not matter.
+func FindSameArtifact(pth string, pths []string) string {
+	for _, suffix := range []string{"", unsignedSuffix, bitriseSignedSuffix} {
+		_, base := parseSigningInfo(pth)
+		artifactPth := filepath.Join(filepath.Dir(pth), base+suffix+filepath.Ext(pth))
+
+		if idx := sliceutil.IndexOfStringInSlice(artifactPth, pths); idx > -1 {
+			return pths[idx]
+		}
+	}
+	return ""
+}
+
+// mapBuildArtifacts creates a module/buildType/productFlavour[artifactPaths] mapping.
+func mapBuildArtifacts(pths []string) ArtifactMap {
+	buildArtifacts := map[string]map[string]map[string]Artifact{}
+	for _, pth := range pths {
+		info := ParseArtifactPath(pth)
+
+		moduleArtifacts, ok := buildArtifacts[info.Module]
+		if !ok {
+			moduleArtifacts = map[string]map[string]Artifact{}
+		}
+
+		buildTypeArtifacts, ok := moduleArtifacts[info.BuildType]
+		if !ok {
+			buildTypeArtifacts = map[string]Artifact{}
+		}
+
+		artifact := buildTypeArtifacts[info.ProductFlavour]
+
+		if filepath.Ext(pth) == ".aab" {
+			if len(artifact.AAB) != 0 {
+				log.Warnf("Multple AAB generated for module: %s, productFlavour: %s, buildType: %s: %s", info.Module, info.ProductFlavour, info.BuildType, pth)
+			}
+			artifact.AAB = pth
+			buildTypeArtifacts[info.ProductFlavour] = artifact
+			moduleArtifacts[info.BuildType] = buildTypeArtifacts
+			buildArtifacts[info.Module] = moduleArtifacts
+			continue
+		}
+
+		if len(info.SplitInfo.SplitParams) == 0 {
+			if len(artifact.APK) != 0 {
+				// might -unsigned and -bitrise-signed versions both exist of the same apk
+			}
+			artifact.APK = pth
+			buildTypeArtifacts[info.ProductFlavour] = artifact
+			moduleArtifacts[info.BuildType] = buildTypeArtifacts
+			buildArtifacts[info.Module] = moduleArtifacts
+			continue
+		}
+
+		if info.SplitInfo.Universal {
+			if len(artifact.UniversalApk) != 0 {
+				log.Warnf("Multple universal APK generated for module: %s, productFlavour: %s, buildType: %s: %s", info.Module, info.ProductFlavour, info.BuildType, pth)
+			}
+			artifact.UniversalApk = pth
+		}
+
+		// might -unsigned and -bitrise-signed versions of the same apk is listed
+		pairPth := FindSameArtifact(pth, artifact.Split)
+		if len(pairPth) == 0 {
+			artifact.Split = append(artifact.Split, pth)
+			buildTypeArtifacts[info.ProductFlavour] = artifact
+		}
+
+		moduleArtifacts[info.BuildType] = buildTypeArtifacts
+		buildArtifacts[info.Module] = moduleArtifacts
+	}
+
+	return buildArtifacts
+}
+
+// remove deletes an element of an array.
+func remove(slice []string, i uint) []string {
+	if int(i) > len(slice)-1 {
+		return slice
+	}
+	return append(slice[:i], slice[i+1:]...)
+}
+
+// SplitArtifactMeta ...
+type SplitArtifactMeta Artifact
+
+// CreateSplitArtifactMeta ...
+func CreateSplitArtifactMeta(pth string, pths []string) (SplitArtifactMeta, error) {
+	artifactsMap := mapBuildArtifacts(pths)
+	info := ParseArtifactPath(pth)
+
+	moduleArtifacts, ok := artifactsMap[info.Module]
+	if !ok {
+		return SplitArtifactMeta{}, fmt.Errorf("artifact: %s is not part of the artifact mapping: %s", pth, pretty.Object(artifactsMap))
+	}
+
+	buildTypeArtifacts, ok := moduleArtifacts[info.BuildType]
+	if !ok {
+		return SplitArtifactMeta{}, fmt.Errorf("artifact: %s is not part of the artifact mapping: %s", pth, pretty.Object(artifactsMap))
+	}
+
+	artifact, ok := buildTypeArtifacts[info.ProductFlavour]
+	if !ok {
+		return SplitArtifactMeta{}, fmt.Errorf("artifact: %s is not part of the artifact mapping: %s", pth, pretty.Object(artifactsMap))
+	}
+
+	return SplitArtifactMeta(artifact), nil
+}
+
+// UniversalAPKBase returns the aab's universal apk pair's base name.
+func UniversalAPKBase(basedOnAAB string) string {
+	// <module>-<product_flavor>?-universal-<build type>-<unsigned|bitrise-signed>?.apk
+	info := ParseArtifactPath(basedOnAAB)
+
+	nameParts := []string{info.Module}
+	if len(info.ProductFlavour) > 0 {
+		nameParts = append(nameParts, info.ProductFlavour)
+	}
+	nameParts = append(nameParts, "universal", info.BuildType)
+
+	name := strings.Join(nameParts, "-")
+	if info.SigningInfo.Unsigned {
+		name = name + unsignedSuffix
+	} else if info.SigningInfo.BitriseSigned {
+		name = name + bitriseSignedSuffix
+	}
+	name += ".apk"
+	return name
+}
diff --git a/androidartifact/file_name_test.go b/androidartifact/file_name_test.go
new file mode 100644
index 00000000..6bd90065
--- /dev/null
+++ b/androidartifact/file_name_test.go
@@ -0,0 +1,562 @@
+package androidartifact
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/bitrise-io/go-utils/sliceutil"
+	"github.com/bitrise-steplib/steps-xcode-test/pretty"
+)
+
+func TestParseArtifactPath(t *testing.T) {
+	tests := []struct {
+		name     string
+		pth      string
+		wantInfo ArtifactSigningInfo
+		wantBase string
+	}{
+		{
+			name: "Does not modify path if does not have -bitrise-signed suffix",
+			pth:  "$BITRISE_DEPLOY_DIR/app-demo-debug.apk",
+			wantInfo: ArtifactSigningInfo{
+				Unsigned:      false,
+				BitriseSigned: false,
+			},
+			wantBase: "app-demo-debug",
+		},
+		{
+			name: "Trims -bitrise-signed suffix",
+			pth:  "$BITRISE_DEPLOY_DIR/app-demo-debug-bitrise-signed.apk",
+			wantInfo: ArtifactSigningInfo{
+				Unsigned:      false,
+				BitriseSigned: true,
+			},
+			wantBase: "app-demo-debug",
+		},
+		{
+			name: "Trims -unsigned suffix",
+			pth:  "$BITRISE_DEPLOY_DIR/app-demo-debug-unsigned.apk",
+			wantInfo: ArtifactSigningInfo{
+				Unsigned:      true,
+				BitriseSigned: false,
+			},
+			wantBase: "app-demo-debug",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gotInfo, gotBase := parseSigningInfo(tt.pth)
+			if !reflect.DeepEqual(gotInfo, tt.wantInfo) {
+				t.Errorf("parseSigningInfo() = %v, want %v", pretty.Object(gotInfo), pretty.Object(tt.wantInfo))
+			}
+
+			if gotBase != tt.wantBase {
+				t.Errorf("parseSigningInfo() = %v, want %v", gotBase, tt.wantBase)
+			}
+		})
+	}
+}
+
+func Test_parseArtifactInfo(t *testing.T) {
+	tests := []struct {
+		name string
+		pth  string
+		want ArtifactInfo
+	}{
+		{
+			name: "Parses apk path with Product Flavour",
+			pth:  "$BITRISE_DEPLOY_DIR/app-demo-debug.apk",
+			want: ArtifactInfo{
+				Module:         "app",
+				ProductFlavour: "demo",
+				BuildType:      "debug",
+			},
+		},
+		{
+			name: "Parses apk path without Product Flavour",
+			pth:  "$BITRISE_DEPLOY_DIR/app-debug.apk",
+			want: ArtifactInfo{
+				Module:         "app",
+				ProductFlavour: "",
+				BuildType:      "debug",
+			},
+		},
+		{
+			name: "Parses aab path with -bitrise-signed suffix",
+			pth:  "$BITRISE_DEPLOY_DIR/app-demo-debug-bitrise-signed.aab",
+			want: ArtifactInfo{
+				Module:         "app",
+				ProductFlavour: "demo",
+				BuildType:      "debug",
+				SigningInfo: ArtifactSigningInfo{
+					Unsigned:      false,
+					BitriseSigned: true,
+				},
+			},
+		},
+		{
+			name: "Returns empty for custom apk path",
+			pth:  "$BITRISE_DEPLOY_DIR/custom.apk",
+			want: ArtifactInfo{
+				Module:         "",
+				ProductFlavour: "",
+				BuildType:      "",
+			},
+		},
+		{
+			name: "Parses ABI split apk path",
+			pth:  "$BITRISE_SOURCE_DIR/app-arm64-v8a-debug.apk",
+			want: ArtifactInfo{
+				Module:         "app",
+				ProductFlavour: "",
+				BuildType:      "debug",
+				SplitInfo: ArtifactSplitInfo{
+					SplitParams: []string{"arm64-v8a"},
+				},
+			},
+		},
+		{
+			name: "Parses 2 flavour dimensions, screen density split",
+			pth:  "$BITRISE_SOURCE_DIR/app-minApi21-demo-hdpi-debug.apk",
+			want: ArtifactInfo{
+				Module:         "app",
+				ProductFlavour: "minApi21-demo",
+				BuildType:      "debug",
+				SplitInfo: ArtifactSplitInfo{
+					SplitParams: []string{"hdpi"},
+				},
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := ParseArtifactPath(tt.pth)
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("ParseArtifactPath() = %v, want %v", pretty.Object(got), pretty.Object(tt.want))
+			}
+		})
+	}
+}
+
+func Test_mapBuildArtifacts(t *testing.T) {
+	tests := []struct {
+		name string
+		pths []string
+		want ArtifactMap
+	}{
+		{
+			name: "APK split by density and abi",
+			pths: []string{
+				"app-arm64-v8a-debug.apk",
+				"app-hdpiArmeabi-v7a-debug.apk",
+				"app-mdpiX86-debug.apk",
+				"app-xhdpiX86_64-debug.apk",
+			},
+			want: ArtifactMap{
+				"app": map[string]map[string]Artifact{
+					"debug": map[string]Artifact{
+						"": Artifact{
+							Split: []string{
+								"app-arm64-v8a-debug.apk",
+								"app-hdpiArmeabi-v7a-debug.apk",
+								"app-mdpiX86-debug.apk",
+								"app-xhdpiX86_64-debug.apk",
+							},
+						},
+					},
+				},
+			},
+		},
+		{
+			name: " -bitrise-signed and -unsigned apks",
+			pths: []string{
+				"app-debug-unsigned.apk",
+				"app-debug-bitrise-signed.apk",
+			},
+			want: ArtifactMap{
+				"app": map[string]map[string]Artifact{
+					"debug": map[string]Artifact{
+						"": Artifact{
+							APK: "app-debug-bitrise-signed.apk",
+						},
+					},
+				},
+			},
+		},
+		{
+			name: " -bitrise-signed and -unsigned apks",
+			pths: []string{
+				"app-demo-debug-unsigned.apk",
+				"app-demo-debug-bitrise-signed.apk",
+			},
+			want: ArtifactMap{
+				"app": map[string]map[string]Artifact{
+					"debug": map[string]Artifact{
+						"demo": Artifact{
+							APK: "app-demo-debug-bitrise-signed.apk",
+						},
+					},
+				},
+			},
+		},
+		{
+			name: "APK split by density and 2 flavours",
+			pths: []string{
+				"app-minApi21-full-hdpi-debug.apk",
+				"app-minApi21-full-ldpi-debug.apk",
+				"app-minApi21-full-mdpi-debug.apk",
+				"app-minApi21-demo-universal-debug.apk",
+				"app-minApi21-demo-xhdpi-debug.apk",
+				"app-minApi21-demo-xxhdpi-debug.apk",
+				"app-minApi21-demo-xxxhdpi-debug.apk",
+			},
+			want: ArtifactMap{
+				"app": map[string]map[string]Artifact{
+					"debug": map[string]Artifact{
+						"minApi21-demo": Artifact{
+							Split: []string{
+								"app-minApi21-demo-universal-debug.apk",
+								"app-minApi21-demo-xhdpi-debug.apk",
+								"app-minApi21-demo-xxhdpi-debug.apk",
+								"app-minApi21-demo-xxxhdpi-debug.apk",
+							},
+							UniversalApk: "app-minApi21-demo-universal-debug.apk",
+						},
+						"minApi21-full": Artifact{
+							Split: []string{
+								"app-minApi21-full-hdpi-debug.apk",
+								"app-minApi21-full-ldpi-debug.apk",
+								"app-minApi21-full-mdpi-debug.apk",
+							},
+						},
+					},
+				},
+			},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got := mapBuildArtifacts(tt.pths)
+
+			if len(tt.want) != len(got) {
+				t.Errorf("%v does not equal %v", pretty.Object(tt.want), pretty.Object(got))
+				return
+			}
+
+			for wantModule, wantModuleArtifacts := range tt.want {
+				gotModuleArtifacts := got[wantModule]
+
+				if len(gotModuleArtifacts) != len(wantModuleArtifacts) {
+					t.Errorf("%v does not equal %v", pretty.Object(tt.want), pretty.Object(got))
+					return
+				}
+
+				for wantBuildType, wantBuildTypeArtifact := range wantModuleArtifacts {
+					gotBuildTypeArtifact := gotModuleArtifacts[wantBuildType]
+
+					if len(gotBuildTypeArtifact) != len(wantBuildTypeArtifact) {
+						t.Errorf("%v does not equal %v", pretty.Object(tt.want), pretty.Object(got))
+						return
+					}
+
+					if !reflect.DeepEqual(wantBuildTypeArtifact, gotBuildTypeArtifact) {
+						t.Errorf("%v does not equal %v", pretty.Object(tt.want), pretty.Object(got))
+						return
+					}
+				}
+			}
+		})
+	}
+}
+
+func comparseSlice(a, b []string) bool {
+	if len(a) != len(b) {
+		return false
+	}
+
+	for _, e := range a {
+		if !sliceutil.IsStringInSlice(e, b) {
+			return false
+		}
+	}
+	return true
+}
+
+func compareMapStringStringSlice(a, b map[string][]string) bool {
+	if len(a) != len(b) {
+		return false
+	}
+
+	for keyA, valueA := range a {
+		valueB, ok := b[keyA]
+		if !ok {
+			return false
+		}
+
+		if !comparseSlice(valueA, valueB) {
+			return false
+		}
+	}
+
+	return true
+}
+
+func TestCreateSplitArtifactMeta(t *testing.T) {
+	tests := []struct {
+		name    string
+		pth     string
+		pths    []string
+		want    SplitArtifactMeta
+		wantErr bool
+	}{
+		{
+			name: "Split artifacts",
+			pth:  "app-mdpiX86-debug.apk",
+			pths: []string{
+				"app-arm64-v8a-debug.apk",
+				"app-hdpiArmeabi-v7a-debug.apk",
+				"app-mdpiX86-debug.apk",
+				"app-xhdpiX86_64-debug.apk",
+			},
+			want: SplitArtifactMeta{
+				Split: []string{
+					"app-arm64-v8a-debug.apk",
+					"app-hdpiArmeabi-v7a-debug.apk",
+					"app-mdpiX86-debug.apk",
+					"app-xhdpiX86_64-debug.apk",
+				},
+				UniversalApk: "",
+			},
+			wantErr: false,
+		},
+		{
+			name: "Split artifacts with universal apk",
+			pth:  "app-minApi21-demo-universal-debug.apk",
+			pths: []string{
+				"app-minApi21-demo-universal-debug.apk",
+				"app-minApi21-demo-xhdpi-debug.apk",
+				"app-minApi21-demo-xxhdpi-debug.apk",
+				"app-minApi21-demo-xxxhdpi-debug.apk",
+			},
+			want: SplitArtifactMeta{
+				Split: []string{
+					"app-minApi21-demo-universal-debug.apk",
+					"app-minApi21-demo-xhdpi-debug.apk",
+					"app-minApi21-demo-xxhdpi-debug.apk",
+					"app-minApi21-demo-xxxhdpi-debug.apk",
+				},
+				UniversalApk: "app-minApi21-demo-universal-debug.apk",
+			},
+			wantErr: false,
+		},
+		{
+			name: "Split artifacts with bitrise signed apk",
+			pth:  "app-minApi21-demo-xhdpi-debug-bitrise-signed.apk",
+			pths: []string{
+				"app-minApi21-demo-universal-debug.apk",
+				"app-minApi21-demo-xhdpi-debug.apk",
+				"app-minApi21-demo-xxhdpi-debug.apk",
+				"app-minApi21-demo-xxxhdpi-debug.apk",
+				"app-minApi21-demo-xhdpi-debug-bitrise-signed.apk",
+			},
+			want: SplitArtifactMeta{
+				Split: []string{
+					"app-minApi21-demo-universal-debug.apk",
+					"app-minApi21-demo-xhdpi-debug.apk",
+					"app-minApi21-demo-xxhdpi-debug.apk",
+					"app-minApi21-demo-xxxhdpi-debug.apk",
+				},
+				UniversalApk: "app-minApi21-demo-universal-debug.apk",
+			},
+			wantErr: false,
+		},
+		{
+			name: "Split apks with aab",
+			pth:  "app-minApi21-demo-xhdpi-debug-bitrise-signed.apk",
+			pths: []string{
+				"app-minApi21-demo-universal-debug.apk",
+				"app-minApi21-demo-xhdpi-debug.apk",
+				"app-minApi21-demo-xxhdpi-debug.apk",
+				"app-minApi21-demo-xxxhdpi-debug.apk",
+				"app-minApi21-demo-xhdpi-debug-bitrise-signed.apk",
+				"app-minApi21-demo-debug.aab",
+			},
+			want: SplitArtifactMeta{
+				Split: []string{
+					"app-minApi21-demo-universal-debug.apk",
+					"app-minApi21-demo-xhdpi-debug.apk",
+					"app-minApi21-demo-xxhdpi-debug.apk",
+					"app-minApi21-demo-xxxhdpi-debug.apk",
+				},
+				UniversalApk: "app-minApi21-demo-universal-debug.apk",
+				AAB:          "app-minApi21-demo-debug.aab",
+			},
+			wantErr: false,
+		},
+		{
+			name: "aab with -bitrise-signed and simple apks",
+			pth:  "app-minApi24-full-release-bitrise-signed.aab",
+			pths: []string{
+				"app-minApi24-full-release-bitrise-signed.aab",
+				"app-minApi24-full-universal-release-bitrise-signed.apk",
+				"app-minApi24-full-universal-release.apk",
+			},
+			want: SplitArtifactMeta{
+				Split: []string{
+					"app-minApi24-full-universal-release-bitrise-signed.apk",
+				},
+				UniversalApk: "app-minApi24-full-universal-release-bitrise-signed.apk",
+				AAB:          "app-minApi24-full-release-bitrise-signed.aab",
+			},
+			wantErr: false,
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			got, err := CreateSplitArtifactMeta(tt.pth, tt.pths)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("CreateSplitArtifactMeta() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("CreateSplitArtifactMeta() = %v, want %v", pretty.Object(got), pretty.Object(tt.want))
+			}
+		})
+	}
+}
+
+func TestUniversalAPKBase(t *testing.T) {
+	tests := []struct {
+		name       string
+		basedOnAAB string
+		want       string
+	}{
+		{
+			name:       "simple test",
+			basedOnAAB: "app-release.aab",
+			want:       "app-universal-release.apk",
+		},
+		{
+			name:       "bitrise signed aab",
+			basedOnAAB: "app-release-bitrise-signed.aab",
+			want:       "app-universal-release-bitrise-signed.apk",
+		},
+		{
+			name:       "2 flavours",
+			basedOnAAB: "app-minApi21-demo-debug.aab",
+			want:       "app-minApi21-demo-universal-debug.apk",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := UniversalAPKBase(tt.basedOnAAB); got != tt.want {
+				t.Errorf("UniversalAPKBase() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func TestFindSameArtifact(t *testing.T) {
+	type args struct {
+		pth  string
+		pths []string
+	}
+	tests := []struct {
+		name string
+		pth  string
+		pths []string
+		want string
+	}{
+		{
+			name: "Finds if -bitrise-signed version exists",
+			pth:  "app-minApi21-demo-debug.apk",
+			pths: []string{"app-minApi21-demo-debug-bitrise-signed.apk"},
+			want: "app-minApi21-demo-debug-bitrise-signed.apk",
+		},
+		{
+			name: "Finds if not -bitrise-signed version exists",
+			pth:  "app-minApi21-demo-debug-bitrise-signed.apk",
+			pths: []string{"app-minApi21-demo-debug.apk"},
+			want: "app-minApi21-demo-debug.apk",
+		},
+		{
+			name: "Finds if not -unsigned version exist",
+			pth:  "app-minApi21-demo-debug-unsigned.apk",
+			pths: []string{"app-minApi21-demo-debug.apk"},
+			want: "app-minApi21-demo-debug.apk",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := FindSameArtifact(tt.pth, tt.pths); got != tt.want {
+				t.Errorf("FindSameArtifact() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func Test_firstLetterUpper(t *testing.T) {
+	tests := []struct {
+		name string
+		str  string
+		want string
+	}{
+		{
+			name: "empty test",
+			str:  "",
+			want: "",
+		},
+		{
+			name: "char test",
+			str:  "t",
+			want: "T",
+		},
+		{
+			name: "simple test",
+			str:  "arm64-v8a",
+			want: "Arm64-v8a",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := firstLetterUpper(tt.str); got != tt.want {
+				t.Errorf("firstLetterUpper() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
+
+func Test_remove(t *testing.T) {
+	tests := []struct {
+		name  string
+		slice []string
+		i     uint
+		want  []string
+	}{
+		{
+			name:  "empty test",
+			slice: []string{},
+			i:     0,
+			want:  []string{},
+		},
+		{
+			name:  "simple test",
+			slice: []string{"a", "b"},
+			i:     0,
+			want:  []string{"b"},
+		},
+		{
+			name:  "out of range test",
+			slice: []string{"a", "b"},
+			i:     2,
+			want:  []string{"a", "b"},
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := remove(tt.slice, tt.i); !reflect.DeepEqual(got, tt.want) {
+				t.Errorf("remove() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
diff --git a/bitrise.yml b/bitrise.yml
index ac5905dc..f2a63236 100644
--- a/bitrise.yml
+++ b/bitrise.yml
@@ -51,6 +51,7 @@ workflows:
         - notify_user_groups: $NOTIFY_USER_GROUPS
         - notify_email_list: $NOTIFY_EMAIL_LIST
         - is_enable_public_page: "true"
+        - debug_mode: "true"
     - path::./:
         title: IOS Test XcArchive
         run_if: true
@@ -62,6 +63,7 @@ workflows:
         - notify_user_groups: $NOTIFY_USER_GROUPS
         - notify_email_list: $NOTIFY_EMAIL_LIST
         - is_enable_public_page: "true"
+        - debug_mode: "true"
     - path::./:
         title: IOS Test compressed with default name
         run_if: true
@@ -73,6 +75,7 @@ workflows:
         - notify_user_groups: $NOTIFY_USER_GROUPS
         - notify_email_list: $NOTIFY_EMAIL_LIST
         - is_enable_public_page: "true"
+        - debug_mode: "true"
     - path::./:
         title: IOS Test compressed with custom name
         run_if: true
@@ -85,6 +88,7 @@ workflows:
         - notify_user_groups: $NOTIFY_USER_GROUPS
         - notify_email_list: $NOTIFY_EMAIL_LIST
         - is_enable_public_page: "true"
+        - debug_mode: "true"
     - path::./:
         title: Android AAB Test uncompressed
         run_if: true
@@ -96,6 +100,7 @@ workflows:
         - notify_user_groups: $NOTIFY_USER_GROUPS
         - notify_email_list: $NOTIFY_EMAIL_LIST
         - is_enable_public_page: "true"
+        - debug_mode: "true"
     - path::./:
         title: Android Test uncompressed
         run_if: true
@@ -107,6 +112,7 @@ workflows:
         - notify_user_groups: $NOTIFY_USER_GROUPS
         - notify_email_list: $NOTIFY_EMAIL_LIST
         - is_enable_public_page: "true"
+        - debug_mode: "true"
     - path::./:
         title: Android Test compressed with default name
         run_if: true
@@ -118,6 +124,7 @@ workflows:
         - notify_user_groups: $NOTIFY_USER_GROUPS
         - notify_email_list: $NOTIFY_EMAIL_LIST
         - is_enable_public_page: "true"
+        - debug_mode: "true"
     - path::./:
         title: Android Test compressed with custom name
         run_if: true
@@ -130,6 +137,7 @@ workflows:
         - notify_user_groups: $NOTIFY_USER_GROUPS
         - notify_email_list: $NOTIFY_EMAIL_LIST
         - is_enable_public_page: "true"
+        - debug_mode: "true"
     - path::./:
         title: Android Test compressed with custom name from file path
         run_if: true
@@ -142,6 +150,7 @@ workflows:
         - notify_user_groups: $NOTIFY_USER_GROUPS
         - notify_email_list: $NOTIFY_EMAIL_LIST
         - is_enable_public_page: "true"
+        - debug_mode: "true"
     - script:
         title: Output (generated by the Step) tests
         inputs:
diff --git a/bundletool/bundletool.go b/bundletool/bundletool.go
index d2592d61..29da56f8 100644
--- a/bundletool/bundletool.go
+++ b/bundletool/bundletool.go
@@ -9,40 +9,38 @@ import (
 	"github.com/bitrise-io/go-utils/pathutil"
 )
 
-// Runner ...
-type Runner struct {
-	localPath string
-}
+// Path ...
+type Path string
 
-// NewRunner ...
-func NewRunner() (Runner, error) {
+// New ...
+func New() (Path, error) {
 	const downloadURL = "https://github.com/google/bundletool/releases/download/0.9.0/bundletool-all-0.9.0.jar"
 
 	tmpPth, err := pathutil.NormalizedOSTempDirPath("tool")
 	if err != nil {
-		return Runner{}, err
+		return "", err
 	}
 
 	resp, err := http.Get(downloadURL)
 	if err != nil {
-		return Runner{}, err
+		return "", err
 	}
 
 	d, err := ioutil.ReadAll(resp.Body)
 	if err != nil {
-		return Runner{}, err
+		return "", err
 	}
 
 	if err := resp.Body.Close(); err != nil {
-		return Runner{}, err
+		return "", err
 	}
 
 	toolPath := filepath.Join(tmpPth, filepath.Base(downloadURL))
 
-	return Runner{toolPath}, ioutil.WriteFile(toolPath, d, 0777)
+	return Path(toolPath), ioutil.WriteFile(toolPath, d, 0777)
 }
 
 // Command ...
-func (r Runner) Command(cmd string, args ...string) *command.Model {
-	return command.New("java", append([]string{"-jar", r.localPath, cmd}, args...)...)
+func (p Path) Command(cmd string, args ...string) *command.Model {
+	return command.New("java", append([]string{"-jar", string(p), cmd}, args...)...)
 }
diff --git a/main.go b/main.go
index 3ed15e16..2de68b07 100644
--- a/main.go
+++ b/main.go
@@ -8,6 +8,7 @@ import (
 	"path/filepath"
 	"strings"
 
+	"github.com/bitrise-steplib/steps-deploy-to-bitrise-io/androidartifact"
 	"github.com/bitrise-steplib/steps-deploy-to-bitrise-io/test"
 
 	"github.com/bitrise-io/go-steputils/stepconf"
@@ -226,10 +227,78 @@ func deployTestResults(config Config) {
 	}
 }
 
+func findUniversalAPKPair(aab string, apks []string) string {
+	universalAPKBase := androidartifact.UniversalAPKBase(aab)
+	return androidartifact.FindSameArtifact(universalAPKBase, apks)
+}
+
+func ensureAABsHasUniversalAPKPair(aabs, apks []string) ([]string, map[string]string, error) {
+	aabAPKPairs := map[string]string{}
+	for _, aab := range aabs {
+		log.Debugf("Looking for universal APK pair for: %s", aab)
+
+		universalAPKPair := findUniversalAPKPair(aab, apks)
+		if len(universalAPKPair) == 0 {
+			log.Debugf("Does not have universal APK pair, generating...")
+
+			var err error
+			universalAPKPair, err = GenerateUniversalAPK(aab)
+			if err != nil {
+				return nil, nil, err
+			}
+
+			log.Debugf("Generated universal APK pair: %s", universalAPKPair)
+
+			apks = append(apks, universalAPKPair)
+		} else {
+			log.Debugf("Universal APK pair: %s", universalAPKPair)
+		}
+
+		aabAPKPairs[aab] = universalAPKPair
+	}
+	return apks, aabAPKPairs, nil
+}
+
+func findAPKsAndAABs(pths []string) (apks []string, aabs []string, others []string) {
+	for _, pth := range pths {
+		switch getFileType(pth) {
+		case ".apk":
+			apks = append(apks, pth)
+		case ".aab":
+			aabs = append(aabs, pth)
+		default:
+			others = append(others, pth)
+		}
+	}
+	return
+}
+
 func deploy(clearedFilesToDeploy []string, config Config) (map[string]string, error) {
-	publicInstallPages := make(map[string]string)
-	for _, pth := range clearedFilesToDeploy {
+	apks, aabs, others := findAPKsAndAABs(clearedFilesToDeploy)
+	apks, aabAPKPairs, err := ensureAABsHasUniversalAPKPair(aabs, apks)
+	if err != nil {
+		return nil, err
+	}
+	androidArtifacts := append(apks, aabs...)
+
+	// deploy the apks first, as the universal apk's public install page will be used for aabs.
+	publicInstallPages := map[string]string{}
+	apkInstallPages := map[string]string{}
+	for _, apk := range apks {
+		log.Donef("Uploading apk file: %s", apk)
+
+		installPage, err := uploaders.DeployAPK(apk, androidArtifacts, config.BuildURL, config.APIToken, config.NotifyUserGroups, config.NotifyEmailList, config.IsPublicPageEnabled)
+		if err != nil {
+			return nil, fmt.Errorf("deploy failed, error: %s", err)
+		}
 
+		if installPage != "" {
+			publicInstallPages[filepath.Base(apk)] = installPage
+			apkInstallPages[filepath.Base(apk)] = installPage
+		}
+	}
+
+	for _, pth := range append(aabs, others...) {
 		fileType := getFileType(pth)
 		fmt.Println()
 
@@ -242,30 +311,24 @@ func deploy(clearedFilesToDeploy []string, config Config) (map[string]string, er
 				return nil, fmt.Errorf("deploy failed, error: %s", err)
 			}
 
-			if installPage != "" {
-				publicInstallPages[filepath.Base(pth)] = installPage
-			}
-		case ".apk":
-			log.Donef("Uploading apk file: %s", pth)
-
-			installPage, err := uploaders.DeployAPK(pth, config.BuildURL, config.APIToken, config.NotifyUserGroups, config.NotifyEmailList, config.IsPublicPageEnabled)
-			if err != nil {
-				return nil, fmt.Errorf("deploy failed, error: %s", err)
-			}
-
 			if installPage != "" {
 				publicInstallPages[filepath.Base(pth)] = installPage
 			}
 		case ".aab":
 			log.Donef("Uploading aab file: %s", pth)
 
-			installPage, err := uploaders.DeployAAB(pth, config.BuildURL, config.APIToken, config.NotifyUserGroups, config.NotifyEmailList, config.IsPublicPageEnabled)
-			if err != nil {
+			if err := uploaders.DeployAAB(pth, androidArtifacts, config.BuildURL, config.APIToken,
+				config.NotifyUserGroups, config.NotifyEmailList, config.IsPublicPageEnabled); err != nil {
 				return nil, fmt.Errorf("deploy failed, error: %s", err)
 			}
 
-			if installPage != "" {
-				publicInstallPages[filepath.Base(pth)] = installPage
+			universalAPKPair, ok := aabAPKPairs[pth]
+			if !ok {
+				return nil, fmt.Errorf("no iniversal apk pair found for aab: %s", pth)
+			}
+
+			if universalAPKInstallPage := apkInstallPages[filepath.Base(universalAPKPair)]; universalAPKInstallPage != "" {
+				publicInstallPages[filepath.Base(pth)] = universalAPKInstallPage
 			}
 		case zippedXcarchiveExt:
 			log.Donef("Uploading xcarchive file: %s", pth)
diff --git a/main_test.go b/main_test.go
new file mode 100644
index 00000000..b46d2c75
--- /dev/null
+++ b/main_test.go
@@ -0,0 +1,38 @@
+package main
+
+import "testing"
+
+func Test_findUniversalAPKPair(t *testing.T) {
+	tests := []struct {
+		name string
+		aab  string
+		apks []string
+		want string
+	}{
+		{
+			name: "Only universal apk can be the pair",
+			aab:  "app-minApi21-demo-debug-bitrise-signed.aab",
+			apks: []string{"app-minApi21-demo-debug.apk"},
+			want: "",
+		},
+		{
+			name: "Finds if aab is bitrise-signed",
+			aab:  "app-minApi21-demo-debug-bitrise-signed.aab",
+			apks: []string{"app-minApi21-demo-universal-debug.apk"},
+			want: "app-minApi21-demo-universal-debug.apk",
+		},
+		{
+			name: "Finds if aab is bitrise-signed, even if apk is unsigned",
+			aab:  "app-minApi21-demo-debug-bitrise-signed.aab",
+			apks: []string{"app-minApi21-demo-universal-debug-unsigned.apk"},
+			want: "app-minApi21-demo-universal-debug-unsigned.apk",
+		},
+	}
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			if got := findUniversalAPKPair(tt.aab, tt.apks); got != tt.want {
+				t.Errorf("findUniversalAPKPair() = %v, want %v", got, tt.want)
+			}
+		})
+	}
+}
diff --git a/uploaders/aabuploader.go b/uploaders/aabuploader.go
index a2b3426d..5a7b8cbf 100644
--- a/uploaders/aabuploader.go
+++ b/uploaders/aabuploader.go
@@ -3,107 +3,33 @@ package uploaders
 import (
 	"encoding/json"
 	"fmt"
-	"os"
-	"path/filepath"
-
-	"github.com/bitrise-io/go-utils/command"
-	"github.com/bitrise-io/go-utils/pathutil"
 
 	"github.com/bitrise-io/go-utils/log"
+	"github.com/bitrise-steplib/steps-deploy-to-bitrise-io/androidartifact"
 	"github.com/bitrise-steplib/steps-deploy-to-bitrise-io/bundletool"
 )
 
-// create debug keystore for signing
-func generateKeystore(tmpPth string) (string, error) {
-	log.Printf("- generating debug keystore")
-
-	keystorePath := filepath.Join(tmpPth, "debug.keystore")
-	cmd := command.New("keytool", "-genkey", "-v", "-keystore", keystorePath, "-storepass", "android", "-alias", "androiddebugkey",
-		"-keypass", "android", "-keyalg", "RSA", "-keysize", "2048", "-validity", "10000", "-dname", "C=US, O=Android, CN=Android Debug").
-		SetStdout(os.Stdout).
-		SetStderr(os.Stderr)
-
-	log.Donef("$ %s", cmd.PrintableCommandArgs())
-
-	return keystorePath, cmd.Run()
-}
-
-// generate `tmpDir/universal.apks` from aab file
-func buildApksArchive(r bundletool.Runner, tmpPth, aabPth, keystorePath string) (string, error) {
-	log.Printf("- generating universal apk")
-
-	apksPth := filepath.Join(tmpPth, "universal.apks")
-	cmd := r.Command("build-apks", "--mode=universal", "--bundle", aabPth, "--output", apksPth, "--ks", keystorePath, "--ks-pass", "pass:android", "--ks-key-alias", "androiddebugkey", "--key-pass", "pass:android").SetStdout(os.Stdout).SetStderr(os.Stderr)
-
-	log.Donef("$ %s", cmd.PrintableCommandArgs())
-
-	return apksPth, cmd.Run()
-}
-
 // DeployAAB ...
-func DeployAAB(pth, buildURL, token, notifyUserGroups, notifyEmails, isEnablePublicPage string) (string, error) {
+func DeployAAB(pth string, artifacts []string, buildURL, token, notifyUserGroups, notifyEmails, isEnablePublicPage string) error {
 	log.Printf("- analyzing aab")
 
-	tmpPth, err := pathutil.NormalizedOSTempDirPath("aab-bundle")
-	if err != nil {
-		return "", err
-	}
-
-	r, err := bundletool.NewRunner()
-	if err != nil {
-		return "", err
-	}
-
-	fmt.Println()
-
-	keystorePath, err := generateKeystore(tmpPth)
-	if err != nil {
-		return "", err
-	}
-
-	fmt.Println()
-
-	apksPth, err := buildApksArchive(r, tmpPth, pth, keystorePath)
-	if err != nil {
-		return "", err
-	}
-
-	fmt.Println()
-
-	// unzip `tmpDir/universal.apks` to tmpPth to have `tmpDir/universal.apk`
-	log.Printf("- unzip")
-	cmd := command.New("unzip", apksPth, "-d", tmpPth).SetStdout(os.Stdout).SetStderr(os.Stderr)
-
-	log.Donef("$ %s", cmd.PrintableCommandArgs())
-
-	if err := cmd.Run(); err != nil {
-		return "", err
-	}
-
-	fmt.Println()
-	log.Printf("- rename")
-
-	// rename `tmpDir/universal.apk` to `tmpDir/aab-name.aab.universal.apk`
-	universalAPKPath, renamedUniversalAPKPath := filepath.Join(tmpPth, "universal.apk"), filepath.Join(tmpPth, filepath.Base(pth)+".universal.apk")
-	if err := os.Rename(universalAPKPath, renamedUniversalAPKPath); err != nil {
-		return "", err
-	}
-
-	fmt.Println()
-
 	// get aab manifest dump
 	log.Printf("- fetching info")
 
-	cmd = r.Command("dump", "manifest", "--bundle", pth)
+	r, err := bundletool.New()
+	if err != nil {
+		return err
+	}
+	cmd := r.Command("dump", "manifest", "--bundle", pth)
 
 	log.Donef("$ %s", cmd.PrintableCommandArgs())
 
 	out, err := cmd.RunAndReturnTrimmedCombinedOutput()
 	if err != nil {
-		return "", err
+		return err
 	}
 
-	packageName, versionCode, versionName := filterPackageInfos(out)
+	packageName, versionCode, versionName := androidartifact.ParsePackageInfos(out)
 
 	appInfo := map[string]interface{}{
 		"package_name": packageName,
@@ -129,35 +55,48 @@ func DeployAAB(pth, buildURL, token, notifyUserGroups, notifyEmails, isEnablePub
 
 	fileSize, err := fileSizeInBytes(pth)
 	if err != nil {
-		return "", fmt.Errorf("failed to get apk size, error: %s", err)
+		return fmt.Errorf("failed to get apk size, error: %s", err)
 	}
 
+	info := androidartifact.ParseArtifactPath(pth)
+
 	aabInfoMap := map[string]interface{}{
 		"file_size_bytes": fmt.Sprintf("%f", fileSize),
 		"app_info":        appInfo,
+		"module":          info.Module,
+		"product_flavour": info.ProductFlavour,
+		"build_type":      info.BuildType,
+	}
+
+	splitMeta, err := androidartifact.CreateSplitArtifactMeta(pth, artifacts)
+	if err != nil {
+		log.Errorf("Failed to create split meta, error: %s", err)
+	} else {
+		aabInfoMap["apk"] = splitMeta.APK
+		aabInfoMap["aab"] = splitMeta.AAB
+		aabInfoMap["split"] = splitMeta.Split
+		aabInfoMap["universal"] = splitMeta.UniversalApk
 	}
 
 	artifactInfoBytes, err := json.Marshal(aabInfoMap)
 	if err != nil {
-		return "", fmt.Errorf("failed to marshal apk infos, error: %s", err)
+		return fmt.Errorf("failed to marshal apk infos, error: %s", err)
 	}
 
 	// ---
 
 	uploadURL, artifactID, err := createArtifact(buildURL, token, pth, "android-apk")
 	if err != nil {
-		return "", fmt.Errorf("failed to create apk artifact, error: %s", err)
+		return fmt.Errorf("failed to create apk artifact, error: %s", err)
 	}
 
 	if err := uploadArtifact(uploadURL, pth, ""); err != nil {
-		return "", fmt.Errorf("failed to upload apk artifact, error: %s", err)
+		return fmt.Errorf("failed to upload apk artifact, error: %s", err)
 	}
 
 	if _, err = finishArtifact(buildURL, token, artifactID, string(artifactInfoBytes), "", "", "false"); err != nil {
-		return "", fmt.Errorf("failed to finish apk artifact, error: %s", err)
+		return fmt.Errorf("failed to finish apk artifact, error: %s", err)
 	}
 
-	fmt.Println()
-
-	return DeployAPK(renamedUniversalAPKPath, buildURL, token, notifyUserGroups, notifyEmails, isEnablePublicPage)
+	return nil
 }
diff --git a/uploaders/apkuploader.go b/uploaders/apkuploader.go
index 70b05379..c8161a88 100644
--- a/uploaders/apkuploader.go
+++ b/uploaders/apkuploader.go
@@ -2,116 +2,17 @@ package uploaders
 
 import (
 	"encoding/json"
-	"errors"
 	"fmt"
-	"os"
-	"regexp"
-	"strings"
 
-	"github.com/bitrise-io/go-android/sdk"
-	"github.com/bitrise-io/go-utils/command"
 	"github.com/bitrise-io/go-utils/log"
+	"github.com/bitrise-steplib/steps-deploy-to-bitrise-io/androidartifact"
 )
 
-// ApkInfo ...
-type ApkInfo struct {
-	AppName           string
-	PackageName       string
-	VersionCode       string
-	VersionName       string
-	MinSDKVersion     string
-	RawPackageContent string
-}
-
-func packageField(data, key string) string {
-	pattern := fmt.Sprintf(`%s=['"](.*?)['"]`, key)
-
-	re := regexp.MustCompile(pattern)
-	if matches := re.FindStringSubmatch(data); len(matches) == 2 {
-		return matches[1]
-	}
-
-	return ""
-}
-
-func filterPackageInfos(aaptOut string) (string, string, string) {
-	return packageField(aaptOut, "name"),
-		packageField(aaptOut, "versionCode"),
-		packageField(aaptOut, "versionName")
-}
-
-func filterAppLable(aaptOut string) string {
-	pattern := `application: label=\'(?P<label>.+)\' icon=`
-	re := regexp.MustCompile(pattern)
-	if matches := re.FindStringSubmatch(aaptOut); len(matches) == 2 {
-		return matches[1]
-	}
-
-	pattern = `application-label:\'(?P<label>.*)\'`
-	re = regexp.MustCompile(pattern)
-	if matches := re.FindStringSubmatch(aaptOut); len(matches) == 2 {
-		return matches[1]
-	}
-
-	return ""
-}
-
-func filterMinSDKVersion(aaptOut string) string {
-	pattern := `sdkVersion:\'(?P<min_sdk_version>.*)\'`
-	re := regexp.MustCompile(pattern)
-	if matches := re.FindStringSubmatch(aaptOut); len(matches) == 2 {
-		return matches[1]
-	}
-	return ""
-}
-
-func getAPKInfo(apkPth string) (ApkInfo, error) {
-	androidHome := os.Getenv("ANDROID_HOME")
-	if androidHome == "" {
-		return ApkInfo{}, errors.New("ANDROID_HOME environment not set")
-	}
-
-	sdkModel, err := sdk.New(androidHome)
-	if err != nil {
-		return ApkInfo{}, fmt.Errorf("failed to create sdk model, error: %s", err)
-	}
-
-	aaptPth, err := sdkModel.LatestBuildToolPath("aapt")
-	if err != nil {
-		return ApkInfo{}, fmt.Errorf("failed to find latest aapt binary, error: %s", err)
-	}
-
-	aaptOut, err := command.New(aaptPth, "dump", "badging", apkPth).RunAndReturnTrimmedCombinedOutput()
-	if err != nil {
-		return ApkInfo{}, fmt.Errorf("failed to get apk infos, output: %s, error: %s", aaptOut, err)
-	}
-
-	appName := filterAppLable(aaptOut)
-	packageName, versionCode, versionName := filterPackageInfos(aaptOut)
-	minSDKVersion := filterMinSDKVersion(aaptOut)
-
-	packageContent := ""
-	for _, line := range strings.Split(aaptOut, "\n") {
-		if strings.HasPrefix(line, "package:") {
-			packageContent = line
-		}
-	}
-
-	return ApkInfo{
-		AppName:           appName,
-		PackageName:       packageName,
-		VersionCode:       versionCode,
-		VersionName:       versionName,
-		MinSDKVersion:     minSDKVersion,
-		RawPackageContent: packageContent,
-	}, nil
-}
-
 // DeployAPK ...
-func DeployAPK(pth, buildURL, token, notifyUserGroups, notifyEmails, isEnablePublicPage string) (string, error) {
+func DeployAPK(pth string, artifacts []string, buildURL, token, notifyUserGroups, notifyEmails, isEnablePublicPage string) (string, error) {
 	log.Printf("analyzing apk")
 
-	apkInfo, err := getAPKInfo(pth)
+	apkInfo, err := androidartifact.GetAPKInfo(pth)
 	if err != nil {
 		return "", err
 	}
@@ -145,9 +46,23 @@ func DeployAPK(pth, buildURL, token, notifyUserGroups, notifyEmails, isEnablePub
 		return "", fmt.Errorf("failed to get apk size, error: %s", err)
 	}
 
+	info := androidartifact.ParseArtifactPath(pth)
+
 	apkInfoMap := map[string]interface{}{
 		"file_size_bytes": fmt.Sprintf("%f", fileSize),
 		"app_info":        appInfo,
+		"module":          info.Module,
+		"product_flavour": info.ProductFlavour,
+		"build_type":      info.BuildType,
+	}
+	splitMeta, err := androidartifact.CreateSplitArtifactMeta(pth, artifacts)
+	if err != nil {
+		log.Errorf("Failed to create split meta, error: %s", err)
+	} else {
+		apkInfoMap["aab"] = splitMeta.AAB
+		apkInfoMap["apk"] = splitMeta.APK
+		apkInfoMap["split"] = splitMeta.Split
+		apkInfoMap["universal"] = splitMeta.UniversalApk
 	}
 
 	artifactInfoBytes, err := json.Marshal(apkInfoMap)
diff --git a/vendor/github.com/bitrise-io/bitrise/models/models.go b/vendor/github.com/bitrise-io/bitrise/models/models.go
index 162b573c..5350eaad 100644
--- a/vendor/github.com/bitrise-io/bitrise/models/models.go
+++ b/vendor/github.com/bitrise-io/bitrise/models/models.go
@@ -20,7 +20,7 @@ const (
 	StepRunStatusCodeSkippedWithRunIf = 4
 
 	// Version ...
-	Version = "8"
+	Version = "9"
 )
 
 // StepListItemModel ...
@@ -44,6 +44,7 @@ type AppModel struct {
 	Summary      string                              `json:"summary,omitempty" yaml:"summary,omitempty"`
 	Description  string                              `json:"description,omitempty" yaml:"description,omitempty"`
 	Environments []envmanModels.EnvironmentItemModel `json:"envs,omitempty" yaml:"envs,omitempty"`
+	Meta         map[string]interface{}              `json:"meta,omitempty" yaml:"meta,omitempty"`
 }
 
 // TriggerEventType ...
diff --git a/vendor/github.com/bitrise-io/bitrise/models/models_methods.go b/vendor/github.com/bitrise-io/bitrise/models/models_methods.go
index c07834f5..c8f75248 100644
--- a/vendor/github.com/bitrise-io/bitrise/models/models_methods.go
+++ b/vendor/github.com/bitrise-io/bitrise/models/models_methods.go
@@ -247,6 +247,12 @@ func (app *AppModel) Normalize() error {
 			return err
 		}
 	}
+	normalizedMeta, err := stepmanModels.JSONMarshallable(app.Meta)
+	if err != nil {
+		return err
+	}
+	app.Meta = normalizedMeta
+
 	return nil
 }
 
diff --git a/vendor/github.com/bitrise-io/go-steputils/stepconf/stepconf.go b/vendor/github.com/bitrise-io/go-steputils/stepconf/stepconf.go
index a47b2fef..027095bd 100644
--- a/vendor/github.com/bitrise-io/go-steputils/stepconf/stepconf.go
+++ b/vendor/github.com/bitrise-io/go-steputils/stepconf/stepconf.go
@@ -23,6 +23,12 @@ type ParseError struct {
 	Err   error
 }
 
+const rangeMinimumGroupName = "min"
+const rangeMaximumGroupName = "max"
+const rangeMinBracketGroupName = "minbr"
+const rangeMaxBracketGroupName = "maxbr"
+const rangeRegex = `range(?P<` + rangeMinBracketGroupName + `>\[|\])(?P<` + rangeMinimumGroupName + `>.*?)\.\.(?P<` + rangeMaximumGroupName + `>.*?)(?P<` + rangeMaxBracketGroupName + `>\[|\])`
+
 // Error implements builtin errors.Error.
 func (e *ParseError) Error() string {
 	segments := []string{e.Field}
@@ -123,6 +129,44 @@ func Parse(conf interface{}) error {
 }
 
 func setField(field reflect.Value, value, constraint string) error {
+	if err := validateConstraint(value, constraint); err != nil {
+		return err
+	}
+
+	if value == "" {
+		return nil
+	}
+
+	switch field.Kind() {
+	case reflect.String:
+		field.SetString(value)
+	case reflect.Bool:
+		b, err := parseutil.ParseBool(value)
+		if err != nil {
+			return errors.New("can't convert to bool")
+		}
+		field.SetBool(b)
+	case reflect.Int:
+		n, err := strconv.ParseInt(value, 10, 32)
+		if err != nil {
+			return errors.New("can't convert to int")
+		}
+		field.SetInt(n)
+	case reflect.Float64:
+		f, err := strconv.ParseFloat(value, 64)
+		if err != nil {
+			return errors.New("can't convert to float")
+		}
+		field.SetFloat(f)
+	case reflect.Slice:
+		field.Set(reflect.ValueOf(strings.Split(value, "|")))
+	default:
+		return fmt.Errorf("type is not supported (%s)", field.Kind())
+	}
+	return nil
+}
+
+func validateConstraint(value, constraint string) error {
 	switch constraint {
 	case "":
 		break
@@ -140,37 +184,270 @@ func setField(field reflect.Value, value, constraint string) error {
 			// TODO: print only the value options, not the whole string.
 			return fmt.Errorf("value is not in value options (%s)", constraint)
 		}
+	case regexp.MustCompile(rangeRegex).FindString(constraint):
+		if err := ValidateRangeFields(value, constraint); err != nil {
+			return err
+		}
 	default:
 		return fmt.Errorf("invalid constraint (%s)", constraint)
 	}
+	return nil
+}
 
-	if value == "" {
+//ValidateRangeFields validates if the given range is proper. Ranges are optional, empty values are valid.
+func ValidateRangeFields(valueStr, constraint string) error {
+	if valueStr == "" {
 		return nil
 	}
+	constraintMin, constraintMax, constraintMinBr, constraintMaxBr, err := GetRangeValues(constraint)
+	if err != nil {
+		return err
+	}
+	min, err := parseValueStr(constraintMin)
+	if err != nil {
+		return fmt.Errorf("failed to parse min value %s: %s", constraintMin, err)
+	}
+	max, err := parseValueStr(constraintMax)
+	if err != nil {
+		return fmt.Errorf("failed to parse max value %s: %s", constraintMax, err)
+	}
+	value, err := parseValueStr(valueStr)
+	if err != nil {
+		return fmt.Errorf("failed to parse value %s: %s", valueStr, err)
+	}
+	isMinInclusiveBool, err := isMinInclusive(constraintMinBr)
+	if err != nil {
+		return err
+	}
+	isMaxInclusiveBool, err := isMaxInclusive(constraintMaxBr)
+	if err != nil {
+		return err
+	}
 
-	switch field.Kind() {
-	case reflect.String:
-		field.SetString(value)
-	case reflect.Bool:
-		b, err := parseutil.ParseBool(value)
-		if err != nil {
-			return errors.New("can't convert to bool")
+	if err := validateRangeFieldValues(min, max, isMinInclusiveBool, isMaxInclusiveBool, value); err != nil {
+		return err
+	}
+	if err := validateRangeFieldTypes(min, max, value); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func isMinInclusive(bracket string) (bool, error) {
+	switch bracket {
+	case "[":
+		return true, nil
+	case "]":
+		return false, nil
+	default:
+		return false, fmt.Errorf("invalid string found for bracket: %s", bracket)
+	}
+}
+
+func isMaxInclusive(bracket string) (bool, error) {
+	switch bracket {
+	case "[":
+		return false, nil
+	case "]":
+		return true, nil
+	default:
+		return false, fmt.Errorf("invalid string found for bracket: %s", bracket)
+	}
+}
+
+func validateRangeFieldValues(min interface{}, max interface{}, minInclusive bool, maxInclusive bool, value interface{}) error {
+	if value == nil {
+		return fmt.Errorf("value is not present")
+	}
+	var err error
+	var valueFloat float64
+	if valueFloat, err = getFloatValue(value); err != nil {
+		return err
+	}
+
+	var minErr error
+	var minFloat float64
+	if min != nil {
+		if minFloat, err = getFloatValue(min); err != nil {
+			return err
 		}
-		field.SetBool(b)
-	case reflect.Int:
-		n, err := strconv.ParseInt(value, 10, 32)
-		if err != nil {
-			return errors.New("can't convert to int")
+		minErr = validateRangeMinFieldValue(minFloat, valueFloat, minInclusive)
+	}
+
+	var maxErr error
+	var maxFloat float64
+	if max != nil {
+		var err error
+		if maxFloat, err = getFloatValue(max); err != nil {
+			return err
 		}
-		field.SetInt(n)
-	case reflect.Slice:
-		field.Set(reflect.ValueOf(strings.Split(value, "|")))
+		maxErr = validateRangeMaxFieldValue(maxFloat, valueFloat, maxInclusive)
+	}
+
+	if min != nil && max != nil {
+		if minFloat > maxFloat {
+			return fmt.Errorf("constraint logic is wrong, minimum value %f is bigger than maximum %f", minFloat, maxFloat)
+		}
+		if minFloat == maxFloat {
+			return fmt.Errorf("minimum value %f is equal to maximum %f, for this case use optional value", minFloat, maxFloat)
+		}
+	}
+
+	if min == nil {
+		return maxErr
+	} else if max == nil {
+		return minErr
+	}
+	if minErr != nil || maxErr != nil {
+		return fmt.Errorf("value %f is out of range %f-%f", value, minFloat, maxFloat)
+	}
+	return nil
+}
+
+func validateRangeFieldTypes(min interface{}, max interface{}, value interface{}) error {
+	if value == nil {
+		return fmt.Errorf("value cannot be nil")
+	}
+	var minType string
+	var maxType string
+	var valueType string
+	var err error
+
+	if valueType, err = getTypeOf(value); err != nil {
+		return err
+	}
+	if min != nil {
+		if minType, err = getTypeOf(min); err != nil {
+			return err
+		}
+	}
+	if max != nil {
+		if maxType, err = getTypeOf(max); err != nil {
+			return err
+		}
+	}
+
+	if maxType != "" && minType != "" && !hasSameContent(minType, maxType, valueType) {
+		return fmt.Errorf("invalid constraint and value combination, minimum is %s, maximum is %s, value is %s, but they should be the same", minType, maxType, valueType)
+	}
+
+	if maxType != "" && !hasSameContent(maxType, valueType) {
+		return fmt.Errorf("invalid constraint and value combination, maximum is %s, value is %s, but they should be the same", maxType, valueType)
+	}
+
+	if minType != "" && !hasSameContent(minType, valueType) {
+		return fmt.Errorf("invalid constraint and value combination, minimum is %s, value is %s, but they should be the same", minType, valueType)
+	}
+	return nil
+}
+
+func hasSameContent(strs ...string) bool {
+	length := len(strs)
+	if length == 1 {
+		return true
+	}
+	firstItem := strs[0]
+	for i := 1; i < length; i++ {
+		if strings.Compare(firstItem, strs[i]) != 0 {
+			return false
+		}
+	}
+	return true
+}
+
+func getTypeOf(v interface{}) (string, error) {
+	switch v.(type) {
+	case int64:
+		return "int64", nil
+	case float64:
+		return "float64", nil
 	default:
-		return fmt.Errorf("type is not supported (%s)", field.Kind())
+		return "unknown", fmt.Errorf("could not find type for %v", v)
+	}
+}
+
+func parseValueStr(value string) (interface{}, error) {
+	var err error
+	var parsedInt int64
+	var parsedFloat float64
+	if parsedInt, err = strconv.ParseInt(value, 10, 64); err != nil {
+		// Could be float
+		if parsedFloat, err = strconv.ParseFloat(value, 64); err != nil {
+			// It is invalid.
+			return nil, fmt.Errorf("value %s is could not be parsed", value)
+		}
+		return parsedFloat, nil
+	}
+	return parsedInt, nil
+}
+
+func getFloatValue(value interface{}) (float64, error) {
+	switch i := value.(type) {
+	case int64:
+		return float64(i), nil
+	case float64:
+		return i, nil
+	case string:
+		var parsedValue interface{}
+		var err error
+		if parsedValue, err = parseValueStr(i); err != nil {
+			return 0, err
+		}
+		return getFloatValue(parsedValue)
+	default:
+		return 0, fmt.Errorf("not supported type %T", value)
+	}
+}
+
+func validateRangeMinFieldValue(min float64, value float64, inclusive bool) error {
+	if inclusive && min > value {
+		return fmt.Errorf("value %f is out of range, less than minimum %f", value, min)
+	} else if !inclusive && min >= value {
+		return fmt.Errorf("value %f is out of range, greater or equal than maximum %f", value, min)
+	}
+	return nil
+}
+
+func validateRangeMaxFieldValue(max float64, value float64, inclusive bool) error {
+	if inclusive && max < value {
+		return fmt.Errorf("value %f is out of range, greater than maximum %f", value, max)
+
+	} else if !inclusive && max <= value {
+		return fmt.Errorf("value %f is out of range, greater or equal than maximum %f", value, max)
 	}
 	return nil
 }
 
+// GetRangeValues reads up the given range constraint and returns the values, or an error if the constraint is malformed or could not be parsed.
+func GetRangeValues(value string) (min string, max string, minBracket string, maxBracket string, err error) {
+	regex := regexp.MustCompile(rangeRegex)
+	groups := regex.FindStringSubmatch(value)
+	if len(groups) < 1 {
+		return "", "", "", "", fmt.Errorf("value in value options is malformed (%s)", value)
+	}
+
+	groupMap := getRegexGroupMap(groups, regex)
+	minStr := groupMap[rangeMinimumGroupName]
+	maxStr := groupMap[rangeMaximumGroupName]
+	minBr := groupMap[rangeMinBracketGroupName]
+	maxBr := groupMap[rangeMaxBracketGroupName]
+	if minStr == "" && maxStr == "" {
+		return "", "", "", "", fmt.Errorf("constraint contains no limits")
+	}
+	return minStr, maxStr, minBr, maxBr, nil
+}
+
+func getRegexGroupMap(groups []string, regex *regexp.Regexp) map[string]string {
+	result := make(map[string]string)
+	for i, value := range regex.SubexpNames() {
+		if i != 0 && value != "" {
+			result[value] = groups[i]
+		}
+	}
+	return result
+}
+
 func checkPath(path string, dir bool) error {
 	file, err := os.Stat(path)
 	if err != nil {
diff --git a/vendor/github.com/bitrise-io/go-utils/sliceutil/sliceutil.go b/vendor/github.com/bitrise-io/go-utils/sliceutil/sliceutil.go
new file mode 100644
index 00000000..9f51cb50
--- /dev/null
+++ b/vendor/github.com/bitrise-io/go-utils/sliceutil/sliceutil.go
@@ -0,0 +1,32 @@
+package sliceutil
+
+// UniqueStringSlice - returns a cleaned up list,
+// where every item is unique.
+// Does NOT guarantee any ordering, the result can
+// be in any order!
+func UniqueStringSlice(strs []string) []string {
+	lookupMap := map[string]interface{}{}
+	for _, aStr := range strs {
+		lookupMap[aStr] = 1
+	}
+	uniqueStrs := []string{}
+	for k := range lookupMap {
+		uniqueStrs = append(uniqueStrs, k)
+	}
+	return uniqueStrs
+}
+
+// IndexOfStringInSlice ...
+func IndexOfStringInSlice(searchFor string, searchIn []string) int {
+	for idx, anItm := range searchIn {
+		if anItm == searchFor {
+			return idx
+		}
+	}
+	return -1
+}
+
+// IsStringInSlice ...
+func IsStringInSlice(searchFor string, searchIn []string) bool {
+	return IndexOfStringInSlice(searchFor, searchIn) >= 0
+}