am 4dfff4e7: am 5fa90218: am f7ffcaa7: Merge "Build the split-select tool... (cdd11d7a) · Commits · e / os / android_frameworks_base

tools/aapt/AaptUtil.h

+37 −3

Original line number	Diff line number	Diff line
		@@ -14,9 +14,11 @@
		* limitations under the License.
		*/

		#ifndef __AAPT_UTIL_H
		#define __AAPT_UTIL_H
		#ifndef H_AAPT_UTIL
		#define H_AAPT_UTIL

		#include <utils/KeyedVector.h>
		#include <utils/SortedVector.h>
		#include <utils/String8.h>
		#include <utils/Vector.h>

		@@ -25,6 +27,38 @@ namespace AaptUtil {
		android::Vector<android::String8> split(const android::String8& str, const char sep);
		android::Vector<android::String8> splitAndLowerCase(const android::String8& str, const char sep);

		template <typename KEY, typename VALUE>
		void appendValue(android::KeyedVector<KEY, android::Vector<VALUE> >& keyedVector,
		const KEY& key, const VALUE& value);

		template <typename KEY, typename VALUE>
		void appendValue(android::KeyedVector<KEY, android::SortedVector<VALUE> >& keyedVector,
		const KEY& key, const VALUE& value);

		//
		// Implementations
		//

		template <typename KEY, typename VALUE>
		void appendValue(android::KeyedVector<KEY, android::Vector<VALUE> >& keyedVector,
		const KEY& key, const VALUE& value) {
		ssize_t idx = keyedVector.indexOfKey(key);
		if (idx < 0) {
		idx = keyedVector.add(key, android::Vector<VALUE>());
		}
		keyedVector.editValueAt(idx).add(value);
		}

		template <typename KEY, typename VALUE>
		void appendValue(android::KeyedVector<KEY, android::SortedVector<VALUE> >& keyedVector,
		const KEY& key, const VALUE& value) {
		ssize_t idx = keyedVector.indexOfKey(key);
		if (idx < 0) {
		idx = keyedVector.add(key, android::SortedVector<VALUE>());
		}
		keyedVector.editValueAt(idx).add(value);
		}

		} // namespace AaptUtil

		#endif // __AAPT_UTIL_H
		#endif // H_AAPT_UTIL

tools/split-select/Abi.cpp

+47 −31

