1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
|
#!/usr/bin/env python
#
# Copyright (C) 2021 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.
#
"""
A tool for merging dexpreopt.config files for <uses-library> dependencies into
the dexpreopt.config file of the library/app that uses them. This is needed to
generate class loader context (CLC) for dexpreopt.
In Make there is no topological order when processing different modules, so a
<uses-library> dependency module may have not been processed yet by the time the
dependent module is processed. Therefore makefiles communicate the information
from dependencies via dexpreopt.config files and add file-level dependencies
from a module dexpreopt.config to its dependency configs. The actual patching
of configs is done by this script, which is called from the makefiles.
"""
from __future__ import print_function
import json
from collections import OrderedDict
import sys
def main():
"""Program entry point."""
if len(sys.argv) < 2:
raise SystemExit('usage: %s <main-config> [dep-config ...]' % sys.argv[0])
# Read all JSON configs.
cfgs = []
for arg in sys.argv[1:]:
with open(arg, 'r') as f:
cfgs.append(json.load(f, object_pairs_hook=OrderedDict))
# The first config is the dexpreopted library/app, the rest are its
# <uses-library> dependencies.
cfg0 = cfgs[0]
# Put dependency configs in a map keyed on module name (for easier lookup).
uses_libs = {}
for cfg in cfgs[1:]:
uses_libs[cfg['Name']] = cfg
# Load the original CLC map.
clc_map = cfg0['ClassLoaderContexts']
# Create a new CLC map that will be a copy of the original one with patched
# fields from dependency dexpreopt.config files.
clc_map2 = OrderedDict()
# Patch CLC for each SDK version. Although this should not be necessary for
# compatibility libraries (so-called "conditional CLC"), because they all have
# known names, known paths in system/framework, and no subcontext. But keep
# the loop in case this changes in the future.
for sdk_ver in clc_map:
clcs = clc_map[sdk_ver]
clcs2 = []
for clc in clcs:
lib = clc['Name']
if lib in uses_libs:
ulib = uses_libs[lib]
# The real <uses-library> name (may be different from the module name).
clc['Name'] = ulib['ProvidesUsesLibrary']
# On-device (install) path to the dependency DEX jar file.
clc['Device'] = ulib['DexLocation']
# CLC of the dependency becomes a subcontext. We only need sub-CLC for
# 'any' version because all other versions are for compatibility
# libraries, which exist only for apps and not for libraries.
clc['Subcontexts'] = ulib['ClassLoaderContexts'].get('any')
else:
# dexpreopt.config for this <uses-library> is not among the script
# arguments, which may be the case with compatibility libraries that
# don't need patching anyway. Just use the original CLC.
pass
clcs2.append(clc)
clc_map2[sdk_ver] = clcs2
# Overwrite the original class loader context with the patched one.
cfg0['ClassLoaderContexts'] = clc_map2
# Update dexpreopt.config file.
with open(sys.argv[1], 'w') as f:
f.write(json.dumps(cfgs[0], indent=4, separators=(',', ': ')))
if __name__ == '__main__':
main()
|
