1 /* 2 * Copyright (C) 2014 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #include "RuleGenerator.h" 18 #include "aapt/SdkConstants.h" 19 20 #include <algorithm> 21 #include <cmath> 22 #include <vector> 23 #include <androidfw/ResourceTypes.h> 24 25 using namespace android; 26 27 namespace split { 28 29 // Calculate the point at which the density selection changes between l and h. findMid(int l,int h)30 static inline int findMid(int l, int h) { 31 double root = sqrt((h*h) + (8*l*h)); 32 return (double(-h) + root) / 2.0; 33 } 34 generateDensity(const Vector<int> & allDensities,size_t index)35 sp<Rule> RuleGenerator::generateDensity(const Vector<int>& allDensities, size_t index) { 36 if (allDensities[index] != ResTable_config::DENSITY_ANY) { 37 sp<Rule> densityRule = new Rule(); 38 densityRule->op = Rule::AND_SUBRULES; 39 40 const bool hasAnyDensity = std::find(allDensities.begin(), 41 allDensities.end(), (int) ResTable_config::DENSITY_ANY) != allDensities.end(); 42 43 if (hasAnyDensity) { 44 sp<Rule> version = new Rule(); 45 version->op = Rule::LESS_THAN; 46 version->key = Rule::SDK_VERSION; 47 version->longArgs.add((long) SDK_LOLLIPOP); 48 densityRule->subrules.add(version); 49 } 50 51 if (index > 0) { 52 sp<Rule> gt = new Rule(); 53 gt->op = Rule::GREATER_THAN; 54 gt->key = Rule::SCREEN_DENSITY; 55 gt->longArgs.add(findMid(allDensities[index - 1], allDensities[index]) - 1); 56 densityRule->subrules.add(gt); 57 } 58 59 if (index + 1 < allDensities.size() && allDensities[index + 1] != ResTable_config::DENSITY_ANY) { 60 sp<Rule> lt = new Rule(); 61 lt->op = Rule::LESS_THAN; 62 lt->key = Rule::SCREEN_DENSITY; 63 lt->longArgs.add(findMid(allDensities[index], allDensities[index + 1])); 64 densityRule->subrules.add(lt); 65 } 66 return densityRule; 67 } else { 68 // SDK_VERSION is handled elsewhere, so we always pick DENSITY_ANY if it's 69 // available. 70 sp<Rule> always = new Rule(); 71 always->op = Rule::ALWAYS_TRUE; 72 return always; 73 } 74 } 75 generateAbi(const Vector<abi::Variant> & splitAbis,size_t index)76 sp<Rule> RuleGenerator::generateAbi(const Vector<abi::Variant>& splitAbis, size_t index) { 77 const abi::Variant thisAbi = splitAbis[index]; 78 const Vector<abi::Variant>& familyVariants = abi::getVariants(abi::getFamily(thisAbi)); 79 80 Vector<abi::Variant>::const_iterator start = 81 std::find(familyVariants.begin(), familyVariants.end(), thisAbi); 82 83 Vector<abi::Variant>::const_iterator end = familyVariants.end(); 84 if (index + 1 < splitAbis.size()) { 85 end = std::find(start, familyVariants.end(), splitAbis[index + 1]); 86 } 87 88 sp<Rule> abiRule = new Rule(); 89 abiRule->op = Rule::CONTAINS_ANY; 90 abiRule->key = Rule::NATIVE_PLATFORM; 91 while (start != end) { 92 abiRule->stringArgs.add(String8(abi::toString(*start))); 93 ++start; 94 } 95 return abiRule; 96 } 97 generate(const SortedVector<SplitDescription> & group,size_t index)98 sp<Rule> RuleGenerator::generate(const SortedVector<SplitDescription>& group, size_t index) { 99 sp<Rule> rootRule = new Rule(); 100 rootRule->op = Rule::AND_SUBRULES; 101 102 if (group[index].config.locale != 0) { 103 sp<Rule> locale = new Rule(); 104 locale->op = Rule::EQUALS; 105 locale->key = Rule::LANGUAGE; 106 char str[RESTABLE_MAX_LOCALE_LEN]; 107 group[index].config.getBcp47Locale(str); 108 locale->stringArgs.add(String8(str)); 109 rootRule->subrules.add(locale); 110 } 111 112 if (group[index].config.sdkVersion != 0) { 113 sp<Rule> sdk = new Rule(); 114 sdk->op = Rule::GREATER_THAN; 115 sdk->key = Rule::SDK_VERSION; 116 sdk->longArgs.add(group[index].config.sdkVersion - 1); 117 rootRule->subrules.add(sdk); 118 } 119 120 if (group[index].config.density != 0) { 121 size_t densityIndex = 0; 122 Vector<int> allDensities; 123 allDensities.add(group[index].config.density); 124 125 const size_t groupSize = group.size(); 126 for (size_t i = 0; i < groupSize; i++) { 127 if (group[i].config.density != group[index].config.density) { 128 // This group differs by density. 129 allDensities.clear(); 130 for (size_t j = 0; j < groupSize; j++) { 131 allDensities.add(group[j].config.density); 132 } 133 densityIndex = index; 134 break; 135 } 136 } 137 rootRule->subrules.add(generateDensity(allDensities, densityIndex)); 138 } 139 140 if (group[index].abi != abi::Variant_none) { 141 size_t abiIndex = 0; 142 Vector<abi::Variant> allVariants; 143 allVariants.add(group[index].abi); 144 145 const size_t groupSize = group.size(); 146 for (size_t i = 0; i < groupSize; i++) { 147 if (group[i].abi != group[index].abi) { 148 // This group differs by ABI. 149 allVariants.clear(); 150 for (size_t j = 0; j < groupSize; j++) { 151 allVariants.add(group[j].abi); 152 } 153 abiIndex = index; 154 break; 155 } 156 } 157 rootRule->subrules.add(generateAbi(allVariants, abiIndex)); 158 } 159 160 return rootRule; 161 } 162 163 } // namespace split 164