Original line number	Diff line number	Diff line
		@@ -16,42 +16,58 @@

		#include "Abi.h"

		using namespace android;

		namespace split {
		namespace abi {

		static const std::vector<Variant> sNoneVariants = {};
		static const std::vector<Variant> sArmVariants =
		{Variant::armeabi, Variant::armeabi_v7a, Variant::arm64_v8a};
		static const std::vector<Variant> sIntelVariants = {Variant::x86, Variant::x86_64};
		static const std::vector<Variant> sMipsVariants = {Variant::mips, Variant::mips64};
		static Vector<Variant> buildVariants(Variant v1, Variant v2) {
		Vector<Variant> v;
		v.add(v1);
		v.add(v2);
		return v;
		}

		static Vector<Variant> buildVariants(Variant v1, Variant v2, Variant v3) {
		Vector<Variant> v;
		v.add(v1);
		v.add(v2);
		v.add(v3);
		return v;
		}

		static const Vector<Variant> sNoneVariants;
		static const Vector<Variant> sArmVariants = buildVariants(Variant_armeabi, Variant_armeabi_v7a, Variant_arm64_v8a);
		static const Vector<Variant> sIntelVariants = buildVariants(Variant_x86, Variant_x86_64);
		static const Vector<Variant> sMipsVariants = buildVariants(Variant_mips, Variant_mips64);

		Family getFamily(Variant variant) {
		switch (variant) {
		case Variant::none:
		return Family::none;
		case Variant::armeabi:
		case Variant::armeabi_v7a:
		case Variant::arm64_v8a:
		return Family::arm;
		case Variant::x86:
		case Variant::x86_64:
		return Family::intel;
		case Variant::mips:
		case Variant::mips64:
		return Family::mips;
		case Variant_none:
		return Family_none;
		case Variant_armeabi:
		case Variant_armeabi_v7a:
		case Variant_arm64_v8a:
		return Family_arm;
		case Variant_x86:
		case Variant_x86_64:
		return Family_intel;
		case Variant_mips:
		case Variant_mips64:
		return Family_mips;
		}
		return Family::none;
		return Family_none;
		}

		const std::vector<Variant>& getVariants(Family family) {
		const Vector<Variant>& getVariants(Family family) {
		switch (family) {
		case Family::none:
		case Family_none:
		return sNoneVariants;
		case Family::arm:
		case Family_arm:
		return sArmVariants;
		case Family::intel:
		case Family_intel:
		return sIntelVariants;
		case Family::mips:
		case Family_mips:
		return sMipsVariants;
		}
		return sNoneVariants;
		@@ -59,21 +75,21 @@ const std::vector<Variant>& getVariants(Family family) {

		const char* toString(Variant variant) {
		switch (variant) {
		case Variant::none:
		case Variant_none:
		return "";
		case Variant::armeabi:
		case Variant_armeabi:
		return "armeabi";
		case Variant::armeabi_v7a:
		case Variant_armeabi_v7a:
		return "armeabi-v7a";
		case Variant::arm64_v8a:
		case Variant_arm64_v8a:
		return "arm64-v8a";
		case Variant::x86:
		case Variant_x86:
		return "x86";
		case Variant::x86_64:
		case Variant_x86_64:
		return "x86_64";
		case Variant::mips:
		case Variant_mips:
		return "mips";
		case Variant::mips64:
		case Variant_mips64:
		return "mips64";
		}
		return "";

tools/split-select/Abi.h

+16 −16

Original line number	Diff line number	Diff line
		@@ -17,31 +17,31 @@
		#ifndef H_ANDROID_SPLIT_ABI
		#define H_ANDROID_SPLIT_ABI

		#include <vector>
		#include <utils/Vector.h>

		namespace split {
		namespace abi {

		enum class Variant {
		none = 0,
		armeabi,
		armeabi_v7a,
		arm64_v8a,
		x86,
		x86_64,
		mips,
		mips64,
		enum Variant {
		Variant_none = 0,
		Variant_armeabi,
		Variant_armeabi_v7a,
		Variant_arm64_v8a,
		Variant_x86,
		Variant_x86_64,
		Variant_mips,
		Variant_mips64,
		};

		enum class Family {
		none,
		arm,
		intel,
		mips,
		enum Family {
		Family_none,
		Family_arm,
		Family_intel,
		Family_mips,
		};

		Family getFamily(Variant variant);
		const std::vector<Variant>& getVariants(Family family);
		const android::Vector<Variant>& getVariants(Family family);
		const char* toString(Variant variant);

		} // namespace abi

tools/split-select/Android.mk

+1 −6

Original line number	Diff line number	Diff line
		@@ -17,10 +17,6 @@
		# This tool is prebuilt if we're doing an app-only build.
		ifeq ($(TARGET_BUILD_APPS)$(filter true,$(TARGET_BUILD_PDK)),)

		# TODO(adamlesinski): Enable OS X builds when I figure out how
		# to build with clang and libc++
		ifneq ($(HOST_OS),darwin)

		# ==========================================================
		# Setup some common variables for the different build
		# targets here.
		@@ -55,7 +51,7 @@ hostStaticLibs := \
		libexpat \
		libziparchive-host

		cFlags := -std=c++11 -Wall -Werror
		cFlags := -Wall -Werror

		ifeq ($(HOST_OS),linux)
		hostLdLibs += -lrt -ldl -lpthread
		@@ -115,5 +111,4 @@ LOCAL_CFLAGS += $(cFlags)

		include $(BUILD_HOST_EXECUTABLE)

		endif # Not OS X
		endif # No TARGET_BUILD_APPS or TARGET_BUILD_PDK

tools/split-select/Grouper.cpp

+10 −16

Original line number	Diff line number	Diff line
		@@ -16,25 +16,17 @@

		#include "Grouper.h"

		#include "aapt/AaptUtil.h"
		#include "SplitDescription.h"

		#include <utils/KeyedVector.h>
		#include <utils/Vector.h>

		using namespace android;
		using AaptUtil::appendValue;

		namespace split {

		template <typename Key, typename Value>
		static void addToVector(KeyedVector<Key, SortedVector<Value> >& group,
		const Key& key, const Value& value) {
		ssize_t idx = group.indexOfKey(key);
		if (idx < 0) {
		idx = group.add(key, SortedVector<Value>());
		}
		group.editValueAt(idx).add(value);
		}

		Vector<SortedVector<SplitDescription> >
		groupByMutualExclusivity(const Vector<SplitDescription>& splits) {
		Vector<SortedVector<SplitDescription> > groups;
		@@ -43,20 +35,22 @@ groupByMutualExclusivity(const Vector<SplitDescription>& splits) {
		KeyedVector<SplitDescription, SortedVector<SplitDescription> > densityGroups;
		KeyedVector<SplitDescription, SortedVector<SplitDescription> > abiGroups;
		KeyedVector<SplitDescription, SortedVector<SplitDescription> > localeGroups;
		for (const SplitDescription& split : splits) {
		const size_t splitCount = splits.size();
		for (size_t i = 0; i < splitCount; i++) {
		const SplitDescription& split = splits[i];
		if (split.config.density != 0) {
		SplitDescription key(split);
		key.config.density = 0;
		key.config.sdkVersion = 0; // Ignore density so we can support anydpi.
		addToVector(densityGroups, key, split);
		} else if (split.abi != abi::Variant::none) {
		appendValue(densityGroups, key, split);
		} else if (split.abi != abi::Variant_none) {
		SplitDescription key(split);
		key.abi = abi::Variant::none;
		addToVector(abiGroups, key, split);
		key.abi = abi::Variant_none;
		appendValue(abiGroups, key, split);
		} else if (split.config.locale != 0) {
		SplitDescription key(split);
		key.config.clearLocale();
		addToVector(localeGroups, key, split);
		appendValue(localeGroups, key, split);
		} else {
		groups.add();
		groups.editTop().add(split);