Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 1 | #!/bin/bash |
| 2 | # |
| 3 | # Copyright (C) 2016 The CyanogenMod Project |
| 4 | # |
| 5 | # Licensed under the Apache License, Version 2.0 (the "License"); |
| 6 | # you may not use this file except in compliance with the License. |
| 7 | # You may obtain a copy of the License at |
| 8 | # |
| 9 | # http://www.apache.org/licenses/LICENSE-2.0 |
| 10 | # |
| 11 | # Unless required by applicable law or agreed to in writing, software |
| 12 | # distributed under the License is distributed on an "AS IS" BASIS, |
| 13 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 14 | # See the License for the specific language governing permissions and |
| 15 | # limitations under the License. |
| 16 | # |
| 17 | |
| 18 | PRODUCT_COPY_FILES_LIST=() |
Steve Kondik | 48f8df8 | 2016-08-14 03:55:08 -0700 | [diff] [blame] | 19 | PRODUCT_COPY_FILES_HASHES=() |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 20 | PRODUCT_PACKAGES_LIST=() |
Steve Kondik | 48f8df8 | 2016-08-14 03:55:08 -0700 | [diff] [blame] | 21 | PRODUCT_PACKAGES_HASHES=() |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 22 | PACKAGE_LIST=() |
| 23 | VENDOR_STATE=-1 |
Louis Popi | a516c2f | 2016-07-25 15:51:13 +0200 | [diff] [blame] | 24 | VENDOR_RADIO_STATE=-1 |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 25 | COMMON=-1 |
Luca Stefani | 7f9fff2 | 2016-07-18 13:47:55 +0200 | [diff] [blame] | 26 | ARCHES= |
| 27 | FULLY_DEODEXED=-1 |
| 28 | |
| 29 | TMPDIR="/tmp/extractfiles.$$" |
| 30 | mkdir "$TMPDIR" |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 31 | |
| 32 | # |
Steve Kondik | 48f8df8 | 2016-08-14 03:55:08 -0700 | [diff] [blame] | 33 | # cleanup |
| 34 | # |
| 35 | # kill our tmpfiles with fire on exit |
| 36 | # |
| 37 | function cleanup() { |
| 38 | rm -rf "${TMPDIR:?}" |
| 39 | } |
| 40 | |
| 41 | trap cleanup EXIT INT TERM ERR |
| 42 | |
| 43 | # |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 44 | # setup_vendor |
| 45 | # |
| 46 | # $1: device name |
| 47 | # $2: vendor name |
Luca Stefani | 5c60e4f | 2017-08-17 19:28:48 +0200 | [diff] [blame] | 48 | # $3: Lineage root directory |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 49 | # $4: is common device - optional, default to false |
| 50 | # $5: cleanup - optional, default to true |
Rashed Abdel-Tawab | 5f17315 | 2016-10-01 20:33:00 -0400 | [diff] [blame] | 51 | # $6: custom vendor makefile name - optional, default to false |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 52 | # |
| 53 | # Must be called before any other functions can be used. This |
| 54 | # sets up the internal state for a new vendor configuration. |
| 55 | # |
| 56 | function setup_vendor() { |
| 57 | local DEVICE="$1" |
| 58 | if [ -z "$DEVICE" ]; then |
| 59 | echo "\$DEVICE must be set before including this script!" |
| 60 | exit 1 |
| 61 | fi |
| 62 | |
| 63 | export VENDOR="$2" |
| 64 | if [ -z "$VENDOR" ]; then |
| 65 | echo "\$VENDOR must be set before including this script!" |
| 66 | exit 1 |
| 67 | fi |
| 68 | |
Luca Stefani | 5c60e4f | 2017-08-17 19:28:48 +0200 | [diff] [blame] | 69 | export LINEAGE_ROOT="$3" |
| 70 | if [ ! -d "$LINEAGE_ROOT" ]; then |
| 71 | echo "\$LINEAGE_ROOT must be set and valid before including this script!" |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 72 | exit 1 |
| 73 | fi |
| 74 | |
| 75 | export OUTDIR=vendor/"$VENDOR"/"$DEVICE" |
Luca Stefani | 5c60e4f | 2017-08-17 19:28:48 +0200 | [diff] [blame] | 76 | if [ ! -d "$LINEAGE_ROOT/$OUTDIR" ]; then |
| 77 | mkdir -p "$LINEAGE_ROOT/$OUTDIR" |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 78 | fi |
| 79 | |
Rashed Abdel-Tawab | 5f17315 | 2016-10-01 20:33:00 -0400 | [diff] [blame] | 80 | VNDNAME="$6" |
| 81 | if [ -z "$VNDNAME" ]; then |
| 82 | VNDNAME="$DEVICE" |
| 83 | fi |
| 84 | |
Luca Stefani | 5c60e4f | 2017-08-17 19:28:48 +0200 | [diff] [blame] | 85 | export PRODUCTMK="$LINEAGE_ROOT"/"$OUTDIR"/"$VNDNAME"-vendor.mk |
| 86 | export ANDROIDMK="$LINEAGE_ROOT"/"$OUTDIR"/Android.mk |
| 87 | export BOARDMK="$LINEAGE_ROOT"/"$OUTDIR"/BoardConfigVendor.mk |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 88 | |
| 89 | if [ "$4" == "true" ] || [ "$4" == "1" ]; then |
| 90 | COMMON=1 |
| 91 | else |
| 92 | COMMON=0 |
| 93 | fi |
| 94 | |
Gabriele M | b6effb3 | 2017-05-01 18:22:04 +0200 | [diff] [blame] | 95 | if [ "$5" == "false" ] || [ "$5" == "0" ]; then |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 96 | VENDOR_STATE=1 |
Louis Popi | a516c2f | 2016-07-25 15:51:13 +0200 | [diff] [blame] | 97 | VENDOR_RADIO_STATE=1 |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 98 | else |
| 99 | VENDOR_STATE=0 |
Louis Popi | a516c2f | 2016-07-25 15:51:13 +0200 | [diff] [blame] | 100 | VENDOR_RADIO_STATE=0 |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 101 | fi |
| 102 | } |
| 103 | |
| 104 | # |
| 105 | # target_file: |
| 106 | # |
| 107 | # $1: colon delimited list |
| 108 | # |
| 109 | # Returns destination filename without args |
| 110 | # |
| 111 | function target_file() { |
| 112 | local LINE="$1" |
| 113 | local SPLIT=(${LINE//:/ }) |
| 114 | local COUNT=${#SPLIT[@]} |
| 115 | if [ "$COUNT" -gt "1" ]; then |
| 116 | if [[ "${SPLIT[1]}" =~ .*/.* ]]; then |
| 117 | printf '%s\n' "${SPLIT[1]}" |
| 118 | return 0 |
| 119 | fi |
| 120 | fi |
| 121 | printf '%s\n' "${SPLIT[0]}" |
| 122 | } |
| 123 | |
| 124 | # |
| 125 | # target_args: |
| 126 | # |
| 127 | # $1: colon delimited list |
| 128 | # |
| 129 | # Returns optional arguments (last value) for given target |
| 130 | # |
| 131 | function target_args() { |
| 132 | local LINE="$1" |
| 133 | local SPLIT=(${LINE//:/ }) |
| 134 | local COUNT=${#SPLIT[@]} |
| 135 | if [ "$COUNT" -gt "1" ]; then |
| 136 | if [[ ! "${SPLIT[$COUNT-1]}" =~ .*/.* ]]; then |
| 137 | printf '%s\n' "${SPLIT[$COUNT-1]}" |
| 138 | fi |
| 139 | fi |
| 140 | } |
| 141 | |
| 142 | # |
| 143 | # prefix_match: |
| 144 | # |
| 145 | # $1: the prefix to match on |
| 146 | # |
| 147 | # Internal function which loops thru the packages list and returns a new |
| 148 | # list containing the matched files with the prefix stripped away. |
| 149 | # |
| 150 | function prefix_match() { |
| 151 | local PREFIX="$1" |
| 152 | for FILE in "${PRODUCT_PACKAGES_LIST[@]}"; do |
| 153 | if [[ "$FILE" =~ ^"$PREFIX" ]]; then |
| 154 | printf '%s\n' "${FILE#$PREFIX}" |
| 155 | fi |
| 156 | done |
| 157 | } |
| 158 | |
| 159 | # |
| 160 | # write_product_copy_files: |
| 161 | # |
| 162 | # Creates the PRODUCT_COPY_FILES section in the product makefile for all |
| 163 | # items in the list which do not start with a dash (-). |
| 164 | # |
| 165 | function write_product_copy_files() { |
| 166 | local COUNT=${#PRODUCT_COPY_FILES_LIST[@]} |
| 167 | local TARGET= |
| 168 | local FILE= |
| 169 | local LINEEND= |
| 170 | |
| 171 | if [ "$COUNT" -eq "0" ]; then |
| 172 | return 0 |
| 173 | fi |
| 174 | |
| 175 | printf '%s\n' "PRODUCT_COPY_FILES += \\" >> "$PRODUCTMK" |
| 176 | for (( i=1; i<COUNT+1; i++ )); do |
| 177 | FILE="${PRODUCT_COPY_FILES_LIST[$i-1]}" |
| 178 | LINEEND=" \\" |
| 179 | if [ "$i" -eq "$COUNT" ]; then |
| 180 | LINEEND="" |
| 181 | fi |
| 182 | |
| 183 | TARGET=$(target_file "$FILE") |
| 184 | printf ' %s/proprietary/%s:system/%s%s\n' \ |
| 185 | "$OUTDIR" "$TARGET" "$TARGET" "$LINEEND" >> "$PRODUCTMK" |
| 186 | done |
| 187 | return 0 |
| 188 | } |
| 189 | |
| 190 | # |
| 191 | # write_packages: |
| 192 | # |
| 193 | # $1: The LOCAL_MODULE_CLASS for the given module list |
| 194 | # $2: "true" if this package is part of the vendor/ path |
Steve Kondik | a991cf1 | 2016-07-28 12:13:12 -0700 | [diff] [blame] | 195 | # $3: type-specific extra flags |
| 196 | # $4: Name of the array holding the target list |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 197 | # |
| 198 | # Internal function which writes out the BUILD_PREBUILT stanzas |
| 199 | # for all modules in the list. This is called by write_product_packages |
| 200 | # after the modules are categorized. |
| 201 | # |
| 202 | function write_packages() { |
| 203 | |
| 204 | local CLASS="$1" |
| 205 | local VENDOR_PKG="$2" |
Steve Kondik | a991cf1 | 2016-07-28 12:13:12 -0700 | [diff] [blame] | 206 | local EXTRA="$3" |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 207 | |
| 208 | # Yes, this is a horrible hack - we create a new array using indirection |
Steve Kondik | a991cf1 | 2016-07-28 12:13:12 -0700 | [diff] [blame] | 209 | local ARR_NAME="$4[@]" |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 210 | local FILELIST=("${!ARR_NAME}") |
| 211 | |
| 212 | local FILE= |
| 213 | local ARGS= |
| 214 | local BASENAME= |
| 215 | local EXTENSION= |
| 216 | local PKGNAME= |
| 217 | local SRC= |
| 218 | |
| 219 | for P in "${FILELIST[@]}"; do |
| 220 | FILE=$(target_file "$P") |
| 221 | ARGS=$(target_args "$P") |
| 222 | |
| 223 | BASENAME=$(basename "$FILE") |
| 224 | EXTENSION=${BASENAME##*.} |
| 225 | PKGNAME=${BASENAME%.*} |
| 226 | |
| 227 | # Add to final package list |
| 228 | PACKAGE_LIST+=("$PKGNAME") |
| 229 | |
| 230 | SRC="proprietary" |
| 231 | if [ "$VENDOR_PKG" = "true" ]; then |
| 232 | SRC+="/vendor" |
| 233 | fi |
| 234 | |
| 235 | printf 'include $(CLEAR_VARS)\n' |
| 236 | printf 'LOCAL_MODULE := %s\n' "$PKGNAME" |
| 237 | printf 'LOCAL_MODULE_OWNER := %s\n' "$VENDOR" |
| 238 | if [ "$CLASS" = "SHARED_LIBRARIES" ]; then |
Steve Kondik | a991cf1 | 2016-07-28 12:13:12 -0700 | [diff] [blame] | 239 | if [ "$EXTRA" = "both" ]; then |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 240 | printf 'LOCAL_SRC_FILES_64 := %s/lib64/%s\n' "$SRC" "$FILE" |
| 241 | printf 'LOCAL_SRC_FILES_32 := %s/lib/%s\n' "$SRC" "$FILE" |
| 242 | #if [ "$VENDOR_PKG" = "true" ]; then |
| 243 | # echo "LOCAL_MODULE_PATH_64 := \$(TARGET_OUT_VENDOR_SHARED_LIBRARIES)" |
| 244 | # echo "LOCAL_MODULE_PATH_32 := \$(2ND_TARGET_OUT_VENDOR_SHARED_LIBRARIES)" |
| 245 | #else |
| 246 | # echo "LOCAL_MODULE_PATH_64 := \$(TARGET_OUT_SHARED_LIBRARIES)" |
| 247 | # echo "LOCAL_MODULE_PATH_32 := \$(2ND_TARGET_OUT_SHARED_LIBRARIES)" |
| 248 | #fi |
Steve Kondik | a991cf1 | 2016-07-28 12:13:12 -0700 | [diff] [blame] | 249 | elif [ "$EXTRA" = "64" ]; then |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 250 | printf 'LOCAL_SRC_FILES := %s/lib64/%s\n' "$SRC" "$FILE" |
| 251 | else |
| 252 | printf 'LOCAL_SRC_FILES := %s/lib/%s\n' "$SRC" "$FILE" |
| 253 | fi |
Steve Kondik | 03ce400 | 2016-07-29 00:00:16 -0700 | [diff] [blame] | 254 | if [ "$EXTRA" != "none" ]; then |
Steve Kondik | a991cf1 | 2016-07-28 12:13:12 -0700 | [diff] [blame] | 255 | printf 'LOCAL_MULTILIB := %s\n' "$EXTRA" |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 256 | fi |
| 257 | elif [ "$CLASS" = "APPS" ]; then |
HashBang | d303031 | 2016-08-01 14:36:46 -0400 | [diff] [blame] | 258 | if [ -z "$ARGS" ]; then |
| 259 | if [ "$EXTRA" = "priv-app" ]; then |
| 260 | SRC="$SRC/priv-app" |
| 261 | else |
| 262 | SRC="$SRC/app" |
| 263 | fi |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 264 | fi |
| 265 | printf 'LOCAL_SRC_FILES := %s/%s\n' "$SRC" "$FILE" |
| 266 | local CERT=platform |
| 267 | if [ ! -z "$ARGS" ]; then |
| 268 | CERT="$ARGS" |
| 269 | fi |
| 270 | printf 'LOCAL_CERTIFICATE := %s\n' "$CERT" |
| 271 | elif [ "$CLASS" = "JAVA_LIBRARIES" ]; then |
| 272 | printf 'LOCAL_SRC_FILES := %s/framework/%s\n' "$SRC" "$FILE" |
Elektroschmock | 082e0ec | 2016-10-04 21:11:43 +0200 | [diff] [blame] | 273 | local CERT=platform |
| 274 | if [ ! -z "$ARGS" ]; then |
| 275 | CERT="$ARGS" |
| 276 | fi |
| 277 | printf 'LOCAL_CERTIFICATE := %s\n' "$CERT" |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 278 | elif [ "$CLASS" = "ETC" ]; then |
| 279 | printf 'LOCAL_SRC_FILES := %s/etc/%s\n' "$SRC" "$FILE" |
| 280 | elif [ "$CLASS" = "EXECUTABLES" ]; then |
Steve Kondik | a991cf1 | 2016-07-28 12:13:12 -0700 | [diff] [blame] | 281 | if [ "$ARGS" = "rootfs" ]; then |
| 282 | SRC="$SRC/rootfs" |
| 283 | if [ "$EXTRA" = "sbin" ]; then |
| 284 | SRC="$SRC/sbin" |
| 285 | printf '%s\n' "LOCAL_MODULE_PATH := \$(TARGET_ROOT_OUT_SBIN)" |
| 286 | printf '%s\n' "LOCAL_UNSTRIPPED_PATH := \$(TARGET_ROOT_OUT_SBIN_UNSTRIPPED)" |
| 287 | fi |
| 288 | else |
| 289 | SRC="$SRC/bin" |
| 290 | fi |
| 291 | printf 'LOCAL_SRC_FILES := %s/%s\n' "$SRC" "$FILE" |
| 292 | unset EXTENSION |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 293 | else |
Steve Kondik | a991cf1 | 2016-07-28 12:13:12 -0700 | [diff] [blame] | 294 | printf 'LOCAL_SRC_FILES := %s/%s\n' "$SRC" "$FILE" |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 295 | fi |
| 296 | printf 'LOCAL_MODULE_TAGS := optional\n' |
| 297 | printf 'LOCAL_MODULE_CLASS := %s\n' "$CLASS" |
Hashbang173 | 3b3a0e1 | 2016-08-28 20:38:45 -0400 | [diff] [blame] | 298 | if [ "$CLASS" = "APPS" ]; then |
| 299 | printf 'LOCAL_DEX_PREOPT := false\n' |
| 300 | fi |
Steve Kondik | a991cf1 | 2016-07-28 12:13:12 -0700 | [diff] [blame] | 301 | if [ ! -z "$EXTENSION" ]; then |
| 302 | printf 'LOCAL_MODULE_SUFFIX := .%s\n' "$EXTENSION" |
| 303 | fi |
| 304 | if [ "$EXTRA" = "priv-app" ]; then |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 305 | printf 'LOCAL_PRIVILEGED_MODULE := true\n' |
| 306 | fi |
| 307 | if [ "$VENDOR_PKG" = "true" ]; then |
| 308 | printf 'LOCAL_PROPRIETARY_MODULE := true\n' |
| 309 | fi |
| 310 | printf 'include $(BUILD_PREBUILT)\n\n' |
| 311 | done |
| 312 | } |
| 313 | |
| 314 | # |
| 315 | # write_product_packages: |
| 316 | # |
| 317 | # This function will create BUILD_PREBUILT entries in the |
| 318 | # Android.mk and associated PRODUCT_PACKAGES list in the |
| 319 | # product makefile for all files in the blob list which |
| 320 | # start with a single dash (-) character. |
| 321 | # |
| 322 | function write_product_packages() { |
| 323 | PACKAGE_LIST=() |
| 324 | |
| 325 | local COUNT=${#PRODUCT_PACKAGES_LIST[@]} |
| 326 | |
| 327 | if [ "$COUNT" = "0" ]; then |
| 328 | return 0 |
| 329 | fi |
| 330 | |
| 331 | # Figure out what's 32-bit, what's 64-bit, and what's multilib |
| 332 | # I really should not be doing this in bash due to shitty array passing :( |
| 333 | local T_LIB32=( $(prefix_match "lib/") ) |
| 334 | local T_LIB64=( $(prefix_match "lib64/") ) |
| 335 | local MULTILIBS=( $(comm -12 <(printf '%s\n' "${T_LIB32[@]}") <(printf '%s\n' "${T_LIB64[@]}")) ) |
| 336 | local LIB32=( $(comm -23 <(printf '%s\n' "${T_LIB32[@]}") <(printf '%s\n' "${MULTILIBS[@]}")) ) |
Steve Kondik | 60ef86d | 2016-07-20 20:03:40 -0700 | [diff] [blame] | 337 | local LIB64=( $(comm -23 <(printf '%s\n' "${T_LIB64[@]}") <(printf '%s\n' "${MULTILIBS[@]}")) ) |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 338 | |
Steve Kondik | 03ce400 | 2016-07-29 00:00:16 -0700 | [diff] [blame] | 339 | if [ "${#MULTILIBS[@]}" -gt "0" ]; then |
| 340 | write_packages "SHARED_LIBRARIES" "false" "both" "MULTILIBS" >> "$ANDROIDMK" |
| 341 | fi |
| 342 | if [ "${#LIB32[@]}" -gt "0" ]; then |
| 343 | write_packages "SHARED_LIBRARIES" "false" "32" "LIB32" >> "$ANDROIDMK" |
| 344 | fi |
| 345 | if [ "${#LIB64[@]}" -gt "0" ]; then |
| 346 | write_packages "SHARED_LIBRARIES" "false" "64" "LIB64" >> "$ANDROIDMK" |
| 347 | fi |
| 348 | |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 349 | local T_V_LIB32=( $(prefix_match "vendor/lib/") ) |
| 350 | local T_V_LIB64=( $(prefix_match "vendor/lib64/") ) |
| 351 | local V_MULTILIBS=( $(comm -12 <(printf '%s\n' "${T_V_LIB32[@]}") <(printf '%s\n' "${T_V_LIB64[@]}")) ) |
| 352 | local V_LIB32=( $(comm -23 <(printf '%s\n' "${T_V_LIB32[@]}") <(printf '%s\n' "${V_MULTILIBS[@]}")) ) |
Steve Kondik | 60ef86d | 2016-07-20 20:03:40 -0700 | [diff] [blame] | 353 | local V_LIB64=( $(comm -23 <(printf '%s\n' "${T_V_LIB64[@]}") <(printf '%s\n' "${V_MULTILIBS[@]}")) ) |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 354 | |
| 355 | if [ "${#V_MULTILIBS[@]}" -gt "0" ]; then |
Steve Kondik | a991cf1 | 2016-07-28 12:13:12 -0700 | [diff] [blame] | 356 | write_packages "SHARED_LIBRARIES" "true" "both" "V_MULTILIBS" >> "$ANDROIDMK" |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 357 | fi |
| 358 | if [ "${#V_LIB32[@]}" -gt "0" ]; then |
Steve Kondik | 03ce400 | 2016-07-29 00:00:16 -0700 | [diff] [blame] | 359 | write_packages "SHARED_LIBRARIES" "true" "32" "V_LIB32" >> "$ANDROIDMK" |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 360 | fi |
| 361 | if [ "${#V_LIB64[@]}" -gt "0" ]; then |
Steve Kondik | a991cf1 | 2016-07-28 12:13:12 -0700 | [diff] [blame] | 362 | write_packages "SHARED_LIBRARIES" "true" "64" "V_LIB64" >> "$ANDROIDMK" |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 363 | fi |
| 364 | |
| 365 | # Apps |
| 366 | local APPS=( $(prefix_match "app/") ) |
| 367 | if [ "${#APPS[@]}" -gt "0" ]; then |
Steve Kondik | a991cf1 | 2016-07-28 12:13:12 -0700 | [diff] [blame] | 368 | write_packages "APPS" "false" "" "APPS" >> "$ANDROIDMK" |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 369 | fi |
| 370 | local PRIV_APPS=( $(prefix_match "priv-app/") ) |
| 371 | if [ "${#PRIV_APPS[@]}" -gt "0" ]; then |
Steve Kondik | a991cf1 | 2016-07-28 12:13:12 -0700 | [diff] [blame] | 372 | write_packages "APPS" "false" "priv-app" "PRIV_APPS" >> "$ANDROIDMK" |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 373 | fi |
| 374 | local V_APPS=( $(prefix_match "vendor/app/") ) |
| 375 | if [ "${#V_APPS[@]}" -gt "0" ]; then |
Steve Kondik | a991cf1 | 2016-07-28 12:13:12 -0700 | [diff] [blame] | 376 | write_packages "APPS" "true" "" "V_APPS" >> "$ANDROIDMK" |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 377 | fi |
| 378 | local V_PRIV_APPS=( $(prefix_match "vendor/priv-app/") ) |
| 379 | if [ "${#V_PRIV_APPS[@]}" -gt "0" ]; then |
Steve Kondik | a991cf1 | 2016-07-28 12:13:12 -0700 | [diff] [blame] | 380 | write_packages "APPS" "true" "priv-app" "V_PRIV_APPS" >> "$ANDROIDMK" |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 381 | fi |
| 382 | |
| 383 | # Framework |
| 384 | local FRAMEWORK=( $(prefix_match "framework/") ) |
| 385 | if [ "${#FRAMEWORK[@]}" -gt "0" ]; then |
Steve Kondik | a991cf1 | 2016-07-28 12:13:12 -0700 | [diff] [blame] | 386 | write_packages "JAVA_LIBRARIES" "false" "" "FRAMEWORK" >> "$ANDROIDMK" |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 387 | fi |
| 388 | |
| 389 | # Etc |
| 390 | local ETC=( $(prefix_match "etc/") ) |
| 391 | if [ "${#ETC[@]}" -gt "0" ]; then |
Steve Kondik | a991cf1 | 2016-07-28 12:13:12 -0700 | [diff] [blame] | 392 | write_packages "ETC" "false" "" "ETC" >> "$ANDROIDMK" |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 393 | fi |
| 394 | local V_ETC=( $(prefix_match "vendor/etc/") ) |
| 395 | if [ "${#V_ETC[@]}" -gt "0" ]; then |
Steve Kondik | a991cf1 | 2016-07-28 12:13:12 -0700 | [diff] [blame] | 396 | write_packages "ETC" "false" "" "V_ETC" >> "$ANDROIDMK" |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 397 | fi |
| 398 | |
| 399 | # Executables |
| 400 | local BIN=( $(prefix_match "bin/") ) |
| 401 | if [ "${#BIN[@]}" -gt "0" ]; then |
Steve Kondik | a991cf1 | 2016-07-28 12:13:12 -0700 | [diff] [blame] | 402 | write_packages "EXECUTABLES" "false" "" "BIN" >> "$ANDROIDMK" |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 403 | fi |
| 404 | local V_BIN=( $(prefix_match "vendor/bin/") ) |
| 405 | if [ "${#V_BIN[@]}" -gt "0" ]; then |
Steve Kondik | a991cf1 | 2016-07-28 12:13:12 -0700 | [diff] [blame] | 406 | write_packages "EXECUTABLES" "true" "" "V_BIN" >> "$ANDROIDMK" |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 407 | fi |
Steve Kondik | a991cf1 | 2016-07-28 12:13:12 -0700 | [diff] [blame] | 408 | local SBIN=( $(prefix_match "sbin/") ) |
| 409 | if [ "${#SBIN[@]}" -gt "0" ]; then |
| 410 | write_packages "EXECUTABLES" "false" "sbin" "SBIN" >> "$ANDROIDMK" |
| 411 | fi |
| 412 | |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 413 | |
| 414 | # Actually write out the final PRODUCT_PACKAGES list |
| 415 | local PACKAGE_COUNT=${#PACKAGE_LIST[@]} |
| 416 | |
| 417 | if [ "$PACKAGE_COUNT" -eq "0" ]; then |
| 418 | return 0 |
| 419 | fi |
| 420 | |
| 421 | printf '\n%s\n' "PRODUCT_PACKAGES += \\" >> "$PRODUCTMK" |
| 422 | for (( i=1; i<PACKAGE_COUNT+1; i++ )); do |
| 423 | local LINEEND=" \\" |
| 424 | if [ "$i" -eq "$PACKAGE_COUNT" ]; then |
| 425 | LINEEND="" |
| 426 | fi |
| 427 | printf ' %s%s\n' "${PACKAGE_LIST[$i-1]}" "$LINEEND" >> "$PRODUCTMK" |
| 428 | done |
| 429 | } |
| 430 | |
| 431 | # |
| 432 | # write_header: |
| 433 | # |
| 434 | # $1: file which will be written to |
| 435 | # |
| 436 | # writes out the copyright header with the current year. |
| 437 | # note that this is not an append operation, and should |
| 438 | # be executed first! |
| 439 | # |
| 440 | function write_header() { |
Matt Mower | 8945f5e | 2017-01-07 14:08:17 -0600 | [diff] [blame] | 441 | if [ -f $1 ]; then |
| 442 | rm $1 |
| 443 | fi |
| 444 | |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 445 | YEAR=$(date +"%Y") |
| 446 | |
| 447 | [ "$COMMON" -eq 1 ] && local DEVICE="$DEVICE_COMMON" |
| 448 | |
Matt Mower | 8945f5e | 2017-01-07 14:08:17 -0600 | [diff] [blame] | 449 | NUM_REGEX='^[0-9]+$' |
| 450 | if [[ $INITIAL_COPYRIGHT_YEAR =~ $NUM_REGEX ]] && [ $INITIAL_COPYRIGHT_YEAR -le $YEAR ]; then |
| 451 | if [ $INITIAL_COPYRIGHT_YEAR -lt 2016 ]; then |
| 452 | printf "# Copyright (C) $INITIAL_COPYRIGHT_YEAR-2016 The CyanogenMod Project\n" > $1 |
| 453 | elif [ $INITIAL_COPYRIGHT_YEAR -eq 2016 ]; then |
| 454 | printf "# Copyright (C) 2016 The CyanogenMod Project\n" > $1 |
| 455 | fi |
| 456 | if [ $YEAR -eq 2017 ]; then |
| 457 | printf "# Copyright (C) 2017 The LineageOS Project\n" >> $1 |
| 458 | elif [ $INITIAL_COPYRIGHT_YEAR -eq $YEAR ]; then |
| 459 | printf "# Copyright (C) $YEAR The LineageOS Project\n" >> $1 |
| 460 | elif [ $INITIAL_COPYRIGHT_YEAR -le 2017 ]; then |
| 461 | printf "# Copyright (C) 2017-$YEAR The LineageOS Project\n" >> $1 |
| 462 | else |
| 463 | printf "# Copyright (C) $INITIAL_COPYRIGHT_YEAR-$YEAR The LineageOS Project\n" >> $1 |
| 464 | fi |
| 465 | else |
| 466 | printf "# Copyright (C) $YEAR The LineageOS Project\n" > $1 |
| 467 | fi |
| 468 | |
| 469 | cat << EOF >> $1 |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 470 | # |
| 471 | # Licensed under the Apache License, Version 2.0 (the "License"); |
| 472 | # you may not use this file except in compliance with the License. |
| 473 | # You may obtain a copy of the License at |
| 474 | # |
| 475 | # http://www.apache.org/licenses/LICENSE-2.0 |
| 476 | # |
| 477 | # Unless required by applicable law or agreed to in writing, software |
| 478 | # distributed under the License is distributed on an "AS IS" BASIS, |
| 479 | # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 480 | # See the License for the specific language governing permissions and |
| 481 | # limitations under the License. |
| 482 | |
| 483 | # This file is generated by device/$VENDOR/$DEVICE/setup-makefiles.sh |
| 484 | |
| 485 | EOF |
| 486 | } |
| 487 | |
| 488 | # |
| 489 | # write_headers: |
| 490 | # |
| 491 | # $1: devices falling under common to be added to guard - optional |
Rashed Abdel-Tawab | d53bff1 | 2016-10-02 01:00:54 -0400 | [diff] [blame] | 492 | # $2: custom guard - optional |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 493 | # |
| 494 | # Calls write_header for each of the makefiles and creates |
| 495 | # the initial path declaration and device guard for the |
| 496 | # Android.mk |
| 497 | # |
| 498 | function write_headers() { |
| 499 | write_header "$ANDROIDMK" |
Rashed Abdel-Tawab | d53bff1 | 2016-10-02 01:00:54 -0400 | [diff] [blame] | 500 | |
| 501 | GUARD="$2" |
| 502 | if [ -z "$GUARD" ]; then |
| 503 | GUARD="TARGET_DEVICE" |
| 504 | fi |
| 505 | |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 506 | cat << EOF >> "$ANDROIDMK" |
| 507 | LOCAL_PATH := \$(call my-dir) |
| 508 | |
| 509 | EOF |
| 510 | if [ "$COMMON" -ne 1 ]; then |
| 511 | cat << EOF >> "$ANDROIDMK" |
Rashed Abdel-Tawab | d53bff1 | 2016-10-02 01:00:54 -0400 | [diff] [blame] | 512 | ifeq (\$($GUARD),$DEVICE) |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 513 | |
| 514 | EOF |
| 515 | else |
| 516 | if [ -z "$1" ]; then |
| 517 | echo "Argument with devices to be added to guard must be set!" |
| 518 | exit 1 |
| 519 | fi |
| 520 | cat << EOF >> "$ANDROIDMK" |
Rashed Abdel-Tawab | d53bff1 | 2016-10-02 01:00:54 -0400 | [diff] [blame] | 521 | ifneq (\$(filter $1,\$($GUARD)),) |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 522 | |
| 523 | EOF |
| 524 | fi |
| 525 | |
| 526 | write_header "$BOARDMK" |
| 527 | write_header "$PRODUCTMK" |
| 528 | } |
| 529 | |
| 530 | # |
| 531 | # write_footers: |
| 532 | # |
| 533 | # Closes the inital guard and any other finalization tasks. Must |
| 534 | # be called as the final step. |
| 535 | # |
| 536 | function write_footers() { |
| 537 | cat << EOF >> "$ANDROIDMK" |
| 538 | endif |
| 539 | EOF |
| 540 | } |
| 541 | |
| 542 | # Return success if adb is up and not in recovery |
| 543 | function _adb_connected { |
| 544 | { |
Steve Kondik | 7561d19 | 2016-09-01 21:40:27 -0700 | [diff] [blame] | 545 | if [[ "$(adb get-state)" == device ]] |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 546 | then |
| 547 | return 0 |
| 548 | fi |
| 549 | } 2>/dev/null |
| 550 | |
| 551 | return 1 |
| 552 | }; |
| 553 | |
| 554 | # |
Bruno Martins | 3b96ba5 | 2016-07-27 15:00:05 +0100 | [diff] [blame] | 555 | # parse_file_list: |
| 556 | # |
| 557 | # $1: input file |
Rashed Abdel-Tawab | 855fbdd | 2017-04-04 02:48:18 -0400 | [diff] [blame] | 558 | # $2: blob section in file - optional |
Bruno Martins | 3b96ba5 | 2016-07-27 15:00:05 +0100 | [diff] [blame] | 559 | # |
| 560 | # Sets PRODUCT_PACKAGES and PRODUCT_COPY_FILES while parsing the input file |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 561 | # |
| 562 | function parse_file_list() { |
Bruno Martins | 3b96ba5 | 2016-07-27 15:00:05 +0100 | [diff] [blame] | 563 | if [ -z "$1" ]; then |
| 564 | echo "An input file is expected!" |
| 565 | exit 1 |
| 566 | elif [ ! -f "$1" ]; then |
| 567 | echo "Input file "$1" does not exist!" |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 568 | exit 1 |
| 569 | fi |
| 570 | |
Rashed Abdel-Tawab | 855fbdd | 2017-04-04 02:48:18 -0400 | [diff] [blame] | 571 | if [ $# -eq 2 ]; then |
| 572 | LIST=$TMPDIR/files.txt |
| 573 | cat $1 | sed -n '/# '"$2"'/I,/^\s*$/p' > $LIST |
| 574 | else |
| 575 | LIST=$1 |
| 576 | fi |
| 577 | |
| 578 | |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 579 | PRODUCT_PACKAGES_LIST=() |
Steve Kondik | 48f8df8 | 2016-08-14 03:55:08 -0700 | [diff] [blame] | 580 | PRODUCT_PACKAGES_HASHES=() |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 581 | PRODUCT_COPY_FILES_LIST=() |
Steve Kondik | 48f8df8 | 2016-08-14 03:55:08 -0700 | [diff] [blame] | 582 | PRODUCT_COPY_FILES_HASHES=() |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 583 | |
| 584 | while read -r line; do |
| 585 | if [ -z "$line" ]; then continue; fi |
| 586 | |
Steve Kondik | 48f8df8 | 2016-08-14 03:55:08 -0700 | [diff] [blame] | 587 | # If the line has a pipe delimiter, a sha1 hash should follow. |
| 588 | # This indicates the file should be pinned and not overwritten |
| 589 | # when extracting files. |
| 590 | local SPLIT=(${line//\|/ }) |
| 591 | local COUNT=${#SPLIT[@]} |
| 592 | local SPEC=${SPLIT[0]} |
| 593 | local HASH="x" |
| 594 | if [ "$COUNT" -gt "1" ]; then |
| 595 | HASH=${SPLIT[1]} |
| 596 | fi |
| 597 | |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 598 | # if line starts with a dash, it needs to be packaged |
Steve Kondik | 48f8df8 | 2016-08-14 03:55:08 -0700 | [diff] [blame] | 599 | if [[ "$SPEC" =~ ^- ]]; then |
| 600 | PRODUCT_PACKAGES_LIST+=("${SPEC#-}") |
| 601 | PRODUCT_PACKAGES_HASHES+=("$HASH") |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 602 | else |
Steve Kondik | 48f8df8 | 2016-08-14 03:55:08 -0700 | [diff] [blame] | 603 | PRODUCT_COPY_FILES_LIST+=("$SPEC") |
| 604 | PRODUCT_COPY_FILES_HASHES+=("$HASH") |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 605 | fi |
| 606 | |
Rashed Abdel-Tawab | 855fbdd | 2017-04-04 02:48:18 -0400 | [diff] [blame] | 607 | done < <(egrep -v '(^#|^[[:space:]]*$)' "$LIST" | LC_ALL=C sort | uniq) |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 608 | } |
| 609 | |
| 610 | # |
| 611 | # write_makefiles: |
| 612 | # |
| 613 | # $1: file containing the list of items to extract |
| 614 | # |
| 615 | # Calls write_product_copy_files and write_product_packages on |
| 616 | # the given file and appends to the Android.mk as well as |
| 617 | # the product makefile. |
| 618 | # |
| 619 | function write_makefiles() { |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 620 | parse_file_list "$1" |
| 621 | write_product_copy_files |
| 622 | write_product_packages |
| 623 | } |
| 624 | |
| 625 | # |
Louis Popi | a516c2f | 2016-07-25 15:51:13 +0200 | [diff] [blame] | 626 | # append_firmware_calls_to_makefiles: |
| 627 | # |
| 628 | # Appends to Android.mk the calls to all images present in radio folder |
| 629 | # (filesmap file used by releasetools to map firmware images should be kept in the device tree) |
| 630 | # |
| 631 | function append_firmware_calls_to_makefiles() { |
| 632 | cat << EOF >> "$ANDROIDMK" |
| 633 | ifeq (\$(LOCAL_PATH)/radio, \$(wildcard \$(LOCAL_PATH)/radio)) |
| 634 | |
| 635 | RADIO_FILES := \$(wildcard \$(LOCAL_PATH)/radio/*) |
| 636 | \$(foreach f, \$(notdir \$(RADIO_FILES)), \\ |
| 637 | \$(call add-radio-file,radio/\$(f))) |
| 638 | \$(call add-radio-file,../../../device/$VENDOR/$DEVICE/radio/filesmap) |
| 639 | |
| 640 | endif |
| 641 | |
| 642 | EOF |
| 643 | } |
| 644 | |
| 645 | # |
Luca Stefani | 7f9fff2 | 2016-07-18 13:47:55 +0200 | [diff] [blame] | 646 | # get_file: |
| 647 | # |
| 648 | # $1: input file |
| 649 | # $2: target file/folder |
| 650 | # $3: source of the file (can be "adb" or a local folder) |
| 651 | # |
| 652 | # Silently extracts the input file to defined target |
| 653 | # Returns success if file can be pulled from the device or found locally |
| 654 | # |
| 655 | function get_file() { |
| 656 | local SRC="$3" |
| 657 | |
| 658 | if [ "$SRC" = "adb" ]; then |
| 659 | # try to pull |
| 660 | adb pull "$1" "$2" >/dev/null 2>&1 && return 0 |
| 661 | |
| 662 | return 1 |
| 663 | else |
| 664 | # try to copy |
Sam Mortimer | 2e994ce | 2016-10-05 09:50:49 -0700 | [diff] [blame] | 665 | cp -r "$SRC/$1" "$2" 2>/dev/null && return 0 |
Luca Stefani | 7f9fff2 | 2016-07-18 13:47:55 +0200 | [diff] [blame] | 666 | |
| 667 | return 1 |
| 668 | fi |
| 669 | }; |
| 670 | |
| 671 | # |
| 672 | # oat2dex: |
| 673 | # |
| 674 | # $1: extracted apk|jar (to check if deodex is required) |
| 675 | # $2: odexed apk|jar to deodex |
| 676 | # $3: source of the odexed apk|jar |
| 677 | # |
| 678 | # Convert apk|jar .odex in the corresposing classes.dex |
| 679 | # |
| 680 | function oat2dex() { |
Luca Stefani | 5c60e4f | 2017-08-17 19:28:48 +0200 | [diff] [blame] | 681 | local LINEAGE_TARGET="$1" |
Luca Stefani | 7f9fff2 | 2016-07-18 13:47:55 +0200 | [diff] [blame] | 682 | local OEM_TARGET="$2" |
| 683 | local SRC="$3" |
| 684 | local TARGET= |
| 685 | local OAT= |
| 686 | |
| 687 | if [ -z "$BAKSMALIJAR" ] || [ -z "$SMALIJAR" ]; then |
Luca Stefani | 5c60e4f | 2017-08-17 19:28:48 +0200 | [diff] [blame] | 688 | export BAKSMALIJAR="$LINEAGE_ROOT"/vendor/lineage/build/tools/smali/baksmali.jar |
| 689 | export SMALIJAR="$LINEAGE_ROOT"/vendor/lineage/build/tools/smali/smali.jar |
Luca Stefani | 7f9fff2 | 2016-07-18 13:47:55 +0200 | [diff] [blame] | 690 | fi |
| 691 | |
| 692 | # Extract existing boot.oats to the temp folder |
| 693 | if [ -z "$ARCHES" ]; then |
Sam Mortimer | 2e994ce | 2016-10-05 09:50:49 -0700 | [diff] [blame] | 694 | echo "Checking if system is odexed and locating boot.oats..." |
Luca Stefani | 7f9fff2 | 2016-07-18 13:47:55 +0200 | [diff] [blame] | 695 | for ARCH in "arm64" "arm" "x86_64" "x86"; do |
Sam Mortimer | 2e994ce | 2016-10-05 09:50:49 -0700 | [diff] [blame] | 696 | mkdir -p "$TMPDIR/system/framework/$ARCH" |
| 697 | if get_file "system/framework/$ARCH/" "$TMPDIR/system/framework/" "$SRC"; then |
Luca Stefani | 7f9fff2 | 2016-07-18 13:47:55 +0200 | [diff] [blame] | 698 | ARCHES+="$ARCH " |
Sam Mortimer | 2e994ce | 2016-10-05 09:50:49 -0700 | [diff] [blame] | 699 | else |
| 700 | rmdir "$TMPDIR/system/framework/$ARCH" |
Luca Stefani | 7f9fff2 | 2016-07-18 13:47:55 +0200 | [diff] [blame] | 701 | fi |
| 702 | done |
| 703 | fi |
| 704 | |
| 705 | if [ -z "$ARCHES" ]; then |
| 706 | FULLY_DEODEXED=1 && return 0 # system is fully deodexed, return |
| 707 | fi |
| 708 | |
Luca Stefani | 5c60e4f | 2017-08-17 19:28:48 +0200 | [diff] [blame] | 709 | if [ ! -f "$LINEAGE_TARGET" ]; then |
Steve Kondik | 48f8df8 | 2016-08-14 03:55:08 -0700 | [diff] [blame] | 710 | return; |
| 711 | fi |
| 712 | |
Luca Stefani | 5c60e4f | 2017-08-17 19:28:48 +0200 | [diff] [blame] | 713 | if grep "classes.dex" "$LINEAGE_TARGET" >/dev/null; then |
Luca Stefani | 7f9fff2 | 2016-07-18 13:47:55 +0200 | [diff] [blame] | 714 | return 0 # target apk|jar is already odexed, return |
| 715 | fi |
| 716 | |
| 717 | for ARCH in $ARCHES; do |
Sam Mortimer | 2e994ce | 2016-10-05 09:50:49 -0700 | [diff] [blame] | 718 | BOOTOAT="$TMPDIR/system/framework/$ARCH/boot.oat" |
Luca Stefani | 7f9fff2 | 2016-07-18 13:47:55 +0200 | [diff] [blame] | 719 | |
| 720 | local OAT="$(dirname "$OEM_TARGET")/oat/$ARCH/$(basename "$OEM_TARGET" ."${OEM_TARGET##*.}").odex" |
| 721 | |
| 722 | if get_file "$OAT" "$TMPDIR" "$SRC"; then |
Sam Mortimer | 2e994ce | 2016-10-05 09:50:49 -0700 | [diff] [blame] | 723 | java -jar "$BAKSMALIJAR" deodex -o "$TMPDIR/dexout" -b "$BOOTOAT" -d "$TMPDIR" "$TMPDIR/$(basename "$OAT")" |
Luca Stefani | 5c60e4f | 2017-08-17 19:28:48 +0200 | [diff] [blame] | 724 | elif [[ "$LINEAGE_TARGET" =~ .jar$ ]]; then |
Gabriele M | 4cf635a | 2017-01-05 22:10:00 +0100 | [diff] [blame] | 725 | # try to extract classes.dex from boot.oats for framework jars |
| 726 | JAROAT="$TMPDIR/system/framework/$ARCH/boot-$(basename ${OEM_TARGET%.*}).oat" |
| 727 | if [ ! -f "$JAROAT" ]; then |
| 728 | JAROAT=$BOOTOAT; |
| 729 | fi |
| 730 | java -jar "$BAKSMALIJAR" deodex -o "$TMPDIR/dexout" -b "$BOOTOAT" -d "$TMPDIR" "$JAROAT/$OEM_TARGET" |
Luca Stefani | 7f9fff2 | 2016-07-18 13:47:55 +0200 | [diff] [blame] | 731 | else |
| 732 | continue |
| 733 | fi |
| 734 | |
Sam Mortimer | 2e994ce | 2016-10-05 09:50:49 -0700 | [diff] [blame] | 735 | java -jar "$SMALIJAR" assemble "$TMPDIR/dexout" -o "$TMPDIR/classes.dex" && break |
Luca Stefani | 7f9fff2 | 2016-07-18 13:47:55 +0200 | [diff] [blame] | 736 | done |
| 737 | |
| 738 | rm -rf "$TMPDIR/dexout" |
| 739 | } |
| 740 | |
| 741 | # |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 742 | # init_adb_connection: |
| 743 | # |
| 744 | # Starts adb server and waits for the device |
| 745 | # |
| 746 | function init_adb_connection() { |
| 747 | adb start-server # Prevent unexpected starting server message from adb get-state in the next line |
| 748 | if ! _adb_connected; then |
| 749 | echo "No device is online. Waiting for one..." |
| 750 | echo "Please connect USB and/or enable USB debugging" |
| 751 | until _adb_connected; do |
| 752 | sleep 1 |
| 753 | done |
| 754 | echo "Device Found." |
| 755 | fi |
| 756 | |
| 757 | # Retrieve IP and PORT info if we're using a TCP connection |
| 758 | TCPIPPORT=$(adb devices | egrep '^[0-9]+\.[0-9]+\.[0-9]+\.[0-9]+:[0-9]+[^0-9]+' \ |
| 759 | | head -1 | awk '{print $1}') |
| 760 | adb root &> /dev/null |
| 761 | sleep 0.3 |
| 762 | if [ -n "$TCPIPPORT" ]; then |
| 763 | # adb root just killed our connection |
| 764 | # so reconnect... |
| 765 | adb connect "$TCPIPPORT" |
| 766 | fi |
| 767 | adb wait-for-device &> /dev/null |
| 768 | sleep 0.3 |
| 769 | } |
| 770 | |
| 771 | # |
Luca Stefani | 3a03012 | 2016-07-30 12:08:25 +0200 | [diff] [blame] | 772 | # fix_xml: |
| 773 | # |
| 774 | # $1: xml file to fix |
| 775 | # |
| 776 | function fix_xml() { |
| 777 | local XML="$1" |
| 778 | local TEMP_XML="$TMPDIR/`basename "$XML"`.temp" |
| 779 | |
Dobroslaw Kijowski | 65f03f1 | 2017-05-18 12:35:02 +0200 | [diff] [blame] | 780 | grep -a '^<?xml version' "$XML" > "$TEMP_XML" |
| 781 | grep -av '^<?xml version' "$XML" >> "$TEMP_XML" |
Luca Stefani | 3a03012 | 2016-07-30 12:08:25 +0200 | [diff] [blame] | 782 | |
| 783 | mv "$TEMP_XML" "$XML" |
| 784 | } |
| 785 | |
| 786 | # |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 787 | # extract: |
| 788 | # |
| 789 | # $1: file containing the list of items to extract |
Dan Pasanen | 7dc287f | 2017-03-21 09:06:11 -0500 | [diff] [blame] | 790 | # $2: path to extracted system folder, an ota zip file, or "adb" to extract from device |
Rashed Abdel-Tawab | 855fbdd | 2017-04-04 02:48:18 -0400 | [diff] [blame] | 791 | # $3: section in list file to extract - optional |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 792 | # |
| 793 | function extract() { |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 794 | if [ -z "$OUTDIR" ]; then |
| 795 | echo "Output dir not set!" |
| 796 | exit 1 |
| 797 | fi |
| 798 | |
Harry Youd | 9c5d129 | 2017-08-05 09:18:56 +0100 | [diff] [blame] | 799 | if [ -z "$3" ]; then |
| 800 | parse_file_list "$1" |
| 801 | else |
| 802 | parse_file_list "$1" "$3" |
| 803 | fi |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 804 | |
| 805 | # Allow failing, so we can try $DEST and/or $FILE |
| 806 | set +e |
| 807 | |
| 808 | local FILELIST=( ${PRODUCT_COPY_FILES_LIST[@]} ${PRODUCT_PACKAGES_LIST[@]} ) |
Steve Kondik | 48f8df8 | 2016-08-14 03:55:08 -0700 | [diff] [blame] | 809 | local HASHLIST=( ${PRODUCT_COPY_FILES_HASHES[@]} ${PRODUCT_PACKAGES_HASHES[@]} ) |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 810 | local COUNT=${#FILELIST[@]} |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 811 | local SRC="$2" |
Luca Stefani | 5c60e4f | 2017-08-17 19:28:48 +0200 | [diff] [blame] | 812 | local OUTPUT_ROOT="$LINEAGE_ROOT"/"$OUTDIR"/proprietary |
Steve Kondik | 48f8df8 | 2016-08-14 03:55:08 -0700 | [diff] [blame] | 813 | local OUTPUT_TMP="$TMPDIR"/"$OUTDIR"/proprietary |
| 814 | |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 815 | if [ "$SRC" = "adb" ]; then |
| 816 | init_adb_connection |
| 817 | fi |
| 818 | |
Dan Pasanen | 7dc287f | 2017-03-21 09:06:11 -0500 | [diff] [blame] | 819 | if [ -f "$SRC" ] && [ "${SRC##*.}" == "zip" ]; then |
Luca Stefani | 5c60e4f | 2017-08-17 19:28:48 +0200 | [diff] [blame] | 820 | DUMPDIR="$LINEAGE_ROOT"/system_dump |
Dan Pasanen | 7dc287f | 2017-03-21 09:06:11 -0500 | [diff] [blame] | 821 | |
| 822 | # Check if we're working with the same zip that was passed last time. |
| 823 | # If so, let's just use what's already extracted. |
| 824 | MD5=`md5sum "$SRC"| awk '{print $1}'` |
| 825 | OLDMD5=`cat "$DUMPDIR"/zipmd5.txt` |
| 826 | |
| 827 | if [ "$MD5" != "$OLDMD5" ]; then |
| 828 | rm -rf "$DUMPDIR" |
| 829 | mkdir "$DUMPDIR" |
| 830 | unzip "$SRC" -d "$DUMPDIR" |
| 831 | echo "$MD5" > "$DUMPDIR"/zipmd5.txt |
| 832 | |
| 833 | # Stop if an A/B OTA zip is detected. We cannot extract these. |
| 834 | if [ -a "$DUMPDIR"/payload.bin ]; then |
| 835 | echo "A/B style OTA zip detected. This is not supported at this time. Stopping..." |
| 836 | exit 1 |
| 837 | # If OTA is block based, extract it. |
| 838 | elif [ -a "$DUMPDIR"/system.new.dat ]; then |
| 839 | echo "Converting system.new.dat to system.img" |
Luca Stefani | 5c60e4f | 2017-08-17 19:28:48 +0200 | [diff] [blame] | 840 | python "$LINEAGE_ROOT"/vendor/lineage/build/tools/sdat2img.py "$DUMPDIR"/system.transfer.list "$DUMPDIR"/system.new.dat "$DUMPDIR"/system.img 2>&1 |
Dan Pasanen | 7dc287f | 2017-03-21 09:06:11 -0500 | [diff] [blame] | 841 | rm -rf "$DUMPDIR"/system.new.dat "$DUMPDIR"/system |
| 842 | mkdir "$DUMPDIR"/system "$DUMPDIR"/tmp |
| 843 | echo "Requesting sudo access to mount the system.img" |
| 844 | sudo mount -o loop "$DUMPDIR"/system.img "$DUMPDIR"/tmp |
| 845 | cp -r "$DUMPDIR"/tmp/* "$DUMPDIR"/system/ |
| 846 | sudo umount "$DUMPDIR"/tmp |
| 847 | rm -rf "$DUMPDIR"/tmp "$DUMPDIR"/system.img |
| 848 | fi |
| 849 | fi |
| 850 | |
| 851 | SRC="$DUMPDIR" |
| 852 | fi |
| 853 | |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 854 | if [ "$VENDOR_STATE" -eq "0" ]; then |
Steve Kondik | a991cf1 | 2016-07-28 12:13:12 -0700 | [diff] [blame] | 855 | echo "Cleaning output directory ($OUTPUT_ROOT).." |
Steve Kondik | 48f8df8 | 2016-08-14 03:55:08 -0700 | [diff] [blame] | 856 | rm -rf "${OUTPUT_TMP:?}" |
| 857 | mkdir -p "${OUTPUT_TMP:?}" |
Adrian DC | 3c6bdac | 2017-01-15 14:03:26 +0100 | [diff] [blame] | 858 | if [ -d "$OUTPUT_ROOT" ]; then |
| 859 | mv "${OUTPUT_ROOT:?}/"* "${OUTPUT_TMP:?}/" |
| 860 | fi |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 861 | VENDOR_STATE=1 |
| 862 | fi |
| 863 | |
| 864 | echo "Extracting $COUNT files in $1 from $SRC:" |
| 865 | |
| 866 | for (( i=1; i<COUNT+1; i++ )); do |
Steve Kondik | a991cf1 | 2016-07-28 12:13:12 -0700 | [diff] [blame] | 867 | |
| 868 | local FROM=$(target_file "${FILELIST[$i-1]}") |
| 869 | local ARGS=$(target_args "${FILELIST[$i-1]}") |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 870 | local SPLIT=(${FILELIST[$i-1]//:/ }) |
| 871 | local FILE="${SPLIT[0]#-}" |
Steve Kondik | a991cf1 | 2016-07-28 12:13:12 -0700 | [diff] [blame] | 872 | local OUTPUT_DIR="$OUTPUT_ROOT" |
Steve Kondik | 48f8df8 | 2016-08-14 03:55:08 -0700 | [diff] [blame] | 873 | local TMP_DIR="$OUTPUT_TMP" |
Steve Kondik | a991cf1 | 2016-07-28 12:13:12 -0700 | [diff] [blame] | 874 | local TARGET= |
| 875 | |
| 876 | if [ "$ARGS" = "rootfs" ]; then |
| 877 | TARGET="$FROM" |
| 878 | OUTPUT_DIR="$OUTPUT_DIR/rootfs" |
Steve Kondik | 48f8df8 | 2016-08-14 03:55:08 -0700 | [diff] [blame] | 879 | TMP_DIR="$TMP_DIR/rootfs" |
Rashed Abdel-Tawab | 8b87b09 | 2017-04-04 18:03:35 -0400 | [diff] [blame] | 880 | elif [ -f "$SRC/$FILE" ] && [ "$SRC" != "adb" ]; then |
| 881 | TARGET="$FROM" |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 882 | else |
Steve Kondik | a991cf1 | 2016-07-28 12:13:12 -0700 | [diff] [blame] | 883 | TARGET="system/$FROM" |
| 884 | FILE="system/$FILE" |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 885 | fi |
Steve Kondik | a991cf1 | 2016-07-28 12:13:12 -0700 | [diff] [blame] | 886 | |
| 887 | if [ "$SRC" = "adb" ]; then |
| 888 | printf ' - %s .. ' "/$TARGET" |
| 889 | else |
| 890 | printf ' - %s \n' "/$TARGET" |
| 891 | fi |
| 892 | |
| 893 | local DIR=$(dirname "$FROM") |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 894 | if [ ! -d "$OUTPUT_DIR/$DIR" ]; then |
| 895 | mkdir -p "$OUTPUT_DIR/$DIR" |
| 896 | fi |
Steve Kondik | a991cf1 | 2016-07-28 12:13:12 -0700 | [diff] [blame] | 897 | local DEST="$OUTPUT_DIR/$FROM" |
| 898 | |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 899 | if [ "$SRC" = "adb" ]; then |
Luca Stefani | 5c60e4f | 2017-08-17 19:28:48 +0200 | [diff] [blame] | 900 | # Try Lineage target first |
Steve Kondik | a991cf1 | 2016-07-28 12:13:12 -0700 | [diff] [blame] | 901 | adb pull "/$TARGET" "$DEST" |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 902 | # if file does not exist try OEM target |
| 903 | if [ "$?" != "0" ]; then |
Steve Kondik | a991cf1 | 2016-07-28 12:13:12 -0700 | [diff] [blame] | 904 | adb pull "/$FILE" "$DEST" |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 905 | fi |
| 906 | else |
Luca Stefani | 5c60e4f | 2017-08-17 19:28:48 +0200 | [diff] [blame] | 907 | # Try Lineage target first |
Christopher R. Palmer | 052d9d9 | 2017-03-04 05:12:29 -0500 | [diff] [blame] | 908 | if [ -f "$SRC/$TARGET" ]; then |
Steve Kondik | a991cf1 | 2016-07-28 12:13:12 -0700 | [diff] [blame] | 909 | cp "$SRC/$TARGET" "$DEST" |
Christopher R. Palmer | 052d9d9 | 2017-03-04 05:12:29 -0500 | [diff] [blame] | 910 | # if file does not exist try OEM target |
| 911 | elif [ -f "$SRC/$FILE" ]; then |
| 912 | cp "$SRC/$FILE" "$DEST" |
Steve Kondik | 48f8df8 | 2016-08-14 03:55:08 -0700 | [diff] [blame] | 913 | else |
| 914 | printf ' !! file not found in source\n' |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 915 | fi |
| 916 | fi |
Steve Kondik | a991cf1 | 2016-07-28 12:13:12 -0700 | [diff] [blame] | 917 | |
Luca Stefani | 7f9fff2 | 2016-07-18 13:47:55 +0200 | [diff] [blame] | 918 | if [ "$?" == "0" ]; then |
| 919 | # Deodex apk|jar if that's the case |
| 920 | if [[ "$FULLY_DEODEXED" -ne "1" && "$DEST" =~ .(apk|jar)$ ]]; then |
| 921 | oat2dex "$DEST" "$FILE" "$SRC" |
| 922 | if [ -f "$TMPDIR/classes.dex" ]; then |
| 923 | zip -gjq "$DEST" "$TMPDIR/classes.dex" |
| 924 | rm "$TMPDIR/classes.dex" |
| 925 | printf ' (updated %s from odex files)\n' "/$FILE" |
| 926 | fi |
Luca Stefani | 3a03012 | 2016-07-30 12:08:25 +0200 | [diff] [blame] | 927 | elif [[ "$DEST" =~ .xml$ ]]; then |
| 928 | fix_xml "$DEST" |
Luca Stefani | 7f9fff2 | 2016-07-18 13:47:55 +0200 | [diff] [blame] | 929 | fi |
| 930 | fi |
| 931 | |
Steve Kondik | 48f8df8 | 2016-08-14 03:55:08 -0700 | [diff] [blame] | 932 | # Check pinned files |
| 933 | local HASH="${HASHLIST[$i-1]}" |
Steve Kondik | 79fa59b | 2016-09-02 21:10:02 -0700 | [diff] [blame] | 934 | if [ "$DISABLE_PINNING" != "1" ] && [ ! -z "$HASH" ] && [ "$HASH" != "x" ]; then |
Steve Kondik | 48f8df8 | 2016-08-14 03:55:08 -0700 | [diff] [blame] | 935 | local KEEP="" |
| 936 | local TMP="$TMP_DIR/$FROM" |
| 937 | if [ -f "$TMP" ]; then |
| 938 | if [ ! -f "$DEST" ]; then |
| 939 | KEEP="1" |
| 940 | else |
Rashed Abdel-Tawab | 5b38c4f | 2016-11-23 23:00:37 -0500 | [diff] [blame] | 941 | if [ "$(uname)" == "Darwin" ]; then |
| 942 | local DEST_HASH=$(shasum "$DEST" | awk '{print $1}' ) |
| 943 | else |
| 944 | local DEST_HASH=$(sha1sum "$DEST" | awk '{print $1}' ) |
| 945 | fi |
Steve Kondik | 48f8df8 | 2016-08-14 03:55:08 -0700 | [diff] [blame] | 946 | if [ "$DEST_HASH" != "$HASH" ]; then |
| 947 | KEEP="1" |
| 948 | fi |
| 949 | fi |
| 950 | if [ "$KEEP" = "1" ]; then |
Rashed Abdel-Tawab | 5b38c4f | 2016-11-23 23:00:37 -0500 | [diff] [blame] | 951 | if [ "$(uname)" == "Darwin" ]; then |
| 952 | local TMP_HASH=$(shasum "$TMP" | awk '{print $1}' ) |
| 953 | else |
| 954 | local TMP_HASH=$(sha1sum "$TMP" | awk '{print $1}' ) |
| 955 | fi |
Steve Kondik | 48f8df8 | 2016-08-14 03:55:08 -0700 | [diff] [blame] | 956 | if [ "$TMP_HASH" = "$HASH" ]; then |
| 957 | printf ' + (keeping pinned file with hash %s)\n' "$HASH" |
| 958 | cp -p "$TMP" "$DEST" |
| 959 | fi |
| 960 | fi |
| 961 | fi |
Steve Kondik | a991cf1 | 2016-07-28 12:13:12 -0700 | [diff] [blame] | 962 | fi |
Steve Kondik | 48f8df8 | 2016-08-14 03:55:08 -0700 | [diff] [blame] | 963 | |
| 964 | if [ -f "$DEST" ]; then |
| 965 | local TYPE="${DIR##*/}" |
| 966 | if [ "$TYPE" = "bin" -o "$TYPE" = "sbin" ]; then |
| 967 | chmod 755 "$DEST" |
| 968 | else |
| 969 | chmod 644 "$DEST" |
| 970 | fi |
| 971 | fi |
| 972 | |
Steve Kondik | 4e2aaab | 2016-07-15 10:39:58 -0700 | [diff] [blame] | 973 | done |
| 974 | |
| 975 | # Don't allow failing |
| 976 | set -e |
| 977 | } |
Louis Popi | a516c2f | 2016-07-25 15:51:13 +0200 | [diff] [blame] | 978 | |
| 979 | # |
| 980 | # extract_firmware: |
| 981 | # |
| 982 | # $1: file containing the list of items to extract |
| 983 | # $2: path to extracted radio folder |
| 984 | # |
| 985 | function extract_firmware() { |
| 986 | if [ -z "$OUTDIR" ]; then |
| 987 | echo "Output dir not set!" |
| 988 | exit 1 |
| 989 | fi |
| 990 | |
| 991 | parse_file_list "$1" |
| 992 | |
| 993 | # Don't allow failing |
| 994 | set -e |
| 995 | |
| 996 | local FILELIST=( ${PRODUCT_COPY_FILES_LIST[@]} ) |
| 997 | local COUNT=${#FILELIST[@]} |
| 998 | local SRC="$2" |
Luca Stefani | 5c60e4f | 2017-08-17 19:28:48 +0200 | [diff] [blame] | 999 | local OUTPUT_DIR="$LINEAGE_ROOT"/"$OUTDIR"/radio |
Louis Popi | a516c2f | 2016-07-25 15:51:13 +0200 | [diff] [blame] | 1000 | |
| 1001 | if [ "$VENDOR_RADIO_STATE" -eq "0" ]; then |
| 1002 | echo "Cleaning firmware output directory ($OUTPUT_DIR).." |
| 1003 | rm -rf "${OUTPUT_DIR:?}/"* |
| 1004 | VENDOR_RADIO_STATE=1 |
| 1005 | fi |
| 1006 | |
| 1007 | echo "Extracting $COUNT files in $1 from $SRC:" |
| 1008 | |
| 1009 | for (( i=1; i<COUNT+1; i++ )); do |
| 1010 | local FILE="${FILELIST[$i-1]}" |
| 1011 | printf ' - %s \n' "/radio/$FILE" |
| 1012 | |
| 1013 | if [ ! -d "$OUTPUT_DIR" ]; then |
| 1014 | mkdir -p "$OUTPUT_DIR" |
| 1015 | fi |
| 1016 | cp "$SRC/$FILE" "$OUTPUT_DIR/$FILE" |
| 1017 | chmod 644 "$OUTPUT_DIR/$FILE" |
| 1018 | done |
| 1019 | } |