Android Build Variant Creator

Main.java

package org.arxing.test;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.TreeMap;
import java.util.concurrent.TimeUnit;
import java.util.stream.Collectors;
import io.reactivex.Observable;

public class Main {

    public static void main(String[] args) {
        //排序渠道群組的索引
        Map<String, Integer> indexes = new HashMap<String, Integer>() {{
            put("index", 0);
            put("platform", 1);
            put("pattern", 2);
        }};

        //gradle 3.0開始 productFlavors強制要定義dimension 所以原本flavor從一維(flavor)提升為二維(dimension->flavor)
        Map<String, List<AndroidBean.Flavor>> productFlavors = new TreeMap<>(Comparator.comparingInt(indexes::get));
        //定義渠道群組:上架平台
        productFlavors.put("platform",
                           Arrays.asList(AndroidBean.Flavor.of("to360"), AndroidBean.Flavor.of("toGoogle"), AndroidBean.Flavor.of("toQQ")));
        //定義渠道群組:主題
        productFlavors.put("pattern", Arrays.asList(AndroidBean.Flavor.of("dark"), AndroidBean.Flavor.of("light")));
        //定義渠道群組:版型
        productFlavors.put("index", Arrays.asList(AndroidBean.Flavor.of("app1"), AndroidBean.Flavor.of("app2")));
        //定義建構類型
        List<AndroidBean.BuildType> buildTypes = new ArrayList<>(Arrays.asList(AndroidBean.BuildType.of("release"),
                                                                               AndroidBean.BuildType.of("debug")));

        //將渠道集合轉為二維
        Collection<List<AndroidBean.Flavor>> flavorGroups = productFlavors.values();
        //將每個渠道群組中的集合製成發射器
        List<Observable<AndroidBean.Flavor>> flavorObservables = new ArrayList<>();
        for (List<AndroidBean.Flavor> flavors : flavorGroups) {
            flavorObservables.add(Observable.fromIterable(flavors));
        }
        //定義渠道群組做笛卡爾積後的發射器 並將上面定義的發射器依序做join運算 最後結果為各個渠道群組中的集合的笛卡爾積
        Observable<List<AndroidBean.Flavor>> flavorGroupObservable = Observable.just(new ArrayList<>());
        for (Observable<AndroidBean.Flavor> observable : flavorObservables) {
            flavorGroupObservable = flavorGroupObservable.join(observable,
                                                               flavors -> Observable.just(flavors).delay(100, TimeUnit.MILLISECONDS),
                                                               Observable::just,
                                                               (f1, f2) -> {
                                                                   List<AndroidBean.Flavor> list = new ArrayList<>(f1);
                                                                   list.add(f2);
                                                                   return list;
                                                               });
        }
        //定義建構類型發射器
        Observable<AndroidBean.BuildType> buildTypeObservable = Observable.fromIterable(buildTypes);
        //將上面取得的渠道群組集合笛卡爾積再與每個建構類型做一次笛卡爾積 得到建構變數
        //(List<Flavor> + BuildType => Variant)
        Observable<Variant> variantObservable = flavorGroupObservable.join(buildTypeObservable,
                                                                           flavors -> Observable.just(flavors)
                                                                                                .delay(100, TimeUnit.MILLISECONDS),
                                                                           Observable::just,
                                                                           Variant::new);
        variantObservable.count().subscribe(s -> pln("得到 %d種結果", s));
        variantObservable.subscribe(variant -> pln(firstCharLower(variant.flavors.stream()
                                                                                 .map(flavor -> firstCharUpper(flavor.name))
                                                                                 .collect(Collectors.joining())
                                                                                 .concat(firstCharUpper(variant.buildType.name)))));
    }

    private static String firstCharUpper(String s) {
        return s.toUpperCase().charAt(0) + s.substring(1);
    }

    private static String firstCharLower(String s) {
        return s.toLowerCase().charAt(0) + s.substring(1);
    }

    private static void pln(String format, Object... objects) {
        System.out.println(String.format(format, objects));
    }

    public static class Variant {
        public List<AndroidBean.Flavor> flavors;
        public AndroidBean.BuildType buildType;

        public Variant(List<AndroidBean.Flavor> flavors, AndroidBean.BuildType buildType) {
            this.flavors = flavors;
            this.buildType = buildType;
        }
    }

    public static class AndroidBean {
        public List<String> flavorDimensions;
        public DefaultConfigBean defaultConfig;
        public List<AndroidBean.BuildType> buildTypes;
        public List<AndroidBean.Flavor> flavors;
        public Map<String, List<AndroidBean.Flavor>> flavorGroup;

        {
            flavorDimensions = new ArrayList<>();
            defaultConfig = new DefaultConfigBean();
            buildTypes = new ArrayList<>();
            flavors = new ArrayList<>();
            flavorGroup = new TreeMap<>(Comparator.comparingInt(o -> flavorDimensions.indexOf(o)));
        }

        public static class DefaultConfigBean {
            public String versionName;
        }

        public static class BuildType {
            public String name;

            public static AndroidBean.BuildType of(String name) {
                BuildType buildType = new AndroidBean.BuildType();
                buildType.name = name;
                return buildType;
            }
        }

        public static class Flavor {
            public String name;
            public String dimension;

            public static AndroidBean.Flavor of(String name) {
                AndroidBean.Flavor flavor = new AndroidBean.Flavor();
                flavor.name = name;
                return flavor;
            }
        }
    }
}

result.txt

得到 24種結果
app1To360DarkRelease
app2To360DarkRelease
app1ToGoogleDarkRelease
app2ToGoogleDarkRelease
app1ToQQDarkRelease
app2ToQQDarkRelease
app1To360LightRelease
app2To360LightRelease
app1ToGoogleLightRelease
app2ToGoogleLightRelease
app1ToQQLightRelease
app2ToQQLightRelease
app1To360DarkDebug
app2To360DarkDebug
app1ToGoogleDarkDebug
app2ToGoogleDarkDebug
app1ToQQDarkDebug
app2ToQQDarkDebug
app1To360LightDebug
app2To360LightDebug
app1ToGoogleLightDebug
app2ToGoogleLightDebug
app1ToQQLightDebug
app2ToQQLightDebug

Process finished with exit code 0