| 1 |
/* |
| 2 |
* Copyright (C) 2022 The Android Open Source Project |
| 3 |
* |
| 4 |
* Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 |
* you may not use this file except in compliance with the License. |
| 6 |
* You may obtain a copy of the License at |
| 7 |
* |
| 8 |
* http://www.apache.org/licenses/LICENSE-2.0 |
| 9 |
* |
| 10 |
* Unless required by applicable law or agreed to in writing, software |
| 11 |
* distributed under the License is distributed on an "AS IS" BASIS, |
| 12 |
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 |
* See the License for the specific language governing permissions and |
| 14 |
* limitations under the License. |
| 15 |
*/ |
| 16 |
|
| 17 |
package com.android.server.art; |
| 18 |
|
| 19 |
import static com.android.server.art.ProfilePath.TmpProfilePath; |
| 20 |
|
| 21 |
import android.R; |
| 22 |
import android.annotation.NonNull; |
| 23 |
import android.annotation.Nullable; |
| 24 |
import android.app.role.RoleManager; |
| 25 |
import android.apphibernation.AppHibernationManager; |
| 26 |
import android.content.Context; |
| 27 |
import android.os.Build; |
| 28 |
import android.os.DeadObjectException; |
| 29 |
import android.os.RemoteException; |
| 30 |
import android.os.ServiceSpecificException; |
| 31 |
import android.os.SystemClock; |
| 32 |
import android.os.SystemProperties; |
| 33 |
import android.os.Trace; |
| 34 |
import android.os.UserManager; |
| 35 |
import android.text.TextUtils; |
| 36 |
import android.util.Log; |
| 37 |
import android.util.Pair; |
| 38 |
import android.util.Slog; |
| 39 |
import android.util.SparseArray; |
| 40 |
|
| 41 |
import androidx.annotation.RequiresApi; |
| 42 |
|
| 43 |
import com.android.modules.utils.pm.PackageStateModulesUtils; |
| 44 |
import com.android.server.art.model.DexoptParams; |
| 45 |
import com.android.server.pm.PackageManagerLocal; |
| 46 |
import com.android.server.pm.pkg.AndroidPackage; |
| 47 |
import com.android.server.pm.pkg.PackageState; |
| 48 |
|
| 49 |
import dalvik.system.DexFile; |
| 50 |
import dalvik.system.VMRuntime; |
| 51 |
|
| 52 |
import com.google.auto.value.AutoValue; |
| 53 |
|
| 54 |
import java.io.File; |
| 55 |
import java.io.IOException; |
| 56 |
import java.nio.file.Files; |
| 57 |
import java.nio.file.Path; |
| 58 |
import java.util.ArrayList; |
| 59 |
import java.util.Collection; |
| 60 |
import java.util.Comparator; |
| 61 |
import java.util.List; |
| 62 |
import java.util.Set; |
| 63 |
import java.util.concurrent.CompletableFuture; |
| 64 |
import java.util.concurrent.ExecutionException; |
| 65 |
import java.util.concurrent.Executor; |
| 66 |
import java.util.concurrent.Future; |
| 67 |
import java.util.stream.Collectors; |
| 68 |
|
| 69 |
/** @hide */ |
| 70 |
@RequiresApi(Build.VERSION_CODES.UPSIDE_DOWN_CAKE) |
| 71 |
public final class Utils { |
| 72 |
public static final String TAG = ArtManagerLocal.TAG; |
| 73 |
public static final String PLATFORM_PACKAGE_NAME = "android"; |
| 74 |
|
| 75 |
/** A copy of {@link android.os.Trace.TRACE_TAG_DALVIK}. */ |
| 76 |
private static final long TRACE_TAG_DALVIK = 1L << 14; |
| 77 |
|
| 78 |
private Utils() {} |
| 79 |
|
| 80 |
/** |
| 81 |
* Checks if given array is null or has zero elements. |
| 82 |
*/ |
| 83 |
public static <T> boolean isEmpty(@Nullable Collection<T> array) { |
| 84 |
return array == null || array.isEmpty(); |
| 85 |
} |
| 86 |
|
| 87 |
/** |
| 88 |
* Checks if given array is null or has zero elements. |
| 89 |
*/ |
| 90 |
public static <T> boolean isEmpty(@Nullable SparseArray<T> array) { |
| 91 |
return array == null || array.size() == 0; |
| 92 |
} |
| 93 |
|
| 94 |
/** |
| 95 |
* Checks if given array is null or has zero elements. |
| 96 |
*/ |
| 97 |
public static boolean isEmpty(@Nullable int[] array) { |
| 98 |
return array == null || array.length == 0; |
| 99 |
} |
| 100 |
|
| 101 |
/** Returns the ABI information for the package. The primary ABI comes first. */ |
| 102 |
@NonNull |
| 103 |
public static List<Abi> getAllAbis(@NonNull PackageState pkgState) { |
| 104 |
List<Abi> abis = new ArrayList<>(); |
| 105 |
abis.add(getPrimaryAbi(pkgState)); |
| 106 |
String pkgPrimaryCpuAbi = pkgState.getPrimaryCpuAbi(); |
| 107 |
String pkgSecondaryCpuAbi = pkgState.getSecondaryCpuAbi(); |
| 108 |
if (pkgSecondaryCpuAbi != null) { |
| 109 |
Utils.check(pkgState.getPrimaryCpuAbi() != null); |
| 110 |
String isa = getTranslatedIsa(VMRuntime.getInstructionSet(pkgSecondaryCpuAbi)); |
| 111 |
abis.add(Abi.create(nativeIsaToAbi(isa), isa, false /* isPrimaryAbi */)); |
| 112 |
} |
| 113 |
// Primary and secondary ABIs should be guaranteed to have different ISAs. |
| 114 |
if (abis.size() == 2 && abis.get(0).isa().equals(abis.get(1).isa())) { |
| 115 |
throw new IllegalStateException(String.format( |
| 116 |
"Duplicate ISA: primary ABI '%s' ('%s'), secondary ABI '%s' ('%s')", |
| 117 |
pkgPrimaryCpuAbi, abis.get(0).name(), pkgSecondaryCpuAbi, abis.get(1).name())); |
| 118 |
} |
| 119 |
return abis; |
| 120 |
} |
| 121 |
|
| 122 |
/** |
| 123 |
* Returns the ABI information for the ABIs with the given names. The primary ABI comes first, |
| 124 |
* if given. |
| 125 |
*/ |
| 126 |
@NonNull |
| 127 |
public static List<Abi> getAllAbisForNames( |
| 128 |
@NonNull Set<String> abiNames, @NonNull PackageState pkgState) { |
| 129 |
Utils.check(abiNames.stream().allMatch(Utils::isNativeAbi)); |
| 130 |
Abi pkgPrimaryAbi = getPrimaryAbi(pkgState); |
| 131 |
return abiNames.stream() |
| 132 |
.map(name |
| 133 |
-> Abi.create(name, VMRuntime.getInstructionSet(name), |
| 134 |
name.equals(pkgPrimaryAbi.name()))) |
| 135 |
.sorted(Comparator.comparing(Abi::isPrimaryAbi).reversed()) |
| 136 |
.collect(Collectors.toList()); |
| 137 |
} |
| 138 |
|
| 139 |
@NonNull |
| 140 |
public static Abi getPrimaryAbi(@NonNull PackageState pkgState) { |
| 141 |
String primaryCpuAbi = pkgState.getPrimaryCpuAbi(); |
| 142 |
if (primaryCpuAbi != null) { |
| 143 |
String isa = getTranslatedIsa(VMRuntime.getInstructionSet(primaryCpuAbi)); |
| 144 |
return Abi.create(nativeIsaToAbi(isa), isa, true /* isPrimaryAbi */); |
| 145 |
} |
| 146 |
// This is the most common case. The package manager can't infer the ABIs, probably because |
| 147 |
// the package doesn't contain any native library. The app is launched with the device's |
| 148 |
// preferred ABI. |
| 149 |
String preferredAbi = Constants.getPreferredAbi(); |
| 150 |
Utils.check(isNativeAbi(preferredAbi)); |
| 151 |
return Abi.create( |
| 152 |
preferredAbi, VMRuntime.getInstructionSet(preferredAbi), true /* isPrimaryAbi */); |
| 153 |
} |
| 154 |
|
| 155 |
/** |
| 156 |
* If the given ISA isn't native to the device, returns the ISA that the native bridge |
| 157 |
* translates it to. Otherwise, returns the ISA as is. This is the ISA that the app is actually |
| 158 |
* launched with and therefore the ISA that should be used to compile the app. |
| 159 |
*/ |
| 160 |
@NonNull |
| 161 |
private static String getTranslatedIsa(@NonNull String isa) { |
| 162 |
String abi64 = Constants.getNative64BitAbi(); |
| 163 |
String abi32 = Constants.getNative32BitAbi(); |
| 164 |
if ((abi64 != null && isa.equals(VMRuntime.getInstructionSet(abi64))) |
| 165 |
|| (abi32 != null && isa.equals(VMRuntime.getInstructionSet(abi32)))) { |
| 166 |
return isa; |
| 167 |
} |
| 168 |
String translatedIsa = SystemProperties.get("ro.dalvik.vm.isa." + isa); |
| 169 |
if (TextUtils.isEmpty(translatedIsa)) { |
| 170 |
throw new IllegalStateException(String.format("Unsupported isa '%s'", isa)); |
| 171 |
} |
| 172 |
return translatedIsa; |
| 173 |
} |
| 174 |
|
| 175 |
@NonNull |
| 176 |
private static String nativeIsaToAbi(@NonNull String isa) { |
| 177 |
String abi64 = Constants.getNative64BitAbi(); |
| 178 |
if (abi64 != null && isa.equals(VMRuntime.getInstructionSet(abi64))) { |
| 179 |
return abi64; |
| 180 |
} |
| 181 |
String abi32 = Constants.getNative32BitAbi(); |
| 182 |
if (abi32 != null && isa.equals(VMRuntime.getInstructionSet(abi32))) { |
| 183 |
return abi32; |
| 184 |
} |
| 185 |
throw new IllegalStateException(String.format("Non-native isa '%s'", isa)); |
| 186 |
} |
| 187 |
|
| 188 |
private static boolean isNativeAbi(@NonNull String abiName) { |
| 189 |
return abiName.equals(Constants.getNative64BitAbi()) |
| 190 |
|| abiName.equals(Constants.getNative32BitAbi()); |
| 191 |
} |
| 192 |
|
| 193 |
/** |
| 194 |
* Returns whether the artifacts of the primary dex files should be in the global dalvik-cache |
| 195 |
* directory. |
| 196 |
* |
| 197 |
* This method is not needed for secondary dex files because they are always in writable |
| 198 |
* locations. |
| 199 |
*/ |
| 200 |
@NonNull |
| 201 |
public static boolean isInDalvikCache(@NonNull PackageState pkgState, @NonNull IArtd artd) |
| 202 |
throws RemoteException { |
| 203 |
// The artifacts should be in the global dalvik-cache directory if: |
| 204 |
// (1). the package is on a system partition, even if the partition is remounted read-write, |
| 205 |
// or |
| 206 |
// (2). the package is in any other readonly location. (At the time of writing, this only |
| 207 |
// include Incremental FS.) |
| 208 |
// |
| 209 |
// Right now, we are using some heuristics to determine this. For (1), we can potentially |
| 210 |
// use "libfstab" instead as a general solution, but for (2), unfortunately, we have to |
| 211 |
// stick with heuristics. |
| 212 |
// |
| 213 |
// We cannot rely on access(2) because: |
| 214 |
// - It doesn't take effective capabilities into account, from which artd gets root access |
| 215 |
// to the filesystem. |
| 216 |
// - The `faccessat` variant with the `AT_EACCESS` flag, which takes effective capabilities |
| 217 |
// into account, is not supported by bionic. |
| 218 |
// |
| 219 |
// We cannot rely on `f_flags` returned by statfs(2) because: |
| 220 |
// - Incremental FS is tagged as read-write while it's actually not. |
| 221 |
return (pkgState.isSystem() && !pkgState.isUpdatedSystemApp()) |
| 222 |
|| artd.isIncrementalFsPath( |
| 223 |
pkgState.getAndroidPackage().getSplits().get(0).getPath()); |
| 224 |
} |
| 225 |
|
| 226 |
/** Returns true if the given string is a valid compiler filter. */ |
| 227 |
public static boolean isValidArtServiceCompilerFilter(@NonNull String compilerFilter) { |
| 228 |
if (compilerFilter.equals(DexoptParams.COMPILER_FILTER_NOOP)) { |
| 229 |
return true; |
| 230 |
} |
| 231 |
return DexFile.isValidCompilerFilter(compilerFilter); |
| 232 |
} |
| 233 |
|
| 234 |
@NonNull |
| 235 |
public static IArtd getArtd() { |
| 236 |
IArtd artd = IArtd.Stub.asInterface(ArtModuleServiceInitializer.getArtModuleServiceManager() |
| 237 |
.getArtdServiceRegisterer() |
| 238 |
.waitForService()); |
| 239 |
if (artd == null) { |
| 240 |
throw new IllegalStateException("Unable to connect to artd"); |
| 241 |
} |
| 242 |
return artd; |
| 243 |
} |
| 244 |
|
| 245 |
public static boolean implies(boolean cond1, boolean cond2) { |
| 246 |
return cond1 ? cond2 : true; |
| 247 |
} |
| 248 |
|
| 249 |
public static void check(boolean cond) { |
| 250 |
// This cannot be replaced with `assert` because `assert` is not enabled in Android. |
| 251 |
if (!cond) { |
| 252 |
throw new IllegalStateException("Check failed"); |
| 253 |
} |
| 254 |
} |
| 255 |
|
| 256 |
@NonNull |
| 257 |
public static PackageState getPackageStateOrThrow( |
| 258 |
@NonNull PackageManagerLocal.FilteredSnapshot snapshot, @NonNull String packageName) { |
| 259 |
PackageState pkgState = snapshot.getPackageState(packageName); |
| 260 |
if (pkgState == null) { |
| 261 |
throw new IllegalArgumentException("Package not found: " + packageName); |
| 262 |
} |
| 263 |
return pkgState; |
| 264 |
} |
| 265 |
|
| 266 |
@NonNull |
| 267 |
public static AndroidPackage getPackageOrThrow(@NonNull PackageState pkgState) { |
| 268 |
AndroidPackage pkg = pkgState.getAndroidPackage(); |
| 269 |
if (pkg == null) { |
| 270 |
throw new IllegalArgumentException( |
| 271 |
"Unable to get package " + pkgState.getPackageName()); |
| 272 |
} |
| 273 |
return pkg; |
| 274 |
} |
| 275 |
|
| 276 |
@NonNull |
| 277 |
public static String assertNonEmpty(@Nullable String str) { |
| 278 |
if (TextUtils.isEmpty(str)) { |
| 279 |
throw new IllegalArgumentException(); |
| 280 |
} |
| 281 |
return str; |
| 282 |
} |
| 283 |
|
| 284 |
public static void executeAndWait(@NonNull Executor executor, @NonNull Runnable runnable) { |
| 285 |
getFuture(CompletableFuture.runAsync(runnable, executor)); |
| 286 |
} |
| 287 |
|
| 288 |
public static <T> T getFuture(Future<T> future) { |
| 289 |
try { |
| 290 |
return future.get(); |
| 291 |
} catch (ExecutionException e) { |
| 292 |
Throwable cause = e.getCause(); |
| 293 |
if (cause instanceof RuntimeException) { |
| 294 |
throw (RuntimeException) cause; |
| 295 |
} |
| 296 |
throw new RuntimeException(cause); |
| 297 |
} catch (InterruptedException e) { |
| 298 |
throw new RuntimeException(e); |
| 299 |
} |
| 300 |
} |
| 301 |
|
| 302 |
/** |
| 303 |
* Returns true if the given package is dexoptable. |
| 304 |
* |
| 305 |
* @param appHibernationManager the {@link AppHibernationManager} instance for checking |
| 306 |
* hibernation status, or null to skip the check |
| 307 |
*/ |
| 308 |
public static boolean canDexoptPackage( |
| 309 |
@NonNull PackageState pkgState, @Nullable AppHibernationManager appHibernationManager) { |
| 310 |
if (!PackageStateModulesUtils.isDexoptable(pkgState)) { |
| 311 |
return false; |
| 312 |
} |
| 313 |
|
| 314 |
// We do not dexopt unused packages. |
| 315 |
// If `appHibernationManager` is null, the caller's intention is to skip the check. |
| 316 |
if (appHibernationManager != null |
| 317 |
&& shouldSkipDexoptDueToHibernation(pkgState, appHibernationManager)) { |
| 318 |
return false; |
| 319 |
} |
| 320 |
|
| 321 |
return true; |
| 322 |
} |
| 323 |
|
| 324 |
public static boolean shouldSkipDexoptDueToHibernation( |
| 325 |
@NonNull PackageState pkgState, @NonNull AppHibernationManager appHibernationManager) { |
| 326 |
return appHibernationManager.isHibernatingGlobally(pkgState.getPackageName()) |
| 327 |
&& appHibernationManager.isOatArtifactDeletionEnabled(); |
| 328 |
} |
| 329 |
|
| 330 |
public static long getPackageLastActiveTime(@NonNull PackageState pkgState, |
| 331 |
@NonNull DexUseManagerLocal dexUseManager, @NonNull UserManager userManager) { |
| 332 |
long lastUsedAtMs = dexUseManager.getPackageLastUsedAtMs(pkgState.getPackageName()); |
| 333 |
// The time where the last user installed the package the first time. |
| 334 |
long lastFirstInstallTimeMs = |
| 335 |
userManager.getUserHandles(true /* excludeDying */) |
| 336 |
.stream() |
| 337 |
.map(handle -> pkgState.getStateForUser(handle)) |
| 338 |
.map(userState -> userState.getFirstInstallTimeMillis()) |
| 339 |
.max(Long::compare) |
| 340 |
.orElse(0l); |
| 341 |
return Math.max(lastUsedAtMs, lastFirstInstallTimeMs); |
| 342 |
} |
| 343 |
|
| 344 |
public static void deleteIfExistsSafe(@Nullable File file) { |
| 345 |
if (file != null) { |
| 346 |
deleteIfExistsSafe(file.toPath()); |
| 347 |
} |
| 348 |
} |
| 349 |
|
| 350 |
public static void deleteIfExistsSafe(@NonNull Path path) { |
| 351 |
try { |
| 352 |
Files.deleteIfExists(path); |
| 353 |
} catch (IOException e) { |
| 354 |
Log.e(TAG, "Failed to delete file '" + path + "'", e); |
| 355 |
} |
| 356 |
} |
| 357 |
|
| 358 |
public static boolean isSystemUiPackage(@NonNull Context context, @NonNull String packageName) { |
| 359 |
return packageName.equals(context.getString(R.string.config_systemUi)); |
| 360 |
} |
| 361 |
|
| 362 |
public static boolean isLauncherPackage(@NonNull Context context, @NonNull String packageName) { |
| 363 |
RoleManager roleManager = context.getSystemService(RoleManager.class); |
| 364 |
return roleManager.getRoleHolders(RoleManager.ROLE_HOME).contains(packageName); |
| 365 |
} |
| 366 |
|
| 367 |
/** |
| 368 |
* Gets the existing reference profile if one exists, or initializes a reference profile from an |
| 369 |
* external profile. |
| 370 |
* |
| 371 |
* If the reference profile is initialized from an external profile, the returned profile path |
| 372 |
* will be a {@link TmpProfilePath}. It's the callers responsibility to either commit it to the |
| 373 |
* final location by calling {@link IArtd#commitTmpProfile} or clean it up by calling {@link |
| 374 |
* IArtd#deleteProfile}. |
| 375 |
* |
| 376 |
* @param dexPath the path to the dex file that the profile is checked against |
| 377 |
* @param refProfile the path where an existing reference profile would be found, if present |
| 378 |
* @param externalProfiles a list of external profiles to initialize the reference profile from, |
| 379 |
* in the order of preference |
| 380 |
* @param initOutput the final location to initialize the reference profile to |
| 381 |
* |
| 382 |
* @return a pair where the first element is the found or initialized profile, and the second |
| 383 |
* element is true if the profile is readable by others. Returns null if there is no |
| 384 |
* reference profile or external profile to use |
| 385 |
*/ |
| 386 |
@Nullable |
| 387 |
public static Pair<ProfilePath, Boolean> getOrInitReferenceProfile(@NonNull IArtd artd, |
| 388 |
@NonNull String dexPath, @NonNull ProfilePath refProfile, |
| 389 |
@NonNull List<ProfilePath> externalProfiles, @NonNull OutputProfile initOutput) |
| 390 |
throws RemoteException { |
| 391 |
try { |
| 392 |
if (artd.isProfileUsable(refProfile, dexPath)) { |
| 393 |
boolean isOtherReadable = |
| 394 |
artd.getProfileVisibility(refProfile) == FileVisibility.OTHER_READABLE; |
| 395 |
return Pair.create(refProfile, isOtherReadable); |
| 396 |
} |
| 397 |
} catch (ServiceSpecificException e) { |
| 398 |
Log.e(TAG, |
| 399 |
"Failed to use the existing reference profile " |
| 400 |
+ AidlUtils.toString(refProfile), |
| 401 |
e); |
| 402 |
} |
| 403 |
|
| 404 |
ProfilePath initializedProfile = |
| 405 |
initReferenceProfile(artd, dexPath, externalProfiles, initOutput); |
| 406 |
return initializedProfile != null ? Pair.create(initializedProfile, true) : null; |
| 407 |
} |
| 408 |
|
| 409 |
/** |
| 410 |
* Similar to above, but never uses an existing profile. |
| 411 |
* |
| 412 |
* Unlike the one above, this method doesn't return a boolean flag to indicate if the profile is |
| 413 |
* readable by others. The profile returned by this method is initialized form an external |
| 414 |
* profile, meaning it has no user data, so it's always readable by others. |
| 415 |
*/ |
| 416 |
@Nullable |
| 417 |
public static ProfilePath initReferenceProfile(@NonNull IArtd artd, @NonNull String dexPath, |
| 418 |
@NonNull List<ProfilePath> externalProfiles, @NonNull OutputProfile output) |
| 419 |
throws RemoteException { |
| 420 |
for (ProfilePath profile : externalProfiles) { |
| 421 |
try { |
| 422 |
// If the profile path is a PrebuiltProfilePath, and the APK is really a prebuilt |
| 423 |
// one, rewriting the profile is unnecessary because the dex location is known at |
| 424 |
// build time and is correctly set in the profile header. However, the APK can also |
| 425 |
// be an installed one, in which case partners may place a profile file next to the |
| 426 |
// APK at install time. Rewriting the profile in the latter case is necessary. |
| 427 |
if (artd.copyAndRewriteProfile(profile, output, dexPath)) { |
| 428 |
return ProfilePath.tmpProfilePath(output.profilePath); |
| 429 |
} |
| 430 |
} catch (ServiceSpecificException e) { |
| 431 |
Log.e(TAG, "Failed to initialize profile from " + AidlUtils.toString(profile), e); |
| 432 |
} |
| 433 |
} |
| 434 |
|
| 435 |
return null; |
| 436 |
} |
| 437 |
|
| 438 |
public static void logArtdException(@NonNull RemoteException e) { |
| 439 |
String message = "An error occurred when calling artd"; |
| 440 |
if (e instanceof DeadObjectException) { |
| 441 |
// We assume that `DeadObjectException` only happens in two cases: |
| 442 |
// 1. artd crashed, in which case a native stack trace was logged. |
| 443 |
// 2. artd was killed before system server during device shutdown, in which case the |
| 444 |
// exception is expected. |
| 445 |
// In either case, we don't need to surface the exception from here. |
| 446 |
// The Java stack trace is intentionally omitted because it's not helpful. |
| 447 |
Log.e(TAG, message); |
| 448 |
} else { |
| 449 |
// Not expected. Log wtf to surface it. |
| 450 |
Slog.wtf(TAG, message, e); |
| 451 |
} |
| 452 |
} |
| 453 |
|
| 454 |
@AutoValue |
| 455 |
public abstract static class Abi { |
| 456 |
static @NonNull Abi create( |
| 457 |
@NonNull String name, @NonNull String isa, boolean isPrimaryAbi) { |
| 458 |
return new AutoValue_Utils_Abi(name, isa, isPrimaryAbi); |
| 459 |
} |
| 460 |
|
| 461 |
// The ABI name. E.g., "arm64-v8a". |
| 462 |
abstract @NonNull String name(); |
| 463 |
|
| 464 |
// The instruction set name. E.g., "arm64". |
| 465 |
abstract @NonNull String isa(); |
| 466 |
|
| 467 |
abstract boolean isPrimaryAbi(); |
| 468 |
} |
| 469 |
|
| 470 |
public static class Tracing implements AutoCloseable { |
| 471 |
public Tracing(@NonNull String methodName) { |
| 472 |
Trace.traceBegin(TRACE_TAG_DALVIK, methodName); |
| 473 |
} |
| 474 |
|
| 475 |
@Override |
| 476 |
public void close() { |
| 477 |
Trace.traceEnd(TRACE_TAG_DALVIK); |
| 478 |
} |
| 479 |
} |
| 480 |
|
| 481 |
public static class TracingWithTimingLogging extends Tracing { |
| 482 |
@NonNull private final String mTag; |
| 483 |
@NonNull private final String mMethodName; |
| 484 |
@NonNull private final long mStartTimeMs; |
| 485 |
|
| 486 |
public TracingWithTimingLogging(@NonNull String tag, @NonNull String methodName) { |
| 487 |
super(methodName); |
| 488 |
mTag = tag; |
| 489 |
mMethodName = methodName; |
| 490 |
mStartTimeMs = SystemClock.elapsedRealtime(); |
| 491 |
Log.d(tag, methodName); |
| 492 |
} |
| 493 |
|
| 494 |
@Override |
| 495 |
public void close() { |
| 496 |
Log.d(mTag, |
| 497 |
mMethodName + " took to complete: " |
| 498 |
+ (SystemClock.elapsedRealtime() - mStartTimeMs) + "ms"); |
| 499 |
super.close(); |
| 500 |
} |
| 501 |
} |
| 502 |
} |