forked from openkylin/platform_build
828 lines
34 KiB
Makefile
828 lines
34 KiB
Makefile
# Target Java.
|
|
# Requires:
|
|
# LOCAL_MODULE_SUFFIX
|
|
# LOCAL_MODULE_CLASS
|
|
# all_res_assets
|
|
|
|
ifeq ($(TARGET_BUILD_PDK),true)
|
|
ifeq ($(TARGET_BUILD_PDK_JAVA_PLATFORM),)
|
|
# LOCAL_SDK not defined or set to current
|
|
ifeq ($(filter-out current,$(LOCAL_SDK_VERSION)),)
|
|
ifneq ($(LOCAL_NO_STANDARD_LIBRARIES),true)
|
|
LOCAL_SDK_VERSION := $(PDK_BUILD_SDK_VERSION)
|
|
endif #!LOCAL_NO_STANDARD_LIBRARIES
|
|
endif
|
|
endif # !PDK_JAVA
|
|
endif #PDK
|
|
|
|
LOCAL_NO_STANDARD_LIBRARIES:=$(strip $(LOCAL_NO_STANDARD_LIBRARIES))
|
|
LOCAL_SDK_VERSION:=$(strip $(LOCAL_SDK_VERSION))
|
|
|
|
proto_sources := $(filter %.proto,$(LOCAL_SRC_FILES))
|
|
ifneq ($(proto_sources),)
|
|
ifeq ($(LOCAL_PROTOC_OPTIMIZE_TYPE),micro)
|
|
LOCAL_STATIC_JAVA_LIBRARIES += libprotobuf-java-micro
|
|
else
|
|
ifeq ($(LOCAL_PROTOC_OPTIMIZE_TYPE),nano)
|
|
LOCAL_STATIC_JAVA_LIBRARIES += libprotobuf-java-nano
|
|
else
|
|
ifeq ($(LOCAL_PROTOC_OPTIMIZE_TYPE),stream)
|
|
# No library for stream protobufs
|
|
else
|
|
LOCAL_STATIC_JAVA_LIBRARIES += libprotobuf-java-lite
|
|
endif
|
|
endif
|
|
endif
|
|
endif
|
|
|
|
# LOCAL_STATIC_JAVA_AAR_LIBRARIES and LOCAL_STATIC_ANDROID_LIBRARIES are also LOCAL_STATIC_JAVA_LIBRARIES.
|
|
LOCAL_STATIC_JAVA_LIBRARIES := $(strip $(LOCAL_STATIC_JAVA_LIBRARIES) \
|
|
$(LOCAL_STATIC_JAVA_AAR_LIBRARIES) \
|
|
$(LOCAL_STATIC_ANDROID_LIBRARIES))
|
|
# LOCAL_SHARED_ANDROID_LIBRARIES are also LOCAL_JAVA_LIBRARIES.
|
|
LOCAL_JAVA_LIBRARIES := $(sort $(LOCAL_JAVA_LIBRARIES) $(LOCAL_SHARED_ANDROID_LIBRARIES))
|
|
|
|
LOCAL_BUILT_MODULE_STEM := $(strip $(LOCAL_BUILT_MODULE_STEM))
|
|
ifeq ($(LOCAL_BUILT_MODULE_STEM),)
|
|
$(error $(LOCAL_PATH): Target java template must define LOCAL_BUILT_MODULE_STEM)
|
|
endif
|
|
ifneq ($(filter classes-compiled.jar classes.jar,$(LOCAL_BUILT_MODULE_STEM)),)
|
|
$(error LOCAL_BUILT_MODULE_STEM may not be "$(LOCAL_BUILT_MODULE_STEM)")
|
|
endif
|
|
|
|
|
|
##############################################################################
|
|
# Define the intermediate targets before including base_rules so they get
|
|
# the correct environment.
|
|
##############################################################################
|
|
|
|
intermediates := $(call local-intermediates-dir)
|
|
intermediates.COMMON := $(call local-intermediates-dir,COMMON)
|
|
|
|
ifeq ($(LOCAL_PROGUARD_ENABLED),disabled)
|
|
LOCAL_PROGUARD_ENABLED :=
|
|
endif
|
|
|
|
full_classes_turbine_jar := $(intermediates.COMMON)/classes-turbine.jar
|
|
full_classes_header_jarjar := $(intermediates.COMMON)/classes-header-jarjar.jar
|
|
full_classes_header_jar := $(intermediates.COMMON)/classes-header.jar
|
|
full_classes_compiled_jar := $(intermediates.COMMON)/classes-full-debug.jar
|
|
full_classes_processed_jar := $(intermediates.COMMON)/classes-processed.jar
|
|
full_classes_desugar_jar := $(intermediates.COMMON)/classes-desugar.jar
|
|
full_classes_jarjar_jar := $(intermediates.COMMON)/classes-jarjar.jar
|
|
full_classes_proguard_jar := $(intermediates.COMMON)/classes-proguard.jar
|
|
full_classes_combined_jar := $(intermediates.COMMON)/classes-combined.jar
|
|
built_dex_intermediate := $(intermediates.COMMON)/dex/classes.dex
|
|
full_classes_stubs_jar := $(intermediates.COMMON)/stubs.jar
|
|
java_source_list_file := $(intermediates.COMMON)/java-source-list
|
|
|
|
|
|
ifeq ($(LOCAL_MODULE_CLASS)$(LOCAL_SRC_FILES)$(LOCAL_STATIC_JAVA_LIBRARIES)$(LOCAL_SOURCE_FILES_ALL_GENERATED),APPS)
|
|
# If this is an apk without any Java code (e.g. framework-res), we should skip compiling Java.
|
|
full_classes_jar :=
|
|
built_dex :=
|
|
else
|
|
full_classes_jar := $(intermediates.COMMON)/classes.jar
|
|
built_dex := $(intermediates.COMMON)/classes.dex
|
|
endif
|
|
|
|
LOCAL_INTERMEDIATE_TARGETS += \
|
|
$(full_classes_turbine_jar) \
|
|
$(full_classes_compiled_jar) \
|
|
$(full_classes_desugar_jar) \
|
|
$(full_classes_jarjar_jar) \
|
|
$(full_classes_jar) \
|
|
$(full_classes_combined_jar) \
|
|
$(full_classes_proguard_jar) \
|
|
$(built_dex_intermediate) \
|
|
$(built_dex) \
|
|
$(full_classes_stubs_jar) \
|
|
$(java_source_list_file)
|
|
|
|
LOCAL_INTERMEDIATE_SOURCE_DIR := $(intermediates.COMMON)/src
|
|
|
|
###############################################################
|
|
## .rs files: RenderScript sources to .java files and .bc files
|
|
## .fs files: Filterscript sources to .java files and .bc files
|
|
###############################################################
|
|
renderscript_sources := $(filter %.rs %.fs,$(LOCAL_SRC_FILES))
|
|
# Because names of the java files from RenderScript are unknown until the
|
|
# .rs file(s) are compiled, we have to depend on a timestamp file.
|
|
RenderScript_file_stamp :=
|
|
rs_generated_res_dir :=
|
|
rs_compatibility_jni_libs :=
|
|
ifneq ($(renderscript_sources),)
|
|
renderscript_sources_fullpath := $(addprefix $(LOCAL_PATH)/, $(renderscript_sources))
|
|
RenderScript_file_stamp := $(LOCAL_INTERMEDIATE_SOURCE_DIR)/RenderScript.stamp
|
|
renderscript_intermediate.COMMON := $(intermediates.COMMON)/renderscript
|
|
|
|
# Defaulting to an empty string uses the latest available platform SDK.
|
|
renderscript_target_api :=
|
|
|
|
ifneq (,$(LOCAL_RENDERSCRIPT_TARGET_API))
|
|
renderscript_target_api := $(LOCAL_RENDERSCRIPT_TARGET_API)
|
|
else
|
|
ifneq (,$(LOCAL_SDK_VERSION))
|
|
# Set target-api for LOCAL_SDK_VERSIONs other than current.
|
|
ifneq (,$(filter-out current system_current test_current, $(LOCAL_SDK_VERSION)))
|
|
renderscript_target_api := $(call get-numeric-sdk-version,$(LOCAL_SDK_VERSION))
|
|
endif
|
|
endif # LOCAL_SDK_VERSION is set
|
|
endif # LOCAL_RENDERSCRIPT_TARGET_API is set
|
|
|
|
# For 64-bit, we always have to upgrade to at least 21 for compat build.
|
|
ifneq ($(LOCAL_RENDERSCRIPT_COMPATIBILITY),)
|
|
ifeq ($(TARGET_IS_64_BIT),true)
|
|
ifneq ($(filter $(RSCOMPAT_32BIT_ONLY_API_LEVELS),$(renderscript_target_api)),)
|
|
renderscript_target_api := 21
|
|
endif
|
|
endif
|
|
endif
|
|
|
|
ifeq ($(LOCAL_RENDERSCRIPT_CC),)
|
|
LOCAL_RENDERSCRIPT_CC := $(LLVM_RS_CC)
|
|
endif
|
|
|
|
# Turn on all warnings and warnings as errors for RS compiles.
|
|
# This can be disabled with LOCAL_RENDERSCRIPT_FLAGS := -Wno-error
|
|
renderscript_flags := -Wall -Werror
|
|
renderscript_flags += $(LOCAL_RENDERSCRIPT_FLAGS)
|
|
|
|
# prepend the RenderScript system include path
|
|
ifneq ($(filter-out current system_current test_current,$(LOCAL_SDK_VERSION))$(if $(TARGET_BUILD_APPS),$(filter current system_current test_current,$(LOCAL_SDK_VERSION))),)
|
|
# if a numeric LOCAL_SDK_VERSION, or current LOCAL_SDK_VERSION with TARGET_BUILD_APPS
|
|
LOCAL_RENDERSCRIPT_INCLUDES := \
|
|
$(HISTORICAL_SDK_VERSIONS_ROOT)/renderscript/clang-include \
|
|
$(HISTORICAL_SDK_VERSIONS_ROOT)/renderscript/include \
|
|
$(LOCAL_RENDERSCRIPT_INCLUDES)
|
|
else
|
|
LOCAL_RENDERSCRIPT_INCLUDES := \
|
|
$(TOPDIR)external/clang/lib/Headers \
|
|
$(TOPDIR)frameworks/rs/script_api/include \
|
|
$(LOCAL_RENDERSCRIPT_INCLUDES)
|
|
endif
|
|
|
|
ifneq ($(LOCAL_RENDERSCRIPT_INCLUDES_OVERRIDE),)
|
|
LOCAL_RENDERSCRIPT_INCLUDES := $(LOCAL_RENDERSCRIPT_INCLUDES_OVERRIDE)
|
|
endif
|
|
|
|
bc_files := $(patsubst %.fs,%.bc, $(patsubst %.rs,%.bc, $(notdir $(renderscript_sources))))
|
|
bc_dep_files := $(addprefix $(renderscript_intermediate.COMMON)/,$(patsubst %.bc,%.d,$(bc_files)))
|
|
|
|
$(RenderScript_file_stamp): PRIVATE_RS_INCLUDES := $(LOCAL_RENDERSCRIPT_INCLUDES)
|
|
$(RenderScript_file_stamp): PRIVATE_RS_CC := $(LOCAL_RENDERSCRIPT_CC)
|
|
$(RenderScript_file_stamp): PRIVATE_RS_FLAGS := $(renderscript_flags)
|
|
$(RenderScript_file_stamp): PRIVATE_RS_SOURCE_FILES := $(renderscript_sources_fullpath)
|
|
# By putting the generated java files into $(LOCAL_INTERMEDIATE_SOURCE_DIR), they will be
|
|
# automatically found by the java compiling function transform-java-to-classes.jar.
|
|
$(RenderScript_file_stamp): PRIVATE_RS_OUTPUT_DIR := $(renderscript_intermediate.COMMON)
|
|
$(RenderScript_file_stamp): PRIVATE_RS_TARGET_API := $(renderscript_target_api)
|
|
$(RenderScript_file_stamp): PRIVATE_DEP_FILES := $(bc_dep_files)
|
|
$(RenderScript_file_stamp): $(renderscript_sources_fullpath) $(LOCAL_RENDERSCRIPT_CC)
|
|
$(transform-renderscripts-to-java-and-bc)
|
|
|
|
# include the dependency files (.d/.P) generated by llvm-rs-cc.
|
|
$(call include-depfile,$(RenderScript_file_stamp).P,$(RenderScript_file_stamp))
|
|
|
|
ifneq ($(LOCAL_RENDERSCRIPT_COMPATIBILITY),)
|
|
|
|
|
|
ifeq ($(filter $(RSCOMPAT_32BIT_ONLY_API_LEVELS),$(renderscript_target_api)),)
|
|
ifeq ($(TARGET_IS_64_BIT),true)
|
|
renderscript_intermediate.bc_folder := $(renderscript_intermediate.COMMON)/res/raw/bc64/
|
|
else
|
|
renderscript_intermediate.bc_folder := $(renderscript_intermediate.COMMON)/res/raw/bc32/
|
|
endif
|
|
else
|
|
renderscript_intermediate.bc_folder := $(renderscript_intermediate.COMMON)/res/raw/
|
|
endif
|
|
|
|
rs_generated_bc := $(addprefix \
|
|
$(renderscript_intermediate.bc_folder), $(bc_files))
|
|
|
|
renderscript_intermediate := $(intermediates)/renderscript
|
|
|
|
# We don't need the .so files in bundled branches
|
|
# Prevent these from showing up on the device
|
|
# One exception is librsjni.so, which is needed for
|
|
# both native path and compat path.
|
|
rs_jni_lib := $(TARGET_OUT_INTERMEDIATE_LIBRARIES)/librsjni.so
|
|
LOCAL_JNI_SHARED_LIBRARIES += librsjni
|
|
|
|
ifneq (,$(TARGET_BUILD_APPS)$(FORCE_BUILD_RS_COMPAT))
|
|
|
|
rs_compatibility_jni_libs := $(addprefix \
|
|
$(renderscript_intermediate)/librs., \
|
|
$(patsubst %.bc,%.so, $(bc_files)))
|
|
|
|
$(rs_generated_bc) : $(RenderScript_file_stamp)
|
|
|
|
rs_support_lib := $(TARGET_OUT_INTERMEDIATE_LIBRARIES)/libRSSupport.so
|
|
LOCAL_JNI_SHARED_LIBRARIES += libRSSupport
|
|
|
|
rs_support_io_lib :=
|
|
# check if the target api level support USAGE_IO
|
|
ifeq ($(filter $(RSCOMPAT_NO_USAGEIO_API_LEVELS),$(renderscript_target_api)),)
|
|
rs_support_io_lib := $(TARGET_OUT_INTERMEDIATE_LIBRARIES)/libRSSupportIO.so
|
|
LOCAL_JNI_SHARED_LIBRARIES += libRSSupportIO
|
|
endif
|
|
|
|
my_arch := $(TARGET_$(LOCAL_2ND_ARCH_VAR_PREFIX)ARCH)
|
|
ifneq (,$(filter arm64 mips64 x86_64,$(my_arch)))
|
|
my_min_sdk_version := 21
|
|
else
|
|
my_min_sdk_version := $(MIN_SUPPORTED_SDK_VERSION)
|
|
endif
|
|
|
|
$(rs_compatibility_jni_libs): $(RenderScript_file_stamp) $(RS_PREBUILT_CLCORE) \
|
|
$(rs_support_lib) $(rs_support_io_lib) $(rs_jni_lib) $(rs_compiler_rt)
|
|
$(rs_compatibility_jni_libs): $(BCC_COMPAT)
|
|
$(rs_compatibility_jni_libs): PRIVATE_CXX := $(CXX_WRAPPER) $(TARGET_CXX)
|
|
$(rs_compatibility_jni_libs): PRIVATE_SDK_VERSION := $(my_min_sdk_version)
|
|
$(rs_compatibility_jni_libs): $(renderscript_intermediate)/librs.%.so: \
|
|
$(renderscript_intermediate.bc_folder)%.bc \
|
|
$(SOONG_OUT_DIR)/ndk.timestamp
|
|
$(transform-bc-to-so)
|
|
|
|
endif
|
|
|
|
endif
|
|
|
|
LOCAL_INTERMEDIATE_TARGETS += $(RenderScript_file_stamp)
|
|
# Make sure the generated resource will be added to the apk.
|
|
rs_generated_res_dir := $(renderscript_intermediate.COMMON)/res
|
|
LOCAL_RESOURCE_DIR := $(rs_generated_res_dir) $(LOCAL_RESOURCE_DIR)
|
|
endif
|
|
|
|
|
|
###########################################################
|
|
## AIDL: Compile .aidl files to .java
|
|
###########################################################
|
|
aidl_sources := $(filter %.aidl,$(LOCAL_SRC_FILES))
|
|
aidl_java_sources :=
|
|
|
|
ifneq ($(strip $(aidl_sources)),)
|
|
|
|
aidl_preprocess_import :=
|
|
ifdef LOCAL_SDK_VERSION
|
|
ifneq ($(filter current system_current test_current, $(LOCAL_SDK_VERSION)$(TARGET_BUILD_APPS)),)
|
|
# LOCAL_SDK_VERSION is current and no TARGET_BUILD_APPS
|
|
aidl_preprocess_import := $(TARGET_OUT_COMMON_INTERMEDIATES)/framework.aidl
|
|
else
|
|
aidl_preprocess_import := $(HISTORICAL_SDK_VERSIONS_ROOT)/$(LOCAL_SDK_VERSION)/framework.aidl
|
|
endif # not current or system_current
|
|
else
|
|
# build against the platform.
|
|
LOCAL_AIDL_INCLUDES += $(FRAMEWORKS_BASE_JAVA_SRC_DIRS)
|
|
endif # LOCAL_SDK_VERSION
|
|
|
|
$(foreach s,$(aidl_sources),\
|
|
$(eval $(call define-aidl-java-rule,$(s),$(intermediates.COMMON)/aidl,aidl_java_sources)))
|
|
$(foreach java,$(aidl_java_sources), \
|
|
$(call include-depfile,$(java:%.java=%.P),$(java)))
|
|
|
|
$(aidl_java_sources) : $(LOCAL_ADDITIONAL_DEPENDENCIES) $(aidl_preprocess_import)
|
|
|
|
$(aidl_java_sources): PRIVATE_AIDL_FLAGS := -b $(addprefix -p,$(aidl_preprocess_import)) -I$(LOCAL_PATH) -I$(LOCAL_PATH)/src $(addprefix -I,$(LOCAL_AIDL_INCLUDES))
|
|
$(aidl_java_sources): PRIVATE_MODULE := $(LOCAL_MODULE)
|
|
|
|
endif
|
|
|
|
##########################################
|
|
|
|
# All of the rules after full_classes_compiled_jar are very unlikely
|
|
# to fail except for bugs in their respective tools. If you would
|
|
# like to run these rules, add the "all" modifier goal to the make
|
|
# command line.
|
|
ifndef LOCAL_CHECKED_MODULE
|
|
ifdef full_classes_jar
|
|
LOCAL_CHECKED_MODULE := $(full_classes_compiled_jar)
|
|
endif
|
|
endif
|
|
|
|
#######################################
|
|
include $(BUILD_SYSTEM)/base_rules.mk
|
|
#######################################
|
|
|
|
###########################################################
|
|
## logtags: emit java source
|
|
###########################################################
|
|
ifneq ($(strip $(logtags_sources)),)
|
|
|
|
logtags_java_sources := $(patsubst %.logtags,%.java,$(addprefix $(intermediates.COMMON)/logtags/, $(logtags_sources)))
|
|
logtags_sources := $(addprefix $(LOCAL_PATH)/, $(logtags_sources))
|
|
|
|
$(logtags_java_sources): PRIVATE_MERGED_TAG := $(TARGET_OUT_COMMON_INTERMEDIATES)/all-event-log-tags.txt
|
|
$(logtags_java_sources): $(intermediates.COMMON)/logtags/%.java: $(LOCAL_PATH)/%.logtags $(TARGET_OUT_COMMON_INTERMEDIATES)/all-event-log-tags.txt $(JAVATAGS) build/make/tools/event_log_tags.py
|
|
$(transform-logtags-to-java)
|
|
|
|
else
|
|
logtags_java_sources :=
|
|
endif
|
|
|
|
##########################################
|
|
java_sources := $(addprefix $(LOCAL_PATH)/, $(filter %.java,$(LOCAL_SRC_FILES))) $(aidl_java_sources) $(logtags_java_sources) \
|
|
$(filter %.java,$(LOCAL_GENERATED_SOURCES))
|
|
java_intermediate_sources := $(addprefix $(TARGET_OUT_COMMON_INTERMEDIATES)/, $(filter %.java,$(LOCAL_INTERMEDIATE_SOURCES)))
|
|
all_java_sources := $(java_sources) $(java_intermediate_sources)
|
|
|
|
enable_sharding :=
|
|
ifneq ($(TURBINE_ENABLED),false)
|
|
ifneq ($(LOCAL_JAVAC_SHARD_SIZE),)
|
|
ifneq ($(LOCAL_JAR_PROCESSOR),)
|
|
$(call pretty-error,Cannot set both LOCAL_JAVAC_SHARD_SIZE and LOCAL_JAR_PROCESSOR!)
|
|
endif # LOCAL_JAR_PROCESSOR is not empty
|
|
enable_sharding := true
|
|
|
|
num_shards := $(call int_divide,$(words $(java_sources)),$(LOCAL_JAVAC_SHARD_SIZE))
|
|
ifneq ($(words $(java_sources)),$(call int_multiply,$(LOCAL_JAVAC_SHARD_SIZE),$(num_shards)))
|
|
# increment number of shards by 1.
|
|
num_shards := $(call int_plus,$(num_shards),1)
|
|
endif
|
|
|
|
shard_idx_list := $(call int_range_list,1,$(num_shards))
|
|
sharded_java_source_list_files += $(foreach x,$(shard_idx_list),$(java_source_list_file).shard.$(x))
|
|
sharded_jar_list += $(foreach x,$(shard_idx_list),$(full_classes_compiled_jar).shard.$(x))
|
|
|
|
# always put dynamically-located .java files (generated by Proto/resource, etc) in a new final shard.
|
|
# increment number of shards by 1.
|
|
num_shards := $(call int_plus,$(num_shards),1)
|
|
sharded_java_source_list_files += $(java_source_list_file).shard.$(num_shards)
|
|
sharded_jar_list += $(full_classes_compiled_jar).shard.$(num_shards)
|
|
LOCAL_INTERMEDIATE_TARGETS += $(sharded_java_source_list_files)
|
|
LOCAL_INTERMEDIATE_TARGETS += $(sharded_jar_list)
|
|
endif # LOCAL_JAVAC_SHARD_SIZE is not empty
|
|
endif # TURBINE_ENABLED != false
|
|
|
|
include $(BUILD_SYSTEM)/java_common.mk
|
|
|
|
$(LOCAL_INTERMEDIATE_TARGETS): PRIVATE_HAS_RS_SOURCES := $(if $(renderscript_sources),true)
|
|
$(LOCAL_INTERMEDIATE_TARGETS): PRIVATE_RS_SOURCE_INTERMEDIATES_DIR := $(intermediates.COMMON)/renderscript
|
|
|
|
# Set the profile source so that the odex / profile code included from java.mk
|
|
# can find it.
|
|
#
|
|
# TODO: b/64896089, this is broken when called from package_internal.mk, since the file
|
|
# we preopt from is a temporary file. This will be addressed in a follow up, possibly
|
|
# by disabling stripping for profile guided preopt (which may be desirable for other
|
|
# reasons anyway).
|
|
#
|
|
# Note that we set this only when called from package_internal.mk and not in other cases.
|
|
ifneq (,$(called_from_package_internal)
|
|
dex_preopt_profile_src_file := $(LOCAL_BUILT_MODULE)
|
|
endif
|
|
|
|
#######################################
|
|
# defines built_odex along with rule to install odex
|
|
include $(BUILD_SYSTEM)/dex_preopt_odex_install.mk
|
|
#######################################
|
|
|
|
# Make sure there's something to build.
|
|
ifdef full_classes_jar
|
|
ifndef need_compile_java
|
|
$(error $(LOCAL_PATH): Target java module does not define any source or resource files)
|
|
endif
|
|
endif
|
|
|
|
# Since we're using intermediates.COMMON, make sure that it gets cleaned
|
|
# properly.
|
|
$(cleantarget): PRIVATE_CLEAN_FILES += $(intermediates.COMMON)
|
|
|
|
ifdef full_classes_jar
|
|
|
|
# Droiddoc isn't currently able to generate stubs for modules, so we're just
|
|
# allowing it to use the classes.jar as the "stubs" that would be use to link
|
|
# against, for the cases where someone needs the jar to link against.
|
|
$(eval $(call copy-one-file,$(full_classes_jar),$(full_classes_stubs_jar)))
|
|
ALL_MODULES.$(LOCAL_MODULE).STUBS := $(full_classes_stubs_jar)
|
|
|
|
# The layers file allows you to enforce a layering between java packages.
|
|
# Run build/make/tools/java-layers.py for more details.
|
|
layers_file := $(addprefix $(LOCAL_PATH)/, $(LOCAL_JAVA_LAYERS_FILE))
|
|
$(full_classes_compiled_jar): PRIVATE_JAVA_LAYERS_FILE := $(layers_file)
|
|
$(full_classes_compiled_jar): PRIVATE_WARNINGS_ENABLE := $(LOCAL_WARNINGS_ENABLE)
|
|
|
|
# Compile the java files to a .jar file.
|
|
# This intentionally depends on java_sources, not all_java_sources.
|
|
# Deps for generated source files must be handled separately,
|
|
# via deps on the target that generates the sources.
|
|
|
|
# If error prone is enabled then add LOCAL_ERROR_PRONE_FLAGS to LOCAL_JAVACFLAGS
|
|
ifeq ($(RUN_ERROR_PRONE),true)
|
|
LOCAL_JAVACFLAGS += $(LOCAL_ERROR_PRONE_FLAGS)
|
|
endif
|
|
|
|
# For user / userdebug builds, strip the local variable table and the local variable
|
|
# type table. This has no bearing on stack traces, but will leave less information
|
|
# available via JDWP.
|
|
ifneq (,$(PRODUCT_MINIMIZE_JAVA_DEBUG_INFO))
|
|
ifneq (,$(filter userdebug user,$(TARGET_BUILD_VARIANT)))
|
|
LOCAL_JAVACFLAGS+= -g:source,lines
|
|
endif
|
|
endif
|
|
|
|
# List of dependencies for anything that needs all java sources in place
|
|
java_sources_deps := \
|
|
$(java_sources) \
|
|
$(java_resource_sources) \
|
|
$(RenderScript_file_stamp) \
|
|
$(proto_java_sources_file_stamp) \
|
|
$(LOCAL_ADDITIONAL_DEPENDENCIES)
|
|
|
|
$(java_source_list_file): $(java_sources_deps)
|
|
$(write-java-source-list)
|
|
|
|
ifdef enable_sharding
|
|
$(foreach x,$(shard_idx_list),\
|
|
$(eval $(call save-sharded-java-source-list,$(x),\
|
|
$(wordlist $(call int_plus,1,$(call int_multiply,$(LOCAL_JAVAC_SHARD_SIZE),$(call int_subtract,$(x),1))),\
|
|
$(call int_multiply,$(LOCAL_JAVAC_SHARD_SIZE),$(x)),$(sort $(java_sources))))))
|
|
|
|
# always put dynamically-located .java files (generated by Proto/resource, etc) in a new final shard.
|
|
$(java_source_list_file).shard.$(num_shards): PRIVATE_JAVA_INTERMEDIATE_SOURCES := $(java_intermediate_sources)
|
|
$(java_source_list_file).shard.$(num_shards): $(java_resource_sources) \
|
|
$(RenderScript_file_stamp) \
|
|
$(proto_java_sources_file_stamp) \
|
|
$(LOCAL_ADDITIONAL_DEPENDENCIES) \
|
|
$(NORMALIZE_PATH)
|
|
$(hide) rm -f $@
|
|
$(call dump-words-to-file,$(PRIVATE_JAVA_INTERMEDIATE_SOURCES),$@.tmp)
|
|
$(call fetch-additional-java-source,$@.tmp)
|
|
$(hide) tr ' ' '\n' < $@.tmp | $(NORMALIZE_PATH) | sort -u > $@
|
|
|
|
# Javac sharding with header libs including its own header jar as one of dependency.
|
|
$(foreach x,$(shard_idx_list),\
|
|
$(eval $(call create-classes-full-debug.jar,$(full_classes_compiled_jar).shard.$(x),\
|
|
$(java_source_list_file).shard.$(x),\
|
|
$(full_java_header_libs) $(full_classes_header_jar),$(x),\
|
|
$(wordlist $(call int_plus,1,$(call int_multiply,$(LOCAL_JAVAC_SHARD_SIZE),$(call int_subtract,$(x),1))),\
|
|
$(call int_multiply,$(LOCAL_JAVAC_SHARD_SIZE),$(x)),$(sort $(java_sources))))))
|
|
|
|
# Javac sharding for last shard with additional Java dependencies.
|
|
$(eval $(call create-classes-full-debug.jar,$(full_classes_compiled_jar).shard.$(num_shards),\
|
|
$(java_source_list_file).shard.$(num_shards),$(full_java_header_libs) $(full_classes_header_jar),$(strip \
|
|
$(num_shards)),$$(java_resource_sources) $$(RenderScript_file_stamp) \
|
|
$$(proto_java_sources_file_stamp) $$(LOCAL_ADDITIONAL_DEPENDENCIES)))
|
|
|
|
$(full_classes_compiled_jar): PRIVATE_SHARDED_JAR_LIST := $(sharded_jar_list)
|
|
$(full_classes_compiled_jar): $(sharded_jar_list) | $(MERGE_ZIPS)
|
|
$(MERGE_ZIPS) -j $@ $(PRIVATE_SHARDED_JAR_LIST)
|
|
else
|
|
# we can't use single $ for java_sources_deps since it may contain hash '#' sign.
|
|
$(eval $(call create-classes-full-debug.jar,$(full_classes_compiled_jar),\
|
|
$(java_source_list_file),$(full_java_header_libs),,$$(java_sources_deps)))
|
|
|
|
endif # ifdef enable_sharding
|
|
|
|
ifneq ($(TURBINE_ENABLED),false)
|
|
|
|
$(full_classes_turbine_jar): PRIVATE_JAVACFLAGS := $(LOCAL_JAVACFLAGS) $(annotation_processor_flags)
|
|
$(full_classes_turbine_jar): PRIVATE_DONT_DELETE_JAR_META_INF := $(LOCAL_DONT_DELETE_JAR_META_INF)
|
|
$(full_classes_turbine_jar): \
|
|
$(java_source_list_file) \
|
|
$(java_sources_deps) \
|
|
$(full_java_header_libs) \
|
|
$(full_java_bootclasspath_libs) \
|
|
$(full_java_system_modules_deps) \
|
|
$(NORMALIZE_PATH) \
|
|
$(JAR_ARGS) \
|
|
$(ZIPTIME) \
|
|
| $(TURBINE) \
|
|
$(MERGE_ZIPS)
|
|
$(transform-java-to-header.jar)
|
|
|
|
.KATI_RESTAT: $(full_classes_turbine_jar)
|
|
|
|
# Run jarjar before generate classes-header.jar if necessary.
|
|
ifneq ($(strip $(LOCAL_JARJAR_RULES)),)
|
|
$(full_classes_header_jarjar): PRIVATE_JARJAR_RULES := $(LOCAL_JARJAR_RULES)
|
|
$(full_classes_header_jarjar): $(full_classes_turbine_jar) $(LOCAL_JARJAR_RULES) | $(JARJAR)
|
|
@echo Header JarJar: $@
|
|
$(hide) $(JAVA) -jar $(JARJAR) process $(PRIVATE_JARJAR_RULES) $< $@
|
|
else
|
|
full_classes_header_jarjar := $(full_classes_turbine_jar)
|
|
endif
|
|
|
|
$(eval $(call copy-one-file,$(full_classes_header_jarjar),$(full_classes_header_jar)))
|
|
|
|
endif # TURBINE_ENABLED != false
|
|
|
|
javac-check : $(full_classes_compiled_jar)
|
|
javac-check-$(LOCAL_MODULE) : $(full_classes_compiled_jar)
|
|
|
|
$(full_classes_combined_jar): PRIVATE_DONT_DELETE_JAR_META_INF := $(LOCAL_DONT_DELETE_JAR_META_INF)
|
|
$(full_classes_combined_jar): $(full_classes_compiled_jar) \
|
|
$(jar_manifest_file) \
|
|
$(full_static_java_libs) | $(MERGE_ZIPS)
|
|
$(if $(PRIVATE_JAR_MANIFEST), $(hide) sed -e "s/%BUILD_NUMBER%/$(BUILD_NUMBER_FROM_FILE)/" \
|
|
$(PRIVATE_JAR_MANIFEST) > $(dir $@)/manifest.mf)
|
|
$(MERGE_ZIPS) -j $(if $(PRIVATE_JAR_MANIFEST),-m $(dir $@)/manifest.mf) \
|
|
$(if $(PRIVATE_DONT_DELETE_JAR_META_INF),,-stripDir META-INF -zipToNotStrip $<) \
|
|
$@ $< $(call reverse-list,$(PRIVATE_STATIC_JAVA_LIBRARIES))
|
|
|
|
ifdef LOCAL_JAR_PROCESSOR
|
|
# LOCAL_JAR_PROCESSOR_ARGS must be evaluated here to set up the rule-local
|
|
# PRIVATE_JAR_PROCESSOR_ARGS variable, but $< and $@ are not available yet.
|
|
# Set ${in} and ${out} so they can be referenced by LOCAL_JAR_PROCESSOR_ARGS
|
|
# using deferred evaluation (LOCAL_JAR_PROCESSOR_ARGS = instead of :=).
|
|
in := $(full_classes_combined_jar)
|
|
out := $(full_classes_processed_jar).tmp
|
|
my_jar_processor := $(HOST_OUT_JAVA_LIBRARIES)/$(LOCAL_JAR_PROCESSOR).jar
|
|
|
|
$(full_classes_processed_jar): PRIVATE_JAR_PROCESSOR_ARGS := $(LOCAL_JAR_PROCESSOR_ARGS)
|
|
$(full_classes_processed_jar): PRIVATE_JAR_PROCESSOR := $(my_jar_processor)
|
|
$(full_classes_processed_jar): PRIVATE_TMP_OUT := $(out)
|
|
in :=
|
|
out :=
|
|
|
|
$(full_classes_processed_jar): $(full_classes_combined_jar) $(my_jar_processor)
|
|
@echo Processing $@ with $(PRIVATE_JAR_PROCESSOR)
|
|
$(hide) rm -f $@ $(PRIVATE_TMP_OUT)
|
|
$(hide) $(JAVA) -jar $(PRIVATE_JAR_PROCESSOR) $(PRIVATE_JAR_PROCESSOR_ARGS)
|
|
$(hide) mv $(PRIVATE_TMP_OUT) $@
|
|
|
|
my_jar_processor :=
|
|
else
|
|
full_classes_processed_jar := $(full_classes_combined_jar)
|
|
endif
|
|
|
|
# Run jarjar if necessary
|
|
ifneq ($(strip $(LOCAL_JARJAR_RULES)),)
|
|
$(full_classes_jarjar_jar): PRIVATE_JARJAR_RULES := $(LOCAL_JARJAR_RULES)
|
|
$(full_classes_jarjar_jar): $(full_classes_processed_jar) $(LOCAL_JARJAR_RULES) | $(JARJAR)
|
|
@echo JarJar: $@
|
|
$(hide) $(JAVA) -jar $(JARJAR) process $(PRIVATE_JARJAR_RULES) $< $@
|
|
else
|
|
full_classes_jarjar_jar := $(full_classes_processed_jar)
|
|
endif
|
|
|
|
$(eval $(call copy-one-file,$(full_classes_jarjar_jar),$(full_classes_jar)))
|
|
|
|
# Temporarily enable --multi-dex until proguard supports v53 class files
|
|
# ( http://b/67673860 ) or we move away from proguard altogether.
|
|
ifdef TARGET_OPENJDK9
|
|
LOCAL_DX_FLAGS := $(filter-out --multi-dex,$(LOCAL_DX_FLAGS)) --multi-dex
|
|
endif
|
|
|
|
ifneq ($(USE_D8_DESUGAR),true)
|
|
my_desugaring :=
|
|
ifndef LOCAL_IS_STATIC_JAVA_LIBRARY
|
|
my_desugaring := true
|
|
$(full_classes_desugar_jar): PRIVATE_DX_FLAGS := $(LOCAL_DX_FLAGS)
|
|
$(full_classes_desugar_jar): $(full_classes_jar) $(full_java_header_libs) $(DESUGAR)
|
|
$(desugar-classes-jar)
|
|
endif
|
|
else
|
|
my_desugaring :=
|
|
endif
|
|
|
|
ifndef my_desugaring
|
|
full_classes_desugar_jar := $(full_classes_jar)
|
|
endif
|
|
|
|
LOCAL_FULL_CLASSES_PRE_JACOCO_JAR := $(full_classes_desugar_jar)
|
|
|
|
#######################################
|
|
include $(BUILD_SYSTEM)/jacoco.mk
|
|
#######################################
|
|
|
|
full_classes_pre_proguard_jar := $(LOCAL_FULL_CLASSES_JACOCO_JAR)
|
|
|
|
# Keep a copy of the jar just before proguard processing.
|
|
$(eval $(call copy-one-file,$(full_classes_pre_proguard_jar),$(intermediates.COMMON)/classes-pre-proguard.jar))
|
|
|
|
# Run proguard if necessary
|
|
ifdef LOCAL_PROGUARD_ENABLED
|
|
ifneq ($(filter-out full custom nosystem obfuscation optimization shrinktests,$(LOCAL_PROGUARD_ENABLED)),)
|
|
$(warning while processing: $(LOCAL_MODULE))
|
|
$(error invalid value for LOCAL_PROGUARD_ENABLED: $(LOCAL_PROGUARD_ENABLED))
|
|
endif
|
|
proguard_dictionary := $(intermediates.COMMON)/proguard_dictionary
|
|
|
|
# When an app contains references to APIs that are not in the SDK specified by
|
|
# its LOCAL_SDK_VERSION for example added by support library or by runtime
|
|
# classes added by desugar, we artifically raise the "SDK version" "linked" by
|
|
# ProGuard, to
|
|
# - suppress ProGuard warnings of referencing symbols unknown to the lower SDK version.
|
|
# - prevent ProGuard stripping subclass in the support library that extends class added in the higher SDK version.
|
|
# See b/20667396
|
|
my_proguard_sdk_raise :=
|
|
ifdef LOCAL_SDK_VERSION
|
|
ifdef TARGET_BUILD_APPS
|
|
ifeq (,$(filter current system_current test_current, $(LOCAL_SDK_VERSION)))
|
|
my_proguard_sdk_raise := $(call java-lib-header-files, sdk_vcurrent)
|
|
endif
|
|
else
|
|
# For platform build, we can't just raise to the "current" SDK,
|
|
# that would break apps that use APIs removed from the current SDK.
|
|
my_proguard_sdk_raise := $(call java-lib-header-files,$(TARGET_DEFAULT_BOOTCLASSPATH_LIBRARIES) $(TARGET_DEFAULT_JAVA_LIBRARIES))
|
|
endif
|
|
endif
|
|
|
|
legacy_proguard_flags := $(addprefix -libraryjars ,$(my_proguard_sdk_raise) \
|
|
$(filter-out $(my_proguard_sdk_raise), \
|
|
$(full_java_bootclasspath_libs) \
|
|
$(full_shared_java_header_libs)))
|
|
|
|
legacy_proguard_lib_deps := $(my_proguard_sdk_raise) \
|
|
$(filter-out $(my_proguard_sdk_raise),$(full_shared_java_header_libs))
|
|
|
|
legacy_proguard_flags += -printmapping $(proguard_dictionary)
|
|
|
|
common_proguard_flags := -forceprocessing
|
|
|
|
common_proguard_flag_files :=
|
|
ifeq ($(filter nosystem,$(LOCAL_PROGUARD_ENABLED)),)
|
|
common_proguard_flag_files += $(BUILD_SYSTEM)/proguard.flags
|
|
ifeq ($(LOCAL_EMMA_INSTRUMENT),true)
|
|
common_proguard_flags += -include $(BUILD_SYSTEM)/proguard.emma.flags
|
|
endif
|
|
# If this is a test package, add proguard keep flags for tests.
|
|
ifneq ($(LOCAL_INSTRUMENTATION_FOR)$(filter tests,$(LOCAL_MODULE_TAGS)),)
|
|
common_proguard_flag_files += $(BUILD_SYSTEM)/proguard_tests.flags
|
|
ifeq ($(filter shrinktests,$(LOCAL_PROGUARD_ENABLED)),)
|
|
common_proguard_flags += -dontshrink # don't shrink tests by default
|
|
endif # shrinktests
|
|
endif # test package
|
|
ifneq ($(LOCAL_PROGUARD_ENABLED),custom)
|
|
ifdef LOCAL_USE_AAPT2
|
|
common_proguard_flag_files += $(foreach l,$(LOCAL_STATIC_ANDROID_LIBRARIES),\
|
|
$(call intermediates-dir-for,JAVA_LIBRARIES,$(l),,COMMON)/export_proguard_flags)
|
|
endif
|
|
endif
|
|
ifneq ($(common_proguard_flag_files),)
|
|
common_proguard_flags += $(addprefix -include , $(common_proguard_flag_files))
|
|
# This is included from $(BUILD_SYSTEM)/proguard.flags
|
|
common_proguard_flag_files += $(BUILD_SYSTEM)/proguard_basic_keeps.flags
|
|
endif
|
|
|
|
ifeq ($(filter obfuscation,$(LOCAL_PROGUARD_ENABLED)),)
|
|
# By default no obfuscation
|
|
common_proguard_flags += -dontobfuscate
|
|
endif # No obfuscation
|
|
ifeq ($(filter optimization,$(LOCAL_PROGUARD_ENABLED)),)
|
|
# By default no optimization
|
|
common_proguard_flags += -dontoptimize
|
|
endif # No optimization
|
|
|
|
ifdef LOCAL_INSTRUMENTATION_FOR
|
|
ifeq ($(filter obfuscation,$(LOCAL_PROGUARD_ENABLED)),)
|
|
# If no obfuscation, link in the instrmented package's classes.jar as a library.
|
|
# link_instr_classes_jar is defined in base_rule.mk
|
|
legacy_proguard_flags += -libraryjars $(link_instr_classes_jar)
|
|
legacy_proguard_lib_deps += $(link_instr_classes_jar)
|
|
else # obfuscation
|
|
# If obfuscation is enabled, the main app must be obfuscated too.
|
|
# We need to run obfuscation using the main app's dictionary,
|
|
# and treat the main app's class.jar as injars instead of libraryjars.
|
|
legacy_proguard_flags := -injars $(link_instr_classes_jar) \
|
|
-outjars $(intermediates.COMMON)/proguard.$(LOCAL_INSTRUMENTATION_FOR).jar \
|
|
-include $(link_instr_intermediates_dir.COMMON)/proguard_options \
|
|
-applymapping $(link_instr_intermediates_dir.COMMON)/proguard_dictionary \
|
|
-verbose \
|
|
$(legacy_proguard_flags)
|
|
|
|
# Sometimes (test + main app) uses different keep rules from the main app -
|
|
# apply the main app's dictionary anyway.
|
|
legacy_proguard_flags += -ignorewarnings
|
|
|
|
# Make sure we run Proguard on the main app first
|
|
$(full_classes_proguard_jar) : $(link_instr_intermediates_dir.COMMON)/proguard.classes.jar
|
|
|
|
endif # no obfuscation
|
|
endif # LOCAL_INSTRUMENTATION_FOR
|
|
endif # LOCAL_PROGUARD_ENABLED is not nosystem
|
|
|
|
proguard_flag_files := $(addprefix $(LOCAL_PATH)/, $(LOCAL_PROGUARD_FLAG_FILES))
|
|
ifeq ($(USE_R8),true)
|
|
proguard_flag_files += $(addprefix $(LOCAL_PATH)/, $(LOCAL_R8_FLAG_FILES))
|
|
endif # USE_R8
|
|
LOCAL_PROGUARD_FLAGS += $(addprefix -include , $(proguard_flag_files))
|
|
|
|
ifdef LOCAL_TEST_MODULE_TO_PROGUARD_WITH
|
|
extra_input_jar := $(call intermediates-dir-for,APPS,$(LOCAL_TEST_MODULE_TO_PROGUARD_WITH),,COMMON)/classes.jar
|
|
else
|
|
extra_input_jar :=
|
|
endif
|
|
|
|
# If building against the current SDK version then filter out the junit,
|
|
# android.test and c.a.i.u.Predicate classes that are to be removed from
|
|
# the Android API as part of b/30188076 but which are still present in
|
|
# the Android API. This is to allow changes to be made to the build to
|
|
# statically include those classes into the application without
|
|
# simultaneously removing those classes from the API.
|
|
proguard_injar_filters :=
|
|
ifdef LOCAL_SDK_VERSION
|
|
ifeq (,$(filter-out current system_current test_current, $(LOCAL_SDK_VERSION)))
|
|
proguard_injar_filters := (!junit/framework/**,!junit/runner/**,!junit/textui/**)
|
|
endif
|
|
endif
|
|
|
|
ifneq ($(filter obfuscation,$(LOCAL_PROGUARD_ENABLED)),)
|
|
ifneq ($(USE_R8),true)
|
|
$(full_classes_proguard_jar): .KATI_IMPLICIT_OUTPUTS := $(proguard_dictionary)
|
|
else
|
|
$(built_dex_intermediate): .KATI_IMPLICIT_OUTPUTS := $(proguard_dictionary)
|
|
endif
|
|
endif
|
|
|
|
# If R8 is not enabled run Proguard.
|
|
ifneq ($(USE_R8),true)
|
|
# Changes to these dependencies need to be replicated below when using R8
|
|
# instead of Proguard + dx.
|
|
$(full_classes_proguard_jar): PRIVATE_PROGUARD_INJAR_FILTERS := $(proguard_injar_filters)
|
|
$(full_classes_proguard_jar): PRIVATE_EXTRA_INPUT_JAR := $(extra_input_jar)
|
|
$(full_classes_proguard_jar): PRIVATE_PROGUARD_FLAGS := $(legacy_proguard_flags) $(common_proguard_flags) $(LOCAL_PROGUARD_FLAGS)
|
|
$(full_classes_proguard_jar) : $(full_classes_pre_proguard_jar) $(extra_input_jar) $(my_proguard_sdk_raise) $(common_proguard_flag_files) $(proguard_flag_files) $(legacy_proguard_lib_deps) | $(PROGUARD)
|
|
$(call transform-jar-to-proguard)
|
|
else # !USE_R8
|
|
# Running R8 instead of Proguard, proguarded jar is actually the pre-Proguarded jar.
|
|
full_classes_proguard_jar := $(full_classes_pre_proguard_jar)
|
|
endif # !USE_R8
|
|
|
|
else # LOCAL_PROGUARD_ENABLED not defined
|
|
proguard_flag_files :=
|
|
full_classes_proguard_jar := $(full_classes_pre_proguard_jar)
|
|
endif # LOCAL_PROGUARD_ENABLED defined
|
|
|
|
ifneq ($(LOCAL_IS_STATIC_JAVA_LIBRARY),true)
|
|
$(built_dex_intermediate): PRIVATE_DX_FLAGS := $(LOCAL_DX_FLAGS)
|
|
|
|
my_r8 :=
|
|
ifdef LOCAL_PROGUARD_ENABLED
|
|
ifeq ($(USE_R8),true)
|
|
# These are the dependencies for the proguarded jar when running
|
|
# Proguard + dx. They are used for the generated dex when using R8, as
|
|
# R8 does Proguard + dx
|
|
my_r8 := true
|
|
$(built_dex_intermediate): PRIVATE_PROGUARD_INJAR_FILTERS := $(proguard_injar_filters)
|
|
$(built_dex_intermediate): PRIVATE_EXTRA_INPUT_JAR := $(extra_input_jar)
|
|
$(built_dex_intermediate): PRIVATE_PROGUARD_FLAGS := $(legacy_proguard_flags) $(common_proguard_flags) $(LOCAL_PROGUARD_FLAGS)
|
|
$(built_dex_intermediate) : $(full_classes_proguard_jar) $(extra_input_jar) $(my_support_library_sdk_raise) $(common_proguard_flag_files) $(proguard_flag_files) $(legacy_proguard_lib_deps) $(R8_COMPAT_PROGUARD)
|
|
$(transform-jar-to-dex-r8)
|
|
endif # USE_R8
|
|
endif # LOCAL_PROGUARD_ENABLED
|
|
|
|
ifndef my_r8
|
|
$(built_dex_intermediate): $(full_classes_proguard_jar) $(DX) $(ZIP2ZIP)
|
|
ifneq ($(USE_D8_DESUGAR),true)
|
|
$(transform-classes.jar-to-dex)
|
|
else
|
|
$(transform-classes-d8.jar-to-dex)
|
|
endif
|
|
endif
|
|
|
|
$(built_dex): $(built_dex_intermediate)
|
|
@echo Copying: $@
|
|
$(hide) mkdir -p $(dir $@)
|
|
$(hide) rm -f $(dir $@)/classes*.dex
|
|
$(hide) cp -fp $(dir $<)/classes*.dex $(dir $@)
|
|
|
|
java-dex: $(built_dex)
|
|
|
|
endif # !LOCAL_IS_STATIC_JAVA_LIBRARY
|
|
|
|
findbugs_xml := $(intermediates.COMMON)/findbugs.xml
|
|
$(findbugs_xml): PRIVATE_AUXCLASSPATH := $(addprefix -auxclasspath ,$(strip \
|
|
$(call normalize-path-list,$(filter %.jar,$(full_java_libs)))))
|
|
$(findbugs_xml): PRIVATE_FINDBUGS_FLAGS := $(LOCAL_FINDBUGS_FLAGS)
|
|
$(findbugs_xml) : $(full_classes_pre_proguard_jar) $(filter %.xml, $(LOCAL_FINDBUGS_FLAGS))
|
|
@echo Findbugs: $@
|
|
$(hide) $(FINDBUGS) -textui -effort:min -xml:withMessages \
|
|
$(PRIVATE_AUXCLASSPATH) $(PRIVATE_FINDBUGS_FLAGS) \
|
|
$< \
|
|
> $@
|
|
|
|
ALL_FINDBUGS_FILES += $(findbugs_xml)
|
|
|
|
findbugs_html := $(PRODUCT_OUT)/findbugs/$(LOCAL_MODULE).html
|
|
$(findbugs_html) : PRIVATE_XML_FILE := $(findbugs_xml)
|
|
$(LOCAL_MODULE)-findbugs : $(findbugs_html)
|
|
$(findbugs_html) : $(findbugs_xml)
|
|
@mkdir -p $(dir $@)
|
|
@echo ConvertXmlToText: $@
|
|
$(hide) $(FINDBUGS_DIR)/convertXmlToText -html:fancy.xsl $(PRIVATE_XML_FILE) \
|
|
> $@
|
|
|
|
$(LOCAL_MODULE)-findbugs : $(findbugs_html)
|
|
|
|
endif # full_classes_jar is defined
|
|
|
|
ifneq (,$(filter-out current system_current test_current, $(LOCAL_SDK_VERSION)))
|
|
my_default_app_target_sdk := $(call get-numeric-sdk-version,$(LOCAL_SDK_VERSION))
|
|
my_sdk_version := $(call get-numeric-sdk-version,$(LOCAL_SDK_VERSION))
|
|
else
|
|
my_default_app_target_sdk := $(DEFAULT_APP_TARGET_SDK)
|
|
my_sdk_version := $(PLATFORM_SDK_VERSION)
|
|
endif
|
|
|
|
ifdef LOCAL_MIN_SDK_VERSION
|
|
my_min_sdk_version := $(LOCAL_MIN_SDK_VERSION)
|
|
else
|
|
my_min_sdk_version := $(call codename-or-sdk-to-sdk,$(my_default_app_target_sdk))
|
|
endif
|
|
|
|
$(LOCAL_INTERMEDIATE_TARGETS): PRIVATE_DEFAULT_APP_TARGET_SDK := $(my_default_app_target_sdk)
|
|
$(LOCAL_INTERMEDIATE_TARGETS): PRIVATE_SDK_VERSION := $(my_sdk_version)
|
|
$(LOCAL_INTERMEDIATE_TARGETS): PRIVATE_MIN_SDK_VERSION := $(my_min_sdk_version)
|