-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathcreate_native_lib_mk_files.bash
339 lines (303 loc) · 18.9 KB
/
create_native_lib_mk_files.bash
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
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
#!/bin/bash
# This script is a generic script for generating Android.mk make file(s) for an apk's shared libraries
# so that the apk may be installed into the system partition as a prebuilt app.
# This script also creates a "build-$2-libnames.txt" file which contains a list of all of the SONAMES for
# the libraries that had Android.mk files generated. Where $2 is the APK's package name as described below.
# In the case of multiarch APKs, only the first occurance of an SONAME is placed in the list so that the list
# will not contain duplicates.
# The first argument to the script is the APK installation directory on the target.
# E.x. "/system/app/com.example.some.package.name"
# The second argument to the script is the APK's package name. (Without the APK file extension.)
# E.x. "com.example.some.package.name"
# The return value of this script is the number of shared libraries that we made Android.mk files for.
# (Including duplicates caused by multiarch APKs.)
# Define ARM Variant lists.
# Note: These should be all lowercase and
# listed in lowest ABI level (Most compatibility) to highest ABI level (least compatibility) order.
# ARM32 Variants.
ARM_32_VARIANTS[0]="armeabi"
ARM_32_VARIANTS[1]="armeabi-v7a"
# ARM64 Variants.
ARM_64_VARIANTS[0]="arm64-v8a"
retC=0
if [ $# -eq 2 ]; then
if [ "$1" != "" -a "$2" != "" ]; then
LOC_TARGET_INSTALL_PATH="$1"
BUILD_MKFILE_TMP="${PWD}/build"
for i in *.mk;
do
if [ "$i" == "*.mk" ]; then
continue
fi
rm -f "$i"
done
if [ -f "$BUILD_MKFILE_TMP-$2-libnames.txt" ]; then
rm -f "$BUILD_MKFILE_TMP-$2-libnames.txt"
fi
TMP_ARR_IDX=0
declare -a LIB_ARR
if [ -d "lib" ]; then
pushd "lib" &> /dev/null
retPush=$?
if [ $retPush -eq 0 ]; then
# Note: We have to clean up the arch names here.
# The AOSP build system is *very* sensitive about arch names and, of course,
# the ABI names are not mapped to the arch names.
# I.e. If TARGET_ARCH=arm64 then
# LOCAL_MODULE_TARGET_ARCH := arm64-v8a will *NOT* match the target, and
# the build system will exclude the module from the built system image.
# Currently I do not know of any ABI matching rule to use here.
# Define the currently selected ARM variants.
CURRENT_ARM32_VAR=""
CURRENT_ARM64_VAR=""
# Declare remaining vars.
declare -a ARCH_VARIANTS
declare -i ARCH_VARIANTS_IDX
ARCH_VARIANTS_IDX=0
for d in *;
do
# Skip bad directory.
if [ ! -d "${d}" ]; then
continue
else
# Generate lower case version of the directory name.
TMP_STR="`echo "${d}" | tr '[:upper:]' '[:lower:]'`"
# Check and see if we are dealing with an ARM variant.
if [ ${#TMP_STR} -ge 3 -a "arm" == "${TMP_STR:0:3}" ]; then
# ARM variant. Determine bitness.
if [ ${#TMP_STR} -ge 5 -a "arm64" == "${TMP_STR:0:5}" ]; then
# ARM64 bit.
# Determine lowest common variant.
if [ "${CURRENT_ARM64_VAR}" == "" ]; then
# No current variant selected. Use this one for now.
CURRENT_ARM64_VAR="${d}"
else
# Determine if the directory's variant is even in the list of known variants.
declare -i COUNT_IDX
COUNT_IDX=0
while [ $COUNT_IDX -lt ${#ARM_64_VARIANTS[@]} ];
do
# Check and see if the current variant is a match.
if [ "${ARM_64_VARIANTS[$COUNT_IDX]}" == "${TMP_STR}" ]; then
# Current variant is a match.
break
else
# Increment COUNT_IDX.
COUNT_IDX=$COUNT_IDX+1
fi
done
if [ $COUNT_IDX -le ${#ARM_64_VARIANTS[@]} ]; then
# Directory's variant is known. See if the currently selected variant is lower than the directory's variant on the list.
declare -i DIR_VARIANT
DIR_VARIANT=$COUNT_IDX
COUNT_IDX=0
CUR_STR="`echo "${CURRENT_ARM64_VAR}" | tr '[:upper:]' '[:lower:]'`"
while [ $COUNT_IDX -lt ${#ARM_64_VARIANTS[@]} ];
do
# Check and see if the current variant is a match.
if [ "${ARM_64_VARIANTS[$COUNT_IDX]}" == "${CUR_STR}" ]; then
# Current variant is a match.
break
else
# Increment COUNT_IDX.
COUNT_IDX=$COUNT_IDX+1
fi
done
# Clean up CUR_STR.
unset CUR_STR
if [ $COUNT_IDX -le ${#ARM_64_VARIANTS[@]} ]; then
# Both current and directory are known variants. Determine which one has a lower ABI level and choose it.
if [ $DIR_VARIANT -le $COUNT_IDX ]; then
# Directory variant has the lower ABI level. Selecting it as the current ABI to use.
CURRENT_ARM64_VAR="${d}"
fi
else
# An UNKNOWN variant was found previously. (Was probably the first one we found.)
# Warn the user and choose the known variant instead.
echo "WARNING: Encountered unknown ARM ABI variant ( ${CURRENT_ARM64_VAR} ) for APK ( ${2} ). You should update create_native_lib_mk_files.bash to be aware of the new variant." >&2
echo "WARNING: Otherwise, if a known ARM ABI variant is found it will be prioritised over this unknown variant by default." >&2
CURRENT_ARM64_VAR="${d}"
fi
# Clean up DIR_VARIANT and CUR_STR.
unset DIR_VARIANT
unset CUR_STR
else
# UNKNOWN variant. Warn the user and ignore it.
echo "WARNING: Encountered unknown ARM ABI variant ( ${TMP_STR} ) for APK ( ${2} ). You should update create_native_lib_mk_files.bash to be aware of the new variant." >&2
echo "WARNING: Otherwise, if a known ARM ABI variant is found it will be prioritised over this unknown variant by default." >&2
fi
# Clean up COUNT_IDX.
unset COUNT_IDX
fi
else
# ARM32 bit.
# Determine lowest common variant.
if [ "${CURRENT_ARM32_VAR}" == "" ]; then
# No current variant selected. Use this one for now.
CURRENT_ARM32_VAR="${d}"
else
# Determine if the directory's variant is even in the list of known variants.
declare -i COUNT_IDX
COUNT_IDX=0
while [ $COUNT_IDX -lt ${#ARM_32_VARIANTS[@]} ];
do
# Check and see if the current variant is a match.
if [ "${ARM_32_VARIANTS[$COUNT_IDX]}" == "${TMP_STR}" ]; then
# Current variant is a match.
break
else
# Increment COUNT_IDX.
COUNT_IDX=$COUNT_IDX+1
fi
done
if [ $COUNT_IDX -le ${#ARM_32_VARIANTS[@]} ]; then
# Directory's variant is known. See if the currently selected variant is lower than the directory's variant on the list.
declare -i DIR_VARIANT
DIR_VARIANT=$COUNT_IDX
COUNT_IDX=0
CUR_STR="`echo "${CURRENT_ARM32_VAR}" | tr '[:upper:]' '[:lower:]'`"
while [ $COUNT_IDX -lt ${#ARM_32_VARIANTS[@]} ];
do
# Check and see if the current variant is a match.
if [ "${ARM_32_VARIANTS[$COUNT_IDX]}" == "${CUR_STR}" ]; then
# Current variant is a match.
break
else
# Increment COUNT_IDX.
COUNT_IDX=$COUNT_IDX+1
fi
done
# Clean up CUR_STR.
unset CUR_STR
if [ $COUNT_IDX -le ${#ARM_32_VARIANTS[@]} ]; then
# Both current and directory are known variants. Determine which one has a lower ABI level and choose it.
if [ $DIR_VARIANT -le $COUNT_IDX ]; then
# Directory variant has the lower ABI level. Selecting it as the current ABI to use.
CURRENT_ARM32_VAR="${d}"
fi
else
# An UNKNOWN variant was found previously. (Was probably the first one we found.)
# Warn the user and choose the known variant instead.
echo "WARNING: Encountered unknown ARM ABI variant ( ${CURRENT_ARM32_VAR} ) for APK ( ${2} ). You should update create_native_lib_mk_files.bash to be aware of the new variant." >&2
echo "WARNING: Otherwise, if a known ARM ABI variant is found it will be prioritised over this unknown variant by default." >&2
CURRENT_ARM32_VAR="${d}"
fi
# Clean up DIR_VARIANT and CUR_STR.
unset DIR_VARIANT
unset CUR_STR
else
# UNKNOWN variant. Warn the user and ignore it.
echo "WARNING: Encountered unknown ARM ABI variant ( ${TMP_STR} ) for APK ( ${2} ). You should update create_native_lib_mk_files.bash to be aware of the new variant." >&2
echo "WARNING: Otherwise, if a known ARM ABI variant is found it will be prioritised over this unknown variant by default." >&2
fi
# Clean up COUNT_IDX.
unset COUNT_IDX
fi
fi
else
# Not an ARM variant, add to the valid arch variants list.
ARCH_VARIANTS[$ARCH_VARIANTS_IDX]="${d}"
ARCH_VARIANTS_IDX=$ARCH_VARIANTS_IDX+1
fi
fi
done
# Add selected ARM variants if needed.
if [ "${CURRENT_ARM32_VAR}" != "" ]; then
ARCH_VARIANTS[$ARCH_VARIANTS_IDX]="${CURRENT_ARM32_VAR}"
ARCH_VARIANTS_IDX=$ARCH_VARIANTS_IDX+1
fi
if [ "${CURRENT_ARM64_VAR}" != "" ]; then
ARCH_VARIANTS[$ARCH_VARIANTS_IDX]="${CURRENT_ARM64_VAR}"
ARCH_VARIANTS_IDX=$ARCH_VARIANTS_IDX+1
fi
# Generate the Android.mk files for the valid variants.
for d in "${ARCH_VARIANTS[@]}";
do
if [ -d "$d" ]; then
pushd "$d" &> /dev/null
retPush=$?
if [ $retPush -eq 0 ]; then
for i in *;
do
# Skip wildcard.
if [ "$i" == "*" ]; then
continue
else
# Check array to see if the SONAME is already present.
TMP_LEN="${#i}"
TMP_NAME="${i:0:$TMP_LEN-3}"
TMP_ADD=1
for z in "${LIB_ARR[@]}"; do
if [ "$z" == "$TMP_NAME" ]; then
# Found the library name. Do not add it to the list.
TMP_ADD=0
break
fi
done
# Add the SONAME if needed.
if [ $TMP_ADD -eq 1 ]; then
LIB_ARR[$TMP_ARR_IDX]="$TMP_NAME"
TMP_ARR_IDX=$TMP_ARR_IDX+1
fi
BUILD_MKFILE="${BUILD_MKFILE_TMP}-${2}-${d}-${i}.mk"
echo 'include $(CLEAR_VARS)' >> "$BUILD_MKFILE"
echo -n 'LOCAL_MODULE := ' >> "$BUILD_MKFILE"
echo "${2}-${TMP_NAME}" >> "$BUILD_MKFILE"
echo -n 'LOCAL_SRC_FILES := ' >> "$BUILD_MKFILE"
echo "lib/${d}/${i}" >> "$BUILD_MKFILE"
echo 'LOCAL_MODULE_TAGS := optional' >> "$BUILD_MKFILE"
echo 'LOCAL_MODULE_CLASS := SHARED_LIBRARIES' >> "$BUILD_MKFILE"
echo -n 'LOCAL_MODULE_PATH := ' >> "$BUILD_MKFILE"
echo "${LOC_TARGET_INSTALL_PATH}/lib/${d}" >> "$BUILD_MKFILE"
echo -n 'LOCAL_MODULE_STEM := ' >> "$BUILD_MKFILE"
echo "${i}" >> "$BUILD_MKFILE"
# Output arch type.
echo -n 'LOCAL_MODULE_TARGET_ARCH := ' >> "$BUILD_MKFILE"
# Check and see if the current arch is a selected ARM arch.
if [ "${d}" == "${CURRENT_ARM32_VAR}" ]; then
# ARM 32 arch. (Should output "arm" here...)
echo "arm" >> "$BUILD_MKFILE"
else
if [ "${d}" == "${CURRENT_ARM64_VAR}" ]; then
# ARM 64 arch. (Should output "arm64" here...)
echo "arm64" >> "$BUILD_MKFILE"
else
# Not a selected ARM arch, just output the name.
echo "${d}" >> "$BUILD_MKFILE"
fi
fi
echo 'include $(BUILD_PREBUILT)' >> "$BUILD_MKFILE"
sync
# Clean up.
unset TMP_LEN
unset TMP_NAME
fi
done
retC=${retC+1}
popd &> /dev/null
else
echo "ERROR: Unable to enter directory ( $PWD/lib/$d )." >&2
retC=0
unset LIB_ARR
declare -a LIB_ARR
break
fi
fi
done
# Exit the lib directory.
popd &> /dev/null
# Create the SONAME list file.
if [ $retC -gt 0 ]; then
for z in "${LIB_ARR[@]}"; do
echo -n "${2}-${z} " >> "$BUILD_MKFILE_TMP-$2-libnames.txt"
done
unset LIB_ARR
fi
else
echo "ERROR: Unable to enter directory ( $PWD/lib )." >&2
fi
fi
fi
fi
# Return the number of libs that we made mk files for.
exit $retC