Merge branch 'stage' into fix/ADFA-3366-include-analysis-api-as-dependency

Author: itsaky-adfa

annotation-processors/build.gradle.kts

@@ -16,6 +16,7 @@
  */
 
 import com.itsaky.androidide.build.config.BuildConfig
+import org.jetbrains.kotlin.gradle.dsl.JvmTarget
 import org.jetbrains.kotlin.gradle.tasks.KotlinCompile
 
 plugins {
@@ -45,5 +46,5 @@ dependencies {
 }
 
 tasks.withType<KotlinCompile> {
-	kotlinOptions.jvmTarget = "17"
+	compilerOptions.jvmTarget.set(JvmTarget.JVM_17)
 }

app/build.gradle.kts

@@ -183,6 +183,10 @@ android {
 	}
 }
 
+sentry {
+      includeProguardMapping = false
+}
+
 kapt { arguments { arg("eventBusIndex", "${BuildConfig.PACKAGE_NAME}.events.AppEventsIndex") } }
 
 desugaring {
@@ -293,6 +297,7 @@ dependencies {
 	implementation(projects.gradlePluginConfig)
 	implementation(projects.subprojects.aaptcompiler)
 	implementation(projects.subprojects.javacServices)
+	implementation(projects.subprojects.kotlinAnalysisApi)
 	implementation(projects.subprojects.shizukuApi)
 	implementation(projects.subprojects.shizukuManager)
 	implementation(projects.subprojects.shizukuProvider)

app/src/debug/java/com/itsaky/androidide/app/LeakCanaryConfig.kt

@@ -0,0 +1,12 @@
+package com.itsaky.androidide.app
+
+import com.itsaky.androidide.utils.FeatureFlags
+import leakcanary.LeakCanary
+
+internal object LeakCanaryConfig {
+	fun applyFromFeatureFlags() {
+		if (FeatureFlags.isLeakCanaryDumpInhibited) {
+			LeakCanary.config = LeakCanary.config.copy(dumpHeap = false)
+		}
+	}
+}

app/src/main/java/com/itsaky/androidide/app/CredentialProtectedApplicationLoader.kt

@@ -73,6 +73,7 @@ internal object CredentialProtectedApplicationLoader : ApplicationLoader {
 		Environment.init(app)
 
 		FeatureFlags.initialize()
+		LeakCanaryConfig.applyFromFeatureFlags()
 
 		EventBus.getDefault().register(this)
 

app/src/main/java/com/itsaky/androidide/app/DeviceProtectedApplicationLoader.kt

@@ -62,7 +62,7 @@ internal object DeviceProtectedApplicationLoader :
 		StrictModeManager.install(
 			StrictModeConfig(
 				enabled = BuildConfig.DEBUG && !FeatureFlags.isPardonEnabled,
-                isReprieveEnabled = true,
+				isReprieveEnabled = true,
 			),
 		)
 

app/src/main/java/org/jetbrains/kotlin/com/intellij/util/containers/UnsafeImpl.java

@@ -0,0 +1,129 @@
+package org.jetbrains.kotlin.com.intellij.util.containers;
+
+import android.util.Log;
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.Arrays;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.kotlin.com.intellij.util.ReflectionUtil;
+import org.lsposed.hiddenapibypass.HiddenApiBypass;
+
+@SuppressWarnings("ALL")
+public class UnsafeImpl {
+
+	private static final Object unsafe;
+
+	private static final Method putObjectVolatile;
+	private static final Method getObjectVolatile;
+	private static final Method compareAndSwapObject;
+	private static final Method compareAndSwapInt;
+	private static final Method compareAndSwapLong;
+	private static final Method getAndAddInt;
+	private static final Method objectFieldOffset;
+	private static final Method arrayIndexScale;
+	private static final Method arrayBaseOffset;
+	// private static final Method copyMemory;
+
+	private static final String TAG = "UnsafeImpl";
+
+	static {
+		try {
+			unsafe = ReflectionUtil.getUnsafe();
+			putObjectVolatile = find("putObjectVolatile", Object.class, long.class, Object.class);
+			getObjectVolatile = find("getObjectVolatile", Object.class, long.class);
+			compareAndSwapObject = find("compareAndSwapObject", Object.class, long.class, Object.class, Object.class);
+			compareAndSwapInt = find("compareAndSwapInt", Object.class, long.class, int.class, int.class);
+			compareAndSwapLong = find("compareAndSwapLong", Object.class, long.class, long.class, long.class);
+			getAndAddInt = find("getAndAddInt", Object.class, long.class, int.class);
+			objectFieldOffset = find("objectFieldOffset", Field.class);
+			arrayBaseOffset = find("arrayBaseOffset", Class.class);
+			arrayIndexScale = find("arrayIndexScale", Class.class);
+			// copyMemory = find("copyMemory", Object.class, long.class, Object.class, long.class, long.class);
+		} catch (Throwable t) {
+			throw new Error(t);
+		}
+	}
+
+	public static int arrayBaseOffset(Class<?> arrayClass) {
+		try {
+			return (int) arrayBaseOffset.invoke(unsafe, arrayClass);
+		} catch (Throwable t) {
+			throw new RuntimeException(t);
+		}
+	}
+
+	public static int arrayIndexScale(Class<?> arrayClass) {
+		try {
+			return (int) arrayIndexScale.invoke(unsafe, arrayClass);
+		} catch (Throwable t) {
+			throw new RuntimeException(t);
+		}
+	}
+
+	public static boolean compareAndSwapInt(Object object, long offset, int expected, int value) {
+		try {
+			return (boolean) compareAndSwapInt.invoke(unsafe, object, offset, expected, value);
+		} catch (Throwable t) {
+			throw new RuntimeException(t);
+		}
+	}
+
+	public static boolean compareAndSwapLong(@NotNull Object object, long offset, long expected, long value) {
+		try {
+			return (boolean) compareAndSwapLong.invoke(unsafe, object, offset, expected, value);
+		} catch (Throwable t) {
+			throw new RuntimeException(t);
+		}
+	}
+
+	public static boolean compareAndSwapObject(Object o, long offset, Object expected, Object x) {
+		try {
+			return (boolean) compareAndSwapObject.invoke(unsafe, o, offset, expected, x);
+		} catch (Throwable t) {
+			throw new RuntimeException(t);
+		}
+	}
+
+	public static void copyMemory(Object srcBase, long srcOffset, Object destBase, long destOffset, long bytes) {
+		throw new UnsupportedOperationException("Not supported on Android!");
+	}
+
+	public static int getAndAddInt(Object object, long offset, int v) {
+		try {
+			return (int) getAndAddInt.invoke(unsafe, object, offset, v);
+		} catch (Throwable t) {
+			throw new RuntimeException(t);
+		}
+	}
+
+	public static Object getObjectVolatile(Object object, long offset) {
+		try {
+			return getObjectVolatile.invoke(unsafe, object, offset);
+		} catch (Throwable t) {
+			throw new RuntimeException(t);
+		}
+	}
+
+	public static long objectFieldOffset(Field f) {
+		try {
+			return (long) objectFieldOffset.invoke(unsafe, f);
+		} catch (Throwable t) {
+			throw new RuntimeException(t);
+		}
+	}
+
+	public static void putObjectVolatile(Object o, long offset, Object x) {
+		try {
+			putObjectVolatile.invoke(unsafe, o, offset, x);
+		} catch (Throwable t) {
+			throw new RuntimeException(t);
+		}
+	}
+
+	private static @NotNull Method find(String name, Class<?>... params) throws Exception {
+		Log.d(TAG, "find: name=" + name + ", params=" + Arrays.toString(params));
+		Method m = HiddenApiBypass.getDeclaredMethod(unsafe.getClass(), name, params);
+		m.setAccessible(true);
+		return m;
+	}
+}

app/src/release/java/com/itsaky/androidide/app/LeakCanaryConfig.kt

@@ -0,0 +1,5 @@
+package com.itsaky.androidide.app
+
+internal object LeakCanaryConfig {
+	fun applyFromFeatureFlags() {}
+}

common/src/main/java/com/itsaky/androidide/utils/FeatureFlags.kt

@@ -13,7 +13,8 @@ private data class FlagsCache(
 	val debugLoggingEnabled: Boolean = false,
 	val emulatorUseEnabled: Boolean = false,
 	val reprieveEnabled: Boolean = false,
-    val pardonEnabled: Boolean = false,
+	val pardonEnabled: Boolean = false,
+	val leakCanaryDumpInhibited: Boolean = false,
 ) {
 	companion object {
 		/**
@@ -28,7 +29,8 @@ object FeatureFlags {
 	private const val LOGD_FILE_NAME = "CodeOnTheGo.logd"
 	private const val EMULATOR_FILE_NAME = "S153.txt"
 	private const val REPRIEVE_FILE_NAME = "CodeOnTheGo.a3s19"
-    private const val PARDON_FILE_NAME = "CodeOnTheGo.a2s2"
+	private const val PARDON_FILE_NAME = "CodeOnTheGo.a2s2"
+	private const val LEAKCANARY_FILE_NAME = "CodeOnTheGo.lc"
 
 	private val logger = LoggerFactory.getLogger(FeatureFlags::class.java)
 
@@ -62,13 +64,19 @@ object FeatureFlags {
 	val isReprieveEnabled: Boolean
 		get() = flags.reprieveEnabled
 
-    /**
-     * Whether pardon is enabled or not.
-     */
-    val isPardonEnabled: Boolean
-        get() = flags.pardonEnabled
+	/**
+	 * Whether pardon is enabled or not.
+	 */
+	val isPardonEnabled: Boolean
+		get() = flags.pardonEnabled
+
+	/**
+	 * Whether LeakCanary heap dumping is inhibited (CodeOnTheGo.lc present in Downloads).
+	 */
+	val isLeakCanaryDumpInhibited: Boolean
+		get() = flags.leakCanaryDumpInhibited
 
-    /**
+	/**
 	 * Initialize feature flag values. This is thread-safe and idempotent i.e.
 	 * subsequent calls do not access disk.
 	 */
@@ -90,7 +98,8 @@ object FeatureFlags {
 							debugLoggingEnabled = checkFlag(LOGD_FILE_NAME),
 							emulatorUseEnabled = checkFlag(EMULATOR_FILE_NAME),
 							reprieveEnabled = checkFlag(REPRIEVE_FILE_NAME),
-                            pardonEnabled = checkFlag(PARDON_FILE_NAME),
+							pardonEnabled = checkFlag(PARDON_FILE_NAME),
+							leakCanaryDumpInhibited = checkFlag(LEAKCANARY_FILE_NAME),
 						)
 					}.getOrElse { error ->
 						logger.error("Failed to load feature flags. Falling back to default values.", error)

composite-builds/build-deps/java-compiler/build.gradle.kts

@@ -16,10 +16,15 @@
  */
 
 plugins {
-  id("java-library")
+	id("java-library")
 }
 
 java {
-  sourceCompatibility = JavaVersion.VERSION_1_8
-  targetCompatibility = JavaVersion.VERSION_1_8
-}
+	sourceCompatibility = JavaVersion.VERSION_1_8
+	targetCompatibility = JavaVersion.VERSION_1_8
+}
+
+dependencies {
+	annotationProcessor(libs.google.auto.service)
+	implementation(libs.google.auto.service.annotations)
+}

composite-builds/build-deps/java-compiler/src/main/java/javac/internal/jrtfs/JrtFileSystemProvider.java

@@ -25,6 +25,8 @@
 
 package javac.internal.jrtfs;
 
+import com.google.auto.service.AutoService;
+
 import java.io.*;
 import java.net.MalformedURLException;
 import java.net.URL;
@@ -53,6 +55,7 @@
  * but also compiled and delivered as part of the jrtfs.jar to support access
  * to the jimage file provided by the shipped JDK by tools running on JDK 8.
  */
+@AutoService(FileSystemProvider.class)
 public final class JrtFileSystemProvider extends FileSystemProvider {
 
     private volatile FileSystem theFileSystem;