From 08e6d325997dd79469d9d5e7f0858bad4928c2e4 Mon Sep 17 00:00:00 2001 From: Pindar Yang Date: Mon, 26 Aug 2024 06:52:12 +0000 Subject: [PATCH] Revert "Convert hardware/interfaces/compatibility_matrices/Andro..." Revert submission 3195743-compatibility_matrix Reason for revert: Build Break, Bug: 361227456 Reverted changes: /q/submissionid:3195743-compatibility_matrix Change-Id: I9a0e678942694a1ea0d068de381d04e2e4b135f8 --- PREUPLOAD.cfg | 1 - compatibility_matrices/Android.bp | 31 ---- compatibility_matrices/Android.mk | 134 ++++++++++++++++++ compatibility_matrices/build/Android.bp | 1 - .../build/vintf_compatibility_matrix.go | 125 +--------------- .../compatibility_matrix.mk | 94 ++++++++++++ 6 files changed, 234 insertions(+), 152 deletions(-) create mode 100644 compatibility_matrices/Android.mk create mode 100644 compatibility_matrices/compatibility_matrix.mk diff --git a/PREUPLOAD.cfg b/PREUPLOAD.cfg index 8c53006d98..de7aa354bd 100644 --- a/PREUPLOAD.cfg +++ b/PREUPLOAD.cfg @@ -5,7 +5,6 @@ ignore_merged_commits = true bpfmt = true clang_format = true aidl_format = true -gofmt = true [Hook Scripts] aosp_hook_confirmationui = ${REPO_ROOT}/frameworks/base/tools/aosp/aosp_sha.sh ${PREUPLOAD_COMMIT} confirmationui diff --git a/compatibility_matrices/Android.bp b/compatibility_matrices/Android.bp index 6a3fa32635..ad42015156 100644 --- a/compatibility_matrices/Android.bp +++ b/compatibility_matrices/Android.bp @@ -93,14 +93,6 @@ vintf_compatibility_matrix { } -// Device framework compatibility matrix (common to all FCM versions) -// Reference: https://source.android.com/docs/core/architecture/vintf/comp-matrices -vintf_compatibility_matrix { - name: "framework_compatibility_matrix.device.xml", - stem: "compatibility_matrix.device.xml", - type: "device_fcm", -} - // Phony target that installs all system compatibility matrix files SYSTEM_MATRIX_DEPS = [ "framework_compatibility_matrix.5.xml", @@ -122,26 +114,3 @@ phony { }, }, } - -// Product Compatibility Matrix -vintf_compatibility_matrix { - name: "product_compatibility_matrix.xml", - stem: "compatibility_matrix.xml", - product_specific: true, - type: "product_fcm", -} - -// Phony target that installs all framework compatibility matrix files (system + product) -FRAMEWORK_MATRIX_DEPS = SYSTEM_MATRIX_DEPS + ["product_compatibility_matrix.xml"] - -phony { - name: "framework_compatibility_matrix.xml", - required: FRAMEWORK_MATRIX_DEPS, - product_variables: { - release_aidl_use_unfrozen: { - required: [ - "framework_compatibility_matrix.202504.xml", - ], - }, - }, -} diff --git a/compatibility_matrices/Android.mk b/compatibility_matrices/Android.mk new file mode 100644 index 0000000000..338c075c02 --- /dev/null +++ b/compatibility_matrices/Android.mk @@ -0,0 +1,134 @@ +# +# Copyright (C) 2017 The Android Open Source Project +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +LOCAL_PATH := $(call my-dir) + +BUILD_FRAMEWORK_COMPATIBILITY_MATRIX := $(LOCAL_PATH)/compatibility_matrix.mk +my_empty_manifest := $(LOCAL_PATH)/manifest.empty.xml + +# System Compatibility Matrix (common to all FCM versions) + +include $(CLEAR_VARS) +include $(LOCAL_PATH)/clear_vars.mk +LOCAL_MODULE := framework_compatibility_matrix.device.xml +LOCAL_LICENSE_KINDS := SPDX-license-identifier-Apache-2.0 +LOCAL_LICENSE_CONDITIONS := notice +LOCAL_NOTICE_FILE := $(LOCAL_PATH)/../NOTICE +LOCAL_MODULE_STEM := compatibility_matrix.device.xml +# define LOCAL_MODULE_CLASS for local-generated-sources-dir. +LOCAL_MODULE_CLASS := ETC +LOCAL_MODULE_RELATIVE_PATH := vintf + +ifndef DEVICE_FRAMEWORK_COMPATIBILITY_MATRIX_FILE +LOCAL_SRC_FILES := compatibility_matrix.empty.xml +else + +# DEVICE_FRAMEWORK_COMPATIBILITY_MATRIX_FILE specifies absolute paths +LOCAL_GENERATED_SOURCES := $(DEVICE_FRAMEWORK_COMPATIBILITY_MATRIX_FILE) + +# Enforce that DEVICE_FRAMEWORK_COMPATIBILITY_MATRIX_FILE does not specify required HALs +# by checking it against an empty manifest. But the empty manifest needs to contain +# BOARD_SEPOLICY_VERS to be compatible with DEVICE_FRAMEWORK_COMPATIBILITY_MATRIX_FILE. +my_gen_check_manifest := $(local-generated-sources-dir)/manifest.check.xml +$(my_gen_check_manifest): PRIVATE_SRC_FILE := $(my_empty_manifest) +$(my_gen_check_manifest): $(my_empty_manifest) $(HOST_OUT_EXECUTABLES)/assemble_vintf + BOARD_SEPOLICY_VERS=$(BOARD_SEPOLICY_VERS) \ + VINTF_IGNORE_TARGET_FCM_VERSION=true \ + $(HOST_OUT_EXECUTABLES)/assemble_vintf -i $(PRIVATE_SRC_FILE) -o $@ + +LOCAL_GEN_FILE_DEPENDENCIES += $(my_gen_check_manifest) +LOCAL_ASSEMBLE_VINTF_FLAGS += -c "$(my_gen_check_manifest)" + +my_gen_check_manifest := + +endif # DEVICE_FRAMEWORK_COMPATIBILITY_MATRIX_FILE + +# TODO(b/296875906): use POLICYVERS from Soong +POLICYVERS ?= 30 + +LOCAL_ADD_VBMETA_VERSION := true +LOCAL_ASSEMBLE_VINTF_ENV_VARS := \ + POLICYVERS \ + PLATFORM_SEPOLICY_VERSION \ + PLATFORM_SEPOLICY_COMPAT_VERSIONS + +include $(BUILD_FRAMEWORK_COMPATIBILITY_MATRIX) + +# Product Compatibility Matrix + +include $(CLEAR_VARS) +include $(LOCAL_PATH)/clear_vars.mk +LOCAL_MODULE := product_compatibility_matrix.xml +LOCAL_LICENSE_KINDS := SPDX-license-identifier-Apache-2.0 +LOCAL_LICENSE_CONDITIONS := notice +LOCAL_NOTICE_FILE := $(LOCAL_PATH)/../NOTICE + +ifndef DEVICE_PRODUCT_COMPATIBILITY_MATRIX_FILE +my_framework_matrix_deps := +include $(BUILD_PHONY_PACKAGE) +else # DEVICE_PRODUCT_COMPATIBILITY_MATRIX_FILE + +LOCAL_MODULE_STEM := compatibility_matrix.xml +LOCAL_PRODUCT_MODULE := true +LOCAL_MODULE_CLASS := ETC +LOCAL_MODULE_RELATIVE_PATH := vintf + +# DEVICE_PRODUCT_COMPATIBILITY_MATRIX_FILE specifies absolute paths +LOCAL_GENERATED_SOURCES := $(DEVICE_PRODUCT_COMPATIBILITY_MATRIX_FILE) + +# Enforce that DEVICE_PRODUCT_COMPATIBILITY_MATRIX_FILE does not specify required HALs +# by checking it against an empty manifest. +LOCAL_GEN_FILE_DEPENDENCIES += $(my_empty_manifest) +LOCAL_ASSEMBLE_VINTF_FLAGS += -c "$(my_empty_manifest)" + +my_framework_matrix_deps := $(LOCAL_MODULE) + +include $(BUILD_FRAMEWORK_COMPATIBILITY_MATRIX) + +endif # DEVICE_PRODUCT_COMPATIBILITY_MATRIX_FILE + +my_system_matrix_deps := \ + framework_compatibility_matrix.5.xml \ + framework_compatibility_matrix.6.xml \ + framework_compatibility_matrix.7.xml \ + framework_compatibility_matrix.8.xml \ + framework_compatibility_matrix.202404.xml \ + framework_compatibility_matrix.device.xml \ + +# Only allow the use of the unreleased compatibility matrix when we can use unfrozen +# interfaces (in the `next` release configuration). +ifeq ($(RELEASE_AIDL_USE_UNFROZEN),true) +my_system_matrix_deps += \ + framework_compatibility_matrix.202504.xml \ + +endif + +my_framework_matrix_deps += \ + $(my_system_matrix_deps) + +# Phony target that installs all framework compatibility matrix files (system + product) +include $(CLEAR_VARS) +LOCAL_MODULE := framework_compatibility_matrix.xml +LOCAL_LICENSE_KINDS := SPDX-license-identifier-Apache-2.0 +LOCAL_LICENSE_CONDITIONS := notice +LOCAL_NOTICE_FILE := $(LOCAL_PATH)/../NOTICE +LOCAL_REQUIRED_MODULES := $(my_framework_matrix_deps) +include $(BUILD_PHONY_PACKAGE) + +my_system_matrix_deps := +my_framework_matrix_deps := +my_empty_manifest := +BUILD_FRAMEWORK_COMPATIBILITY_MATRIX := diff --git a/compatibility_matrices/build/Android.bp b/compatibility_matrices/build/Android.bp index 6011fcc138..79ef36dffc 100644 --- a/compatibility_matrices/build/Android.bp +++ b/compatibility_matrices/build/Android.bp @@ -30,7 +30,6 @@ bootstrap_go_package { "kernel-config-soong-rules", "soong", "soong-android", - "soong-selinux", ], srcs: [ "vintf_compatibility_matrix.go", diff --git a/compatibility_matrices/build/vintf_compatibility_matrix.go b/compatibility_matrices/build/vintf_compatibility_matrix.go index b8f2a14118..c72cbde05c 100644 --- a/compatibility_matrices/build/vintf_compatibility_matrix.go +++ b/compatibility_matrices/build/vintf_compatibility_matrix.go @@ -24,7 +24,6 @@ import ( "android/soong/android" "android/soong/kernel/configs" - "android/soong/selinux" ) type dependencyTag struct { @@ -36,10 +35,10 @@ var ( pctx = android.NewPackageContext("android/vintf") assembleVintfRule = pctx.AndroidStaticRule("assemble_vintf", blueprint.RuleParams{ - Command: `${assembleVintfEnv} ${assembleVintfCmd} -i ${inputs} -o ${out} ${extraArgs}`, - CommandDeps: []string{"${assembleVintfCmd}", "${AvbToolCmd}"}, + Command: `${assembleVintfCmd} -i ${inputs} -o ${out}`, + CommandDeps: []string{"${assembleVintfCmd}"}, Description: "assemble_vintf -i ${inputs}", - }, "inputs", "extraArgs", "assembleVintfEnv") + }, "inputs") xmllintXsd = pctx.AndroidStaticRule("xmllint-xsd", blueprint.RuleParams{ Command: `$XmlLintCmd --quiet --schema $xsd $in > /dev/null && touch -a $out`, @@ -53,11 +52,7 @@ var ( ) const ( - relpath = "vintf" - emptyManifest = "hardware/interfaces/compatibility_matrices/manifest.empty.xml" - compatibilityEmptyMatrix = "hardware/interfaces/compatibility_matrices/compatibility_matrix.empty.xml" - deviceFcmType = "device_fcm" - productFcmType = "product_fcm" + relpath = "vintf" ) type vintfCompatibilityMatrixProperties struct { @@ -69,9 +64,6 @@ type vintfCompatibilityMatrixProperties struct { // list of kernel_config modules to be combined to final output Kernel_configs []string - - // Type of the FCM type, the allowed type are device_fcm and product_fcm and it should only be used under hardware/interfaces/compatibility_matrices - Type *string } type vintfCompatibilityMatrixRule struct { @@ -80,13 +72,11 @@ type vintfCompatibilityMatrixRule struct { genFile android.WritablePath additionalDependencies android.WritablePaths - phonyOnly bool } func init() { pctx.HostBinToolVariable("assembleVintfCmd", "assemble_vintf") pctx.HostBinToolVariable("XmlLintCmd", "xmllint") - pctx.HostBinToolVariable("AvbToolCmd", "avbtool") android.RegisterModuleType("vintf_compatibility_matrix", vintfCompatibilityMatrixFactory) } @@ -141,20 +131,6 @@ func (g *vintfCompatibilityMatrixRule) getSchema(ctx android.ModuleContext) andr } func (g *vintfCompatibilityMatrixRule) GenerateAndroidBuildActions(ctx android.ModuleContext) { - // Types attribute only allow `device_fcm` or `product_fcm` if set and only restricted it being used under - // `hardware/interfaces/compatibility_matrices` to prevent accidental external usages. - matrixType := proptools.String(g.properties.Type) - if matrixType != "" { - if matrixType != deviceFcmType && matrixType != productFcmType { - panic(fmt.Errorf("The attribute 'type' value must be either 'device_fcm' or 'product_fcm' if set!")) - } - if !strings.HasPrefix(android.PathForModuleSrc(ctx).String(), "hardware/interfaces/compatibility_matrices") { - panic(fmt.Errorf("Attribute type can only be set for module under `hardware/interfaces/compatibility_matrices`!")) - } - if (len(g.properties.Srcs) + len(g.properties.Kernel_configs)) > 0 { - panic(fmt.Errorf("Attribute 'type' and 'srcs' or 'kernel_configs' should not set simultaneously! To update inputs for this rule, edit vintf_compatibility_matrix.go directly.")) - } - } outputFilename := proptools.String(g.properties.Stem) if outputFilename == "" { @@ -182,72 +158,15 @@ func (g *vintfCompatibilityMatrixRule) GenerateAndroidBuildActions(ctx android.M } }) - // For product_compatibility_matrix.xml the source is from the product configuration - // DEVICE_PRODUCT_COMPATIBILITY_MATRIX_FILE. - extraArgs := []string{} - if matrixType == productFcmType { - productMatrixs := android.PathsForSource(ctx, ctx.Config().DeviceProductCompatibilityMatrixFile()) - if len(productMatrixs) > 0 { - inputPaths = append(inputPaths, productMatrixs...) - extraArgs = append(extraArgs, "-c", android.PathForSource(ctx, emptyManifest).String()) - } else { - // For product_fcm, if DEVICE_PRODUCT_COMPATIBILITY_MATRIX_FILE not set, treat it as a phony target without any output generated. - g.phonyOnly = true - return - } - } - - // For framework_compatibility_matrix.device.xml the source may come from the product configuration - // DEVICE_FRAMEWORK_COMPATIBILITY_MATRIX_FILE or use compatibilityEmptyMatrix if not set. We can't - // use a phony target because we still need to install framework_compatibility_matrix.device.xml to - // include sepolicy versions. - frameworkRuleImplicits := []android.Path{} - - if matrixType == deviceFcmType { - frameworkMatrixs := android.PathsForSource(ctx, ctx.Config().DeviceFrameworkCompatibilityMatrixFile()) - if len(frameworkMatrixs) > 0 { - inputPaths = append(inputPaths, frameworkMatrixs...) - - // Generate BuildAction for generating the check manifest. - emptyManifestPath := android.PathForSource(ctx, emptyManifest) - genCheckManifest := android.PathForModuleGen(ctx, "manifest.check.xml") - checkManifestInputs := []android.Path{emptyManifestPath} - genCheckManifestEnvs := []string{ - "BOARD_SEPOLICY_VERS=" + ctx.DeviceConfig().BoardSepolicyVers(), - "VINTF_IGNORE_TARGET_FCM_VERSION=true", - } - - ctx.Build(pctx, android.BuildParams{ - Rule: assembleVintfRule, - Description: "Framework Check Manifest", - Implicits: checkManifestInputs, - Output: genCheckManifest, - Args: map[string]string{ - "inputs": android.PathForSource(ctx, emptyManifest).String(), - "extraArgs": "", - "assembleVintfEnv": strings.Join(genCheckManifestEnvs, " "), - }, - }) - - frameworkRuleImplicits = append(frameworkRuleImplicits, genCheckManifest) - extraArgs = append(extraArgs, "-c", genCheckManifest.String()) - } else { - inputPaths = append(inputPaths, android.PathForSource(ctx, compatibilityEmptyMatrix)) - } - } - g.genFile = android.PathForModuleGen(ctx, outputFilename) - frameworkRuleImplicits = append(frameworkRuleImplicits, inputPaths...) ctx.Build(pctx, android.BuildParams{ Rule: assembleVintfRule, Description: "Framework Compatibility Matrix", - Implicits: frameworkRuleImplicits, + Implicits: inputPaths, Output: g.genFile, Args: map[string]string{ - "inputs": strings.Join(inputPaths.Strings(), ":"), - "extraArgs": strings.Join(extraArgs, " "), - "assembleVintfEnv": g.getAssembleVintfEnv(ctx), + "inputs": strings.Join(inputPaths.Strings(), ":"), }, }) g.generateValidateBuildAction(ctx, g.genFile, schema.Path()) @@ -255,39 +174,7 @@ func (g *vintfCompatibilityMatrixRule) GenerateAndroidBuildActions(ctx android.M ctx.InstallFile(android.PathForModuleInstall(ctx, "etc", relpath), outputFilename, g.genFile) } -func (g *vintfCompatibilityMatrixRule) getAssembleVintfEnv(ctx android.ModuleContext) string { - if proptools.String(g.properties.Type) == deviceFcmType { - assembleVintfEnvs := []string{ - // POLICYVERS defined in system/sepolicy/build/soong/policy.go - fmt.Sprintf("POLICYVERS=%d", selinux.PolicyVers), - fmt.Sprintf("PLATFORM_SEPOLICY_VERSION=%s", ctx.DeviceConfig().PlatformSepolicyVersion()), - fmt.Sprintf("PLATFORM_SEPOLICY_COMPAT_VERSIONS=\"%s\"", strings.Join(ctx.DeviceConfig().PlatformSepolicyCompatVersions(), " ")), - } - - if ctx.Config().BoardAvbEnable() { - assembleVintfEnvs = append(assembleVintfEnvs, fmt.Sprintf("FRAMEWORK_VBMETA_VERSION=\"$$(${AvbToolCmd} add_hashtree_footer --print_required_libavb_version %s)\"", strings.Join(ctx.Config().BoardAvbSystemAddHashtreeFooterArgs(), " "))) - } else { - assembleVintfEnvs = append(assembleVintfEnvs, "FRAMEWORK_VBMETA_VERSION=\"0.0\"") - } - - return strings.Join(assembleVintfEnvs, " ") - } - - return "" -} - func (g *vintfCompatibilityMatrixRule) AndroidMk() android.AndroidMkData { - if g.phonyOnly { - return android.AndroidMkData{ - Custom: func(w io.Writer, name, prefix, moduleDir string, data android.AndroidMkData) { - fmt.Fprintln(w, "\ninclude $(CLEAR_VARS)", " # vintf.vintf_compatibility_matrix") - fmt.Fprintln(w, "LOCAL_PATH :=", moduleDir) - fmt.Fprintln(w, "LOCAL_MODULE :=", name) - fmt.Fprintln(w, "include $(BUILD_PHONY_PACKAGE)") - }, - } - } - return android.AndroidMkData{ Class: "ETC", OutputFile: android.OptionalPathForPath(g.genFile), diff --git a/compatibility_matrices/compatibility_matrix.mk b/compatibility_matrices/compatibility_matrix.mk new file mode 100644 index 0000000000..64cd645e24 --- /dev/null +++ b/compatibility_matrices/compatibility_matrix.mk @@ -0,0 +1,94 @@ +# +# Copyright (C) 2018 The Android Open Source Project +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +##### Input Variables: +# LOCAL_MODULE: required. Module name for the build system. +# LOCAL_MODULE_CLASS: optional. Default is ETC. +# LOCAL_MODULE_PATH / LOCAL_MODULE_RELATIVE_PATH: required. (Relative) path of output file. +# If not defined, LOCAL_MODULE_RELATIVE_PATH will be "vintf". +# LOCAL_MODULE_STEM: optional. Name of output file. Default is $(LOCAL_MODULE). +# LOCAL_SRC_FILES: required. Local source files provided to assemble_vintf +# (command line argument -i). +# LOCAL_GENERATED_SOURCES: optional. Global source files provided to assemble_vintf +# (command line argument -i). +# +# LOCAL_ADD_VBMETA_VERSION: Use AVBTOOL to add avb version to the output matrix +# (corresponds to tag) +# LOCAL_ASSEMBLE_VINTF_ENV_VARS: Add a list of environment variable names from global variables in +# the build system that is lazily evaluated (e.g. PRODUCT_ENFORCE_VINTF_MANIFEST). +# LOCAL_ASSEMBLE_VINTF_FLAGS: Add additional command line arguments to assemble_vintf invocation. +# LOCAL_GEN_FILE_DEPENDENCIES: A list of additional dependencies for the generated file. + +ifndef LOCAL_MODULE +$(error LOCAL_MODULE must be defined.) +endif + +ifndef LOCAL_MODULE_STEM +LOCAL_MODULE_STEM := $(LOCAL_MODULE) +endif + +ifndef LOCAL_MODULE_CLASS +LOCAL_MODULE_CLASS := ETC +endif + +ifndef LOCAL_MODULE_PATH +ifndef LOCAL_MODULE_RELATIVE_PATH +$(error Either LOCAL_MODULE_PATH or LOCAL_MODULE_RELATIVE_PATH must be defined.) +endif +endif + +GEN := $(local-generated-sources-dir)/$(LOCAL_MODULE_STEM) + +$(GEN): PRIVATE_ENV_VARS := $(LOCAL_ASSEMBLE_VINTF_ENV_VARS) +$(GEN): PRIVATE_FLAGS := $(LOCAL_ASSEMBLE_VINTF_FLAGS) + +$(GEN): $(LOCAL_GEN_FILE_DEPENDENCIES) + +ifeq (true,$(strip $(LOCAL_ADD_VBMETA_VERSION))) +ifeq (true,$(BOARD_AVB_ENABLE)) +$(GEN): $(AVBTOOL) +$(GEN): $(BOARD_AVB_SYSTEM_KEY_PATH) +# Use deferred assignment (=) instead of immediate assignment (:=). +# Otherwise, cannot get INTERNAL_AVB_SYSTEM_SIGNING_ARGS. +$(GEN): FRAMEWORK_VBMETA_VERSION = $$("$(AVBTOOL)" add_hashtree_footer \ + --print_required_libavb_version \ + $(BOARD_AVB_SYSTEM_ADD_HASHTREE_FOOTER_ARGS)) +else +$(GEN): FRAMEWORK_VBMETA_VERSION := 0.0 +endif # BOARD_AVB_ENABLE +$(GEN): PRIVATE_ENV_VARS += FRAMEWORK_VBMETA_VERSION +endif # LOCAL_ADD_VBMETA_VERSION + +my_matrix_src_files := \ + $(addprefix $(LOCAL_PATH)/,$(LOCAL_SRC_FILES)) \ + $(LOCAL_GENERATED_SOURCES) + +$(GEN): PRIVATE_SRC_FILES := $(my_matrix_src_files) +$(GEN): $(my_matrix_src_files) $(HOST_OUT_EXECUTABLES)/assemble_vintf + $(foreach varname,$(PRIVATE_ENV_VARS),$(varname)="$($(varname))") \ + $(HOST_OUT_EXECUTABLES)/assemble_vintf \ + -i $(call normalize-path-list,$(PRIVATE_SRC_FILES)) \ + -o $@ \ + $(PRIVATE_FLAGS) + +LOCAL_PREBUILT_MODULE_FILE := $(GEN) +LOCAL_SRC_FILES := +LOCAL_GENERATED_SOURCES := + +include $(LOCAL_PATH)/clear_vars.mk +my_matrix_src_files := + +include $(BUILD_PREBUILT)