Merge "Update how common sources are computed" into androidx-main
diff --git a/appcompat/appcompat/src/androidTest/java/androidx/appcompat/app/DrawerLayoutTest.java b/appcompat/appcompat/src/androidTest/java/androidx/appcompat/app/DrawerLayoutTest.java
index 4ce752e..3b86f6e 100644
--- a/appcompat/appcompat/src/androidTest/java/androidx/appcompat/app/DrawerLayoutTest.java
+++ b/appcompat/appcompat/src/androidTest/java/androidx/appcompat/app/DrawerLayoutTest.java
@@ -259,6 +259,7 @@
@Test
@MediumTest
+ @SdkSuppress(maxSdkVersion = 34) // b/384972471: Failing on SDK 35
public void testDrawerHeight() {
// Open the drawer so it becomes visible
onView(withId(R.id.drawer_layout)).perform(openDrawer(GravityCompat.START));
diff --git a/appfunctions/appfunctions-common/api/current.txt b/appfunctions/appfunctions-common/api/current.txt
index e6f50d0..724d892f 100644
--- a/appfunctions/appfunctions-common/api/current.txt
+++ b/appfunctions/appfunctions-common/api/current.txt
@@ -1 +1,60 @@
// Signature format: 4.0
+package androidx.appfunctions {
+
+ public interface AppFunctionContext {
+ method public String getCallingPackageName();
+ method public android.content.pm.SigningInfo getCallingPackageSigningInfo();
+ method public android.content.Context getContext();
+ property public abstract String callingPackageName;
+ property public abstract android.content.pm.SigningInfo callingPackageSigningInfo;
+ property public abstract android.content.Context context;
+ }
+
+ public final class AppFunctionException {
+ ctor public AppFunctionException(int errorCode, optional String? errorMessage);
+ method public int getErrorCategory();
+ method public int getErrorCode();
+ method public String? getErrorMessage();
+ property public final int errorCategory;
+ property public final int errorCode;
+ property public final String? errorMessage;
+ field public static final androidx.appfunctions.AppFunctionException.Companion Companion;
+ field public static final int ERROR_APP_UNKNOWN_ERROR = 3000; // 0xbb8
+ field public static final int ERROR_CANCELLED = 2001; // 0x7d1
+ field public static final int ERROR_CATEGORY_APP = 3; // 0x3
+ field public static final int ERROR_CATEGORY_REQUEST_ERROR = 1; // 0x1
+ field public static final int ERROR_CATEGORY_SYSTEM = 2; // 0x2
+ field public static final int ERROR_CATEGORY_UNKNOWN = 0; // 0x0
+ field public static final int ERROR_DENIED = 1000; // 0x3e8
+ field public static final int ERROR_DISABLED = 1002; // 0x3ea
+ field public static final int ERROR_FUNCTION_NOT_FOUND = 1003; // 0x3eb
+ field public static final int ERROR_INVALID_ARGUMENT = 1001; // 0x3e9
+ field public static final int ERROR_LIMIT_EXCEEDED = 1501; // 0x5dd
+ field public static final int ERROR_NOT_SUPPORTED = 3501; // 0xdad
+ field public static final int ERROR_PERMISSION_REQUIRED = 3500; // 0xdac
+ field public static final int ERROR_RESOURCE_ALREADY_EXISTS = 1502; // 0x5de
+ field public static final int ERROR_RESOURCE_NOT_FOUND = 1500; // 0x5dc
+ field public static final int ERROR_SYSTEM_ERROR = 2000; // 0x7d0
+ }
+
+ public static final class AppFunctionException.Companion {
+ property public static final int ERROR_APP_UNKNOWN_ERROR;
+ property public static final int ERROR_CANCELLED;
+ property public static final int ERROR_CATEGORY_APP;
+ property public static final int ERROR_CATEGORY_REQUEST_ERROR;
+ property public static final int ERROR_CATEGORY_SYSTEM;
+ property public static final int ERROR_CATEGORY_UNKNOWN;
+ property public static final int ERROR_DENIED;
+ property public static final int ERROR_DISABLED;
+ property public static final int ERROR_FUNCTION_NOT_FOUND;
+ property public static final int ERROR_INVALID_ARGUMENT;
+ property public static final int ERROR_LIMIT_EXCEEDED;
+ property public static final int ERROR_NOT_SUPPORTED;
+ property public static final int ERROR_PERMISSION_REQUIRED;
+ property public static final int ERROR_RESOURCE_ALREADY_EXISTS;
+ property public static final int ERROR_RESOURCE_NOT_FOUND;
+ property public static final int ERROR_SYSTEM_ERROR;
+ }
+
+}
+
diff --git a/appfunctions/appfunctions-common/api/restricted_current.txt b/appfunctions/appfunctions-common/api/restricted_current.txt
index e6f50d0..724d892f 100644
--- a/appfunctions/appfunctions-common/api/restricted_current.txt
+++ b/appfunctions/appfunctions-common/api/restricted_current.txt
@@ -1 +1,60 @@
// Signature format: 4.0
+package androidx.appfunctions {
+
+ public interface AppFunctionContext {
+ method public String getCallingPackageName();
+ method public android.content.pm.SigningInfo getCallingPackageSigningInfo();
+ method public android.content.Context getContext();
+ property public abstract String callingPackageName;
+ property public abstract android.content.pm.SigningInfo callingPackageSigningInfo;
+ property public abstract android.content.Context context;
+ }
+
+ public final class AppFunctionException {
+ ctor public AppFunctionException(int errorCode, optional String? errorMessage);
+ method public int getErrorCategory();
+ method public int getErrorCode();
+ method public String? getErrorMessage();
+ property public final int errorCategory;
+ property public final int errorCode;
+ property public final String? errorMessage;
+ field public static final androidx.appfunctions.AppFunctionException.Companion Companion;
+ field public static final int ERROR_APP_UNKNOWN_ERROR = 3000; // 0xbb8
+ field public static final int ERROR_CANCELLED = 2001; // 0x7d1
+ field public static final int ERROR_CATEGORY_APP = 3; // 0x3
+ field public static final int ERROR_CATEGORY_REQUEST_ERROR = 1; // 0x1
+ field public static final int ERROR_CATEGORY_SYSTEM = 2; // 0x2
+ field public static final int ERROR_CATEGORY_UNKNOWN = 0; // 0x0
+ field public static final int ERROR_DENIED = 1000; // 0x3e8
+ field public static final int ERROR_DISABLED = 1002; // 0x3ea
+ field public static final int ERROR_FUNCTION_NOT_FOUND = 1003; // 0x3eb
+ field public static final int ERROR_INVALID_ARGUMENT = 1001; // 0x3e9
+ field public static final int ERROR_LIMIT_EXCEEDED = 1501; // 0x5dd
+ field public static final int ERROR_NOT_SUPPORTED = 3501; // 0xdad
+ field public static final int ERROR_PERMISSION_REQUIRED = 3500; // 0xdac
+ field public static final int ERROR_RESOURCE_ALREADY_EXISTS = 1502; // 0x5de
+ field public static final int ERROR_RESOURCE_NOT_FOUND = 1500; // 0x5dc
+ field public static final int ERROR_SYSTEM_ERROR = 2000; // 0x7d0
+ }
+
+ public static final class AppFunctionException.Companion {
+ property public static final int ERROR_APP_UNKNOWN_ERROR;
+ property public static final int ERROR_CANCELLED;
+ property public static final int ERROR_CATEGORY_APP;
+ property public static final int ERROR_CATEGORY_REQUEST_ERROR;
+ property public static final int ERROR_CATEGORY_SYSTEM;
+ property public static final int ERROR_CATEGORY_UNKNOWN;
+ property public static final int ERROR_DENIED;
+ property public static final int ERROR_DISABLED;
+ property public static final int ERROR_FUNCTION_NOT_FOUND;
+ property public static final int ERROR_INVALID_ARGUMENT;
+ property public static final int ERROR_LIMIT_EXCEEDED;
+ property public static final int ERROR_NOT_SUPPORTED;
+ property public static final int ERROR_PERMISSION_REQUIRED;
+ property public static final int ERROR_RESOURCE_ALREADY_EXISTS;
+ property public static final int ERROR_RESOURCE_NOT_FOUND;
+ property public static final int ERROR_SYSTEM_ERROR;
+ }
+
+}
+
diff --git a/appfunctions/appfunctions-common/src/androidTest/java/androidx/appfunctions/AppFunctionExceptionTest.kt b/appfunctions/appfunctions-common/src/androidTest/java/androidx/appfunctions/AppFunctionExceptionTest.kt
new file mode 100644
index 0000000..7652f91
--- /dev/null
+++ b/appfunctions/appfunctions-common/src/androidTest/java/androidx/appfunctions/AppFunctionExceptionTest.kt
@@ -0,0 +1,148 @@
+/*
+ * Copyright 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.appfunctions
+
+import android.os.Bundle
+import com.google.common.truth.Truth
+import org.junit.AssumptionViolatedException
+import org.junit.Test
+
+class AppFunctionExceptionTest {
+ @Test
+ fun testConstructor_withoutMessageAndExtras() {
+ val exception = AppFunctionException(AppFunctionException.ERROR_DENIED)
+
+ Truth.assertThat(exception.errorCode).isEqualTo(AppFunctionException.ERROR_DENIED)
+ Truth.assertThat(exception.errorMessage).isNull()
+ Truth.assertThat(exception.extras).isEqualTo(Bundle.EMPTY)
+ }
+
+ @Test
+ fun testConstructor_withoutExtras() {
+ val exception = AppFunctionException(AppFunctionException.ERROR_DENIED, "testMessage")
+
+ Truth.assertThat(exception.errorCode).isEqualTo(AppFunctionException.ERROR_DENIED)
+ Truth.assertThat(exception.errorMessage).isEqualTo("testMessage")
+ Truth.assertThat(exception.extras).isEqualTo(Bundle.EMPTY)
+ }
+
+ @Test
+ fun testConstructor() {
+ val extras = Bundle().apply { putString("testKey", "testValue") }
+ val exception =
+ AppFunctionException(AppFunctionException.ERROR_DENIED, "testMessage", extras)
+
+ Truth.assertThat(exception.errorCode).isEqualTo(AppFunctionException.ERROR_DENIED)
+ Truth.assertThat(exception.errorMessage).isEqualTo("testMessage")
+ Truth.assertThat(exception.extras.getString("testKey")).isEqualTo("testValue")
+ }
+
+ @Test
+ fun testErrorCategory_RequestError() {
+ Truth.assertThat(AppFunctionException(AppFunctionException.ERROR_DENIED).errorCategory)
+ .isEqualTo(AppFunctionException.ERROR_CATEGORY_REQUEST_ERROR)
+ Truth.assertThat(
+ AppFunctionException(AppFunctionException.ERROR_INVALID_ARGUMENT).errorCategory
+ )
+ .isEqualTo(AppFunctionException.ERROR_CATEGORY_REQUEST_ERROR)
+ Truth.assertThat(AppFunctionException(AppFunctionException.ERROR_DISABLED).errorCategory)
+ .isEqualTo(AppFunctionException.ERROR_CATEGORY_REQUEST_ERROR)
+ Truth.assertThat(
+ AppFunctionException(AppFunctionException.ERROR_FUNCTION_NOT_FOUND).errorCategory
+ )
+ .isEqualTo(AppFunctionException.ERROR_CATEGORY_REQUEST_ERROR)
+ Truth.assertThat(
+ AppFunctionException(AppFunctionException.ERROR_RESOURCE_NOT_FOUND).errorCategory
+ )
+ .isEqualTo(AppFunctionException.ERROR_CATEGORY_REQUEST_ERROR)
+ Truth.assertThat(
+ AppFunctionException(AppFunctionException.ERROR_LIMIT_EXCEEDED).errorCategory
+ )
+ .isEqualTo(AppFunctionException.ERROR_CATEGORY_REQUEST_ERROR)
+ Truth.assertThat(
+ AppFunctionException(AppFunctionException.ERROR_RESOURCE_ALREADY_EXISTS)
+ .errorCategory
+ )
+ .isEqualTo(AppFunctionException.ERROR_CATEGORY_REQUEST_ERROR)
+ }
+
+ @Test
+ fun testErrorCategory_SystemError() {
+ Truth.assertThat(
+ AppFunctionException(AppFunctionException.ERROR_SYSTEM_ERROR).errorCategory
+ )
+ .isEqualTo(AppFunctionException.ERROR_CATEGORY_SYSTEM)
+ Truth.assertThat(AppFunctionException(AppFunctionException.ERROR_CANCELLED).errorCategory)
+ .isEqualTo(AppFunctionException.ERROR_CATEGORY_SYSTEM)
+ }
+
+ @Test
+ fun testErrorCategory_AppError() {
+ Truth.assertThat(
+ AppFunctionException(AppFunctionException.ERROR_APP_UNKNOWN_ERROR).errorCategory
+ )
+ .isEqualTo(AppFunctionException.ERROR_CATEGORY_APP)
+ Truth.assertThat(
+ AppFunctionException(AppFunctionException.ERROR_PERMISSION_REQUIRED).errorCategory
+ )
+ .isEqualTo(AppFunctionException.ERROR_CATEGORY_APP)
+ Truth.assertThat(
+ AppFunctionException(AppFunctionException.ERROR_NOT_SUPPORTED).errorCategory
+ )
+ .isEqualTo(AppFunctionException.ERROR_CATEGORY_APP)
+ }
+
+ @Test
+ fun testTransformToPlatformExtensionsClass() {
+ assumeAppFunctionExtensionLibraryAvailable()
+ val extras = Bundle().apply { putString("testKey", "testValue") }
+ val exception =
+ AppFunctionException(AppFunctionException.ERROR_DENIED, "testMessage", extras)
+
+ val platformException = exception.toPlatformExtensionsClass()
+
+ Truth.assertThat(platformException.errorCode).isEqualTo(AppFunctionException.ERROR_DENIED)
+ Truth.assertThat(platformException.errorMessage).isEqualTo("testMessage")
+ Truth.assertThat(platformException.extras.getString("testKey")).isEqualTo("testValue")
+ }
+
+ @Test
+ fun testCreateFromPlatformExtensionsClass() {
+ assumeAppFunctionExtensionLibraryAvailable()
+ val extras = Bundle().apply { putString("testKey", "testValue") }
+ val platformException =
+ com.android.extensions.appfunctions.AppFunctionException(
+ AppFunctionException.ERROR_DENIED,
+ "testMessage",
+ extras
+ )
+
+ val exception = AppFunctionException.fromPlatformExtensionsClass(platformException)
+ Truth.assertThat(exception.errorCode).isEqualTo(AppFunctionException.ERROR_DENIED)
+ Truth.assertThat(exception.errorMessage).isEqualTo("testMessage")
+ Truth.assertThat(exception.extras.getString("testKey")).isEqualTo("testValue")
+ }
+
+ private fun assumeAppFunctionExtensionLibraryAvailable(): Boolean {
+ try {
+ Class.forName("com.android.extensions.appfunctions.AppFunctionManager")
+ return true
+ } catch (e: ClassNotFoundException) {
+ throw AssumptionViolatedException("Unable to find AppFunction extension library", e)
+ }
+ }
+}
diff --git a/appfunctions/appfunctions-common/src/main/AndroidManifest.xml b/appfunctions/appfunctions-common/src/main/AndroidManifest.xml
new file mode 100644
index 0000000..d290837
--- /dev/null
+++ b/appfunctions/appfunctions-common/src/main/AndroidManifest.xml
@@ -0,0 +1,23 @@
+<!--
+ Copyright 2024 The Android Open Source Project
+
+ Licensed under the Apache License, Version 2.0 (the "License");
+ you may not use this file except in compliance with the License.
+ You may obtain a copy of the License at
+
+ http://www.apache.org/licenses/LICENSE-2.0
+
+ Unless required by applicable law or agreed to in writing, software
+ distributed under the License is distributed on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ See the License for the specific language governing permissions and
+ limitations under the License.
+ -->
+<manifest
+ xmlns:android="http://schemas.android.com/apk/res/android">
+ <application>
+ <uses-library
+ android:name="com.android.extensions.appfunctions"
+ android:required="false" />
+ </application>
+</manifest>
\ No newline at end of file
diff --git a/appfunctions/appfunctions-common/src/main/java/androidx/appfunctions/AppFunctionContext.kt b/appfunctions/appfunctions-common/src/main/java/androidx/appfunctions/AppFunctionContext.kt
new file mode 100644
index 0000000..250690e
--- /dev/null
+++ b/appfunctions/appfunctions-common/src/main/java/androidx/appfunctions/AppFunctionContext.kt
@@ -0,0 +1,38 @@
+/*
+ * Copyright 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.appfunctions
+
+import android.content.Context
+import android.content.pm.SigningInfo
+
+/** The execution context of app function. */
+public interface AppFunctionContext {
+ /** The Android context. */
+ public val context: Context
+
+ /**
+ * Return the name of the package that invoked this AppFunction. You can use this information to
+ * validate the caller.
+ */
+ public val callingPackageName: String
+
+ /**
+ * Return the [android.content.pm.SigningInfo] of the package that invoked this AppFunction. You
+ * can use this information to validate the caller.
+ */
+ public val callingPackageSigningInfo: SigningInfo
+}
diff --git a/appfunctions/appfunctions-common/src/main/java/androidx/appfunctions/AppFunctionException.kt b/appfunctions/appfunctions-common/src/main/java/androidx/appfunctions/AppFunctionException.kt
new file mode 100644
index 0000000..35dbf20
--- /dev/null
+++ b/appfunctions/appfunctions-common/src/main/java/androidx/appfunctions/AppFunctionException.kt
@@ -0,0 +1,253 @@
+/*
+ * Copyright 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.appfunctions
+
+import android.os.Bundle
+import androidx.annotation.IntDef
+import androidx.annotation.RestrictTo
+
+/**
+ * An exception that is thrown when an error occurs during an app function execution.
+ *
+ * This exception can be used by the app to report errors to the caller.
+ */
+public class AppFunctionException
+internal constructor(
+ /** The error code. */
+ @ErrorCode public val errorCode: Int,
+ /** The error message. */
+ public val errorMessage: String?,
+ internal val extras: Bundle
+) {
+ /**
+ * Create an [AppFunctionException].
+ *
+ * @param errorCode The error code.
+ * @param errorMessage The error message.
+ */
+ public constructor(
+ @ErrorCode errorCode: Int,
+ errorMessage: String? = null,
+ ) : this(errorCode, errorMessage, Bundle.EMPTY)
+
+ @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
+ public fun toPlatformExtensionsClass():
+ com.android.extensions.appfunctions.AppFunctionException {
+ return com.android.extensions.appfunctions.AppFunctionException(
+ errorCode,
+ errorMessage,
+ extras
+ )
+ }
+
+ /**
+ * Returns the error category.
+ *
+ * <p> This method categorizes errors based on their underlying cause, allowing developers to
+ * implement targeted error handling and provide more informative error messages to users. It
+ * maps ranges of error codes to specific error categories.
+ *
+ * <p> This method returns [ERROR_CATEGORY_UNKNOWN] if the error code does not belong to any
+ * error category.
+ */
+ @ErrorCategory
+ public val errorCategory: Int =
+ when (errorCode) {
+ in 1000..1999 -> ERROR_CATEGORY_REQUEST_ERROR
+ in 2000..2999 -> ERROR_CATEGORY_SYSTEM
+ in 3000..3999 -> ERROR_CATEGORY_APP
+ else -> ERROR_CATEGORY_UNKNOWN
+ }
+
+ @IntDef(
+ value =
+ [
+ ERROR_CATEGORY_UNKNOWN,
+ ERROR_CATEGORY_REQUEST_ERROR,
+ ERROR_CATEGORY_APP,
+ ERROR_CATEGORY_SYSTEM,
+ ]
+ )
+ internal annotation class ErrorCategory
+
+ @IntDef(
+ value =
+ [
+ ERROR_DENIED,
+ ERROR_INVALID_ARGUMENT,
+ ERROR_DISABLED,
+ ERROR_FUNCTION_NOT_FOUND,
+ ERROR_RESOURCE_NOT_FOUND,
+ ERROR_LIMIT_EXCEEDED,
+ ERROR_RESOURCE_ALREADY_EXISTS,
+ ERROR_SYSTEM_ERROR,
+ ERROR_CANCELLED,
+ ERROR_APP_UNKNOWN_ERROR,
+ ERROR_PERMISSION_REQUIRED,
+ ERROR_NOT_SUPPORTED,
+ ]
+ )
+ internal annotation class ErrorCode
+
+ public companion object {
+ @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
+ public fun fromPlatformExtensionsClass(
+ exception: com.android.extensions.appfunctions.AppFunctionException
+ ): AppFunctionException {
+ return AppFunctionException(
+ exception.errorCode,
+ exception.errorMessage,
+ exception.extras
+ )
+ }
+
+ // Error categories
+ /** The error category is unknown. */
+ public const val ERROR_CATEGORY_UNKNOWN: Int = 0
+
+ /**
+ * The error is caused by the app requesting a function execution.
+ *
+ * <p>For example, the caller provided invalid parameters in the execution request e.g. an
+ * invalid function ID.
+ *
+ * <p>Errors in the category fall in the range 1000-1999 inclusive.
+ */
+ public const val ERROR_CATEGORY_REQUEST_ERROR: Int = 1
+
+ /**
+ * The error is caused by an issue in the system.
+ *
+ * <p>For example, the AppFunctionService implementation is not found by the system.
+ *
+ * <p>Errors in the category fall in the range 2000-2999 inclusive.
+ */
+ public const val ERROR_CATEGORY_SYSTEM: Int = 2
+
+ /**
+ * The error is caused by the app providing the function.
+ *
+ * <p>For example, the app crashed when the system is executing the request.
+ *
+ * <p>Errors in the category fall in the range 3000-3999 inclusive.
+ */
+ public const val ERROR_CATEGORY_APP: Int = 3
+
+ // Error codes
+ /**
+ * The caller does not have the permission to execute an app function.
+ *
+ * <p>This error is in the [ERROR_CATEGORY_REQUEST_ERROR] category.
+ */
+ public const val ERROR_DENIED: Int = 1000
+
+ /**
+ * The caller supplied invalid arguments to the execution request.
+ *
+ * <p>This error may be considered similar to [IllegalArgumentException].
+ *
+ * <p>This error is in the [ERROR_CATEGORY_REQUEST_ERROR] category.
+ */
+ public const val ERROR_INVALID_ARGUMENT: Int = 1001
+
+ /**
+ * The caller tried to execute a disabled app function.
+ *
+ * <p>This error is in the [ERROR_CATEGORY_REQUEST_ERROR] category.
+ */
+ public const val ERROR_DISABLED: Int = 1002
+
+ /**
+ * The caller tried to execute a function that does not exist.
+ *
+ * <p>This error is in the [ERROR_CATEGORY_REQUEST_ERROR] category.
+ */
+ public const val ERROR_FUNCTION_NOT_FOUND: Int = 1003
+
+ // SDK-defined error codes in the [ERROR_CATEGORY_REQUEST_ERROR] category start from 1500.
+ /**
+ * The caller tried to request a resource/entity that does not exist.
+ *
+ * <p>This error is in the [ERROR_CATEGORY_REQUEST_ERROR] category.
+ */
+ public const val ERROR_RESOURCE_NOT_FOUND: Int = 1500
+
+ /**
+ * The caller exceeded the allowed request rate.
+ *
+ * <p>This error is in the [ERROR_CATEGORY_REQUEST_ERROR] category.
+ */
+ public const val ERROR_LIMIT_EXCEEDED: Int = 1501
+
+ /**
+ * The caller tried to create a resource/entity that already exists or has conflicts with
+ * existing resource/entity.
+ *
+ * <p>This error is in the [ERROR_CATEGORY_REQUEST_ERROR] category.
+ */
+ public const val ERROR_RESOURCE_ALREADY_EXISTS: Int = 1502
+
+ /**
+ * An internal unexpected error coming from the system.
+ *
+ * <p>This error is in the [ERROR_CATEGORY_SYSTEM] category.
+ */
+ public const val ERROR_SYSTEM_ERROR: Int = 2000
+
+ /**
+ * The operation was cancelled. Use this error code to report that a cancellation is done
+ * after receiving a cancellation signal.
+ *
+ * <p>This error is in the [ERROR_CATEGORY_SYSTEM] category.
+ */
+ public const val ERROR_CANCELLED: Int = 2001
+
+ /**
+ * An unknown error occurred while processing the call in the AppFunctionService.
+ *
+ * <p>This error is thrown when the service is connected in the remote application but an
+ * unexpected error is thrown from the bound application.
+ *
+ * <p>This error is in the [ERROR_CATEGORY_APP] category.
+ */
+ public const val ERROR_APP_UNKNOWN_ERROR: Int = 3000
+
+ // SDK-defined error codes in the [ERROR_CATEGORY_APP] category start from 3500.
+ /**
+ * Indicates the app lacks the necessary permission to fulfill the request.
+ *
+ * <p>This occurs when the app attempts an operation requiring user-granted permission that
+ * has not been provided. For example, creating a calendar event requires access to the
+ * calendar content. If the user hasn't granted this permission, this error should be
+ * thrown.
+ *
+ * <p>This error is in the [ERROR_CATEGORY_APP] category.
+ */
+ public const val ERROR_PERMISSION_REQUIRED: Int = 3500
+
+ /**
+ * Indicates the action is not supported by the app.
+ *
+ * <p>This error occurs when an app receives a request to perform an unsupported action. For
+ * example, a clock app might support updating timer properties such as label but may not
+ * allow updating the timer's duration once the timer has already started.
+ *
+ * <p>This error is in the [ERROR_CATEGORY_APP] category.
+ */
+ public const val ERROR_NOT_SUPPORTED: Int = 3501
+ }
+}
diff --git a/benchmark/benchmark-macro/src/androidTest/java/androidx/benchmark/macro/ProfileInstallBroadcastTest.kt b/benchmark/benchmark-macro/src/androidTest/java/androidx/benchmark/macro/ProfileInstallBroadcastTest.kt
index a856ba4..7184c9b 100644
--- a/benchmark/benchmark-macro/src/androidTest/java/androidx/benchmark/macro/ProfileInstallBroadcastTest.kt
+++ b/benchmark/benchmark-macro/src/androidTest/java/androidx/benchmark/macro/ProfileInstallBroadcastTest.kt
@@ -73,7 +73,7 @@
fun saveProfile_missing() {
val errorString = ProfileInstallBroadcast.saveProfile(Packages.MISSING)
assertNotNull(errorString)
- assertContains(errorString!!, "The save profile broadcast event was not received")
+ assertContains(errorString!!, "The save profile broadcast was not received")
}
@Test
@@ -133,6 +133,6 @@
val result = ProfileInstallBroadcast.saveProfilesForAllProcesses(Packages.TEST)
assertEquals(1, result.processCount)
assertNotNull(result.error)
- assertContains(result.error!!, "The save profile broadcast event was not received.")
+ assertContains(result.error!!, "The save profile broadcast was not received.")
}
}
diff --git a/benchmark/benchmark-macro/src/main/java/androidx/benchmark/macro/ProfileInstallBroadcast.kt b/benchmark/benchmark-macro/src/main/java/androidx/benchmark/macro/ProfileInstallBroadcast.kt
index 0340c07..d2e49aa 100644
--- a/benchmark/benchmark-macro/src/main/java/androidx/benchmark/macro/ProfileInstallBroadcast.kt
+++ b/benchmark/benchmark-macro/src/main/java/androidx/benchmark/macro/ProfileInstallBroadcast.kt
@@ -98,6 +98,13 @@
}
}
+ private fun nullResultErrorMessage(broadcastLabel: String, versionAdded: String): String =
+ "The $broadcastLabel broadcast was not received. " +
+ "This most likely means that the `androidx.profileinstaller` library is " +
+ "missing from the target app, or is too old. Please use `$versionAdded` or " +
+ "newer. For more information refer to the release notes at " +
+ "https://developer.android.com/jetpack/androidx/releases/profileinstaller."
+
/**
* Uses skip files for avoiding interference from ProfileInstaller when using
* [CompilationMode.None].
@@ -122,12 +129,10 @@
result == null || result == 0 -> {
// 0 is returned by the platform by default, and also if no broadcast receiver
// receives the broadcast.
-
- "The baseline profile skip file broadcast was not received. " +
- "This most likely means that the `androidx.profileinstaller` library " +
- "used by the target apk is old. Please use `1.2.0-alpha03` or newer. " +
- "For more information refer to the release notes at " +
- "https://developer.android.com/jetpack/androidx/releases/profileinstaller."
+ nullResultErrorMessage(
+ broadcastLabel = "baseline profile skip file",
+ versionAdded = "1.2.0-alpha03",
+ )
}
operation == "WRITE_SKIP_FILE" && result == 10 -> { // RESULT_INSTALL_SKIP_FILE_SUCCESS
null // success!
@@ -156,12 +161,10 @@
// 0 is returned by the platform by default, and also if no broadcast receiver
// receives the broadcast. This can be because the package name specified is
// incorrect or an old version of profile installer was used.
-
- "The save profile broadcast event was not received. This can be because the " +
- "specified package name is incorrect or the `androidx.profileinstaller`" +
- " library used by the target apk is old. Please use version `1.3.1` or " +
- "newer. For more information refer to the release notes at " +
- "https://developer.android.com/jetpack/androidx/releases/profileinstaller."
+ nullResultErrorMessage(
+ broadcastLabel = "save profile",
+ versionAdded = "1.3.1",
+ )
}
12 -> { // RESULT_SAVE_PROFILE_SIGNALLED
// While this is observed to be fast for simple/sample apps,
@@ -229,10 +232,10 @@
"used by the target apk is old. Please use `${operation.minimumVersion}`" +
" or newer. For more information refer to the release notes at " +
"https://developer.android.com/jetpack/androidx/releases/profileinstaller. " +
- "If you are already using androidx.profileinstaller library and still seeing " +
+ "If you are already using 'androidx.profileinstaller' library and still seeing " +
"error, verify: 1) androidx.profileinstaller.ProfileInstallReceiver appears " +
"unobfuscated in your APK's AndroidManifest and dex, and 2) the following " +
- "command executes successfully (should print 14): " +
+ "command executes successfully (should print ${operation.successCode}}): " +
"adb shell am broadcast $broadcastArguments"
}
15 -> { // RESULT_BENCHMARK_OPERATION_FAILURE
diff --git a/camera/camera-camera2-pipe-integration/build.gradle b/camera/camera-camera2-pipe-integration/build.gradle
index bb710ed..eccd134 100644
--- a/camera/camera-camera2-pipe-integration/build.gradle
+++ b/camera/camera-camera2-pipe-integration/build.gradle
@@ -85,6 +85,8 @@
}
android {
+ compileSdk 35
+
lintOptions {
enable("CameraXQuirksClassDetector")
}
diff --git a/camera/camera-camera2-pipe-integration/src/test/java/androidx/camera/camera2/pipe/integration/adapter/SupportedSurfaceCombinationTest.kt b/camera/camera-camera2-pipe-integration/src/test/java/androidx/camera/camera2/pipe/integration/adapter/SupportedSurfaceCombinationTest.kt
index 2bac7fd..13a7539 100644
--- a/camera/camera-camera2-pipe-integration/src/test/java/androidx/camera/camera2/pipe/integration/adapter/SupportedSurfaceCombinationTest.kt
+++ b/camera/camera-camera2-pipe-integration/src/test/java/androidx/camera/camera2/pipe/integration/adapter/SupportedSurfaceCombinationTest.kt
@@ -90,7 +90,6 @@
import androidx.camera.core.impl.UseCaseConfigFactory
import androidx.camera.core.impl.UseCaseConfigFactory.CaptureType
import androidx.camera.core.impl.utils.CompareSizesByArea
-import androidx.camera.core.internal.utils.SizeUtil
import androidx.camera.core.internal.utils.SizeUtil.RESOLUTION_1080P
import androidx.camera.core.internal.utils.SizeUtil.RESOLUTION_1440P
import androidx.camera.core.internal.utils.SizeUtil.RESOLUTION_720P
@@ -146,7 +145,6 @@
private val recordSize = Size(3840, 2160)
private val maximumSize = Size(4032, 3024)
private val legacyVideoMaximumSize = Size(1920, 1080)
- private val mod16Size = Size(960, 544)
private val profileUhd =
EncoderProfilesUtil.createFakeEncoderProfilesProxy(recordSize.width, recordSize.height)
private val profileFhd = EncoderProfilesUtil.createFakeEncoderProfilesProxy(1920, 1080)
@@ -319,7 +317,7 @@
@Test
fun checkLimitedSurfaceCombinationSupportedInLimitedDevice() {
- setupCamera(CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED)
+ setupCamera(INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED)
val supportedSurfaceCombination =
SupportedSurfaceCombination(context, fakeCameraMetadata, mockEncoderProfilesAdapter)
val combinationList = getLimitedSupportedCombinationList()
@@ -338,7 +336,7 @@
@Test
fun checkFullSurfaceCombinationNotSupportedInLimitedDevice() {
- setupCamera(CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED)
+ setupCamera(INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED)
val supportedSurfaceCombination =
SupportedSurfaceCombination(context, fakeCameraMetadata, mockEncoderProfilesAdapter)
val combinationList = getFullSupportedCombinationList()
@@ -357,7 +355,7 @@
@Test
fun checkLevel3SurfaceCombinationNotSupportedInLimitedDevice() {
- setupCamera(CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED)
+ setupCamera(INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED)
val supportedSurfaceCombination =
SupportedSurfaceCombination(context, fakeCameraMetadata, mockEncoderProfilesAdapter)
val combinationList = getLevel3SupportedCombinationList()
@@ -648,8 +646,7 @@
ImageFormat.YUV_420_888,
vgaSize
)
- val expectedSurfaceConfig =
- SurfaceConfig.create(SurfaceConfig.ConfigType.YUV, SurfaceConfig.ConfigSize.VGA)
+ val expectedSurfaceConfig = SurfaceConfig.create(ConfigType.YUV, ConfigSize.VGA)
assertThat(surfaceConfig).isEqualTo(expectedSurfaceConfig)
}
@@ -664,8 +661,7 @@
ImageFormat.YUV_420_888,
previewSize
)
- val expectedSurfaceConfig =
- SurfaceConfig.create(SurfaceConfig.ConfigType.YUV, SurfaceConfig.ConfigSize.PREVIEW)
+ val expectedSurfaceConfig = SurfaceConfig.create(ConfigType.YUV, ConfigSize.PREVIEW)
assertThat(surfaceConfig).isEqualTo(expectedSurfaceConfig)
}
@@ -680,8 +676,7 @@
ImageFormat.YUV_420_888,
recordSize
)
- val expectedSurfaceConfig =
- SurfaceConfig.create(SurfaceConfig.ConfigType.YUV, SurfaceConfig.ConfigSize.RECORD)
+ val expectedSurfaceConfig = SurfaceConfig.create(ConfigType.YUV, ConfigSize.RECORD)
assertThat(surfaceConfig).isEqualTo(expectedSurfaceConfig)
}
@@ -696,8 +691,7 @@
ImageFormat.YUV_420_888,
maximumSize
)
- val expectedSurfaceConfig =
- SurfaceConfig.create(SurfaceConfig.ConfigType.YUV, SurfaceConfig.ConfigSize.MAXIMUM)
+ val expectedSurfaceConfig = SurfaceConfig.create(ConfigType.YUV, ConfigSize.MAXIMUM)
assertThat(surfaceConfig).isEqualTo(expectedSurfaceConfig)
}
@@ -712,8 +706,7 @@
ImageFormat.JPEG,
vgaSize
)
- val expectedSurfaceConfig =
- SurfaceConfig.create(SurfaceConfig.ConfigType.JPEG, SurfaceConfig.ConfigSize.VGA)
+ val expectedSurfaceConfig = SurfaceConfig.create(ConfigType.JPEG, ConfigSize.VGA)
assertThat(surfaceConfig).isEqualTo(expectedSurfaceConfig)
}
@@ -728,8 +721,7 @@
ImageFormat.JPEG,
previewSize
)
- val expectedSurfaceConfig =
- SurfaceConfig.create(SurfaceConfig.ConfigType.JPEG, SurfaceConfig.ConfigSize.PREVIEW)
+ val expectedSurfaceConfig = SurfaceConfig.create(ConfigType.JPEG, ConfigSize.PREVIEW)
assertThat(surfaceConfig).isEqualTo(expectedSurfaceConfig)
}
@@ -744,8 +736,7 @@
ImageFormat.JPEG,
recordSize
)
- val expectedSurfaceConfig =
- SurfaceConfig.create(SurfaceConfig.ConfigType.JPEG, SurfaceConfig.ConfigSize.RECORD)
+ val expectedSurfaceConfig = SurfaceConfig.create(ConfigType.JPEG, ConfigSize.RECORD)
assertThat(surfaceConfig).isEqualTo(expectedSurfaceConfig)
}
@@ -760,8 +751,7 @@
ImageFormat.JPEG,
maximumSize
)
- val expectedSurfaceConfig =
- SurfaceConfig.create(SurfaceConfig.ConfigType.JPEG, SurfaceConfig.ConfigSize.MAXIMUM)
+ val expectedSurfaceConfig = SurfaceConfig.create(ConfigType.JPEG, ConfigSize.MAXIMUM)
assertThat(surfaceConfig).isEqualTo(expectedSurfaceConfig)
}
@@ -776,10 +766,9 @@
supportedSurfaceCombination.transformSurfaceConfig(
CameraMode.CONCURRENT_CAMERA,
ImageFormat.PRIVATE,
- SizeUtil.RESOLUTION_720P
+ RESOLUTION_720P
)
- val expectedSurfaceConfig =
- SurfaceConfig.create(SurfaceConfig.ConfigType.PRIV, SurfaceConfig.ConfigSize.s720p)
+ val expectedSurfaceConfig = SurfaceConfig.create(ConfigType.PRIV, ConfigSize.s720p)
assertThat(surfaceConfig).isEqualTo(expectedSurfaceConfig)
}
@@ -794,10 +783,9 @@
supportedSurfaceCombination.transformSurfaceConfig(
CameraMode.CONCURRENT_CAMERA,
ImageFormat.YUV_420_888,
- SizeUtil.RESOLUTION_720P
+ RESOLUTION_720P
)
- val expectedSurfaceConfig =
- SurfaceConfig.create(SurfaceConfig.ConfigType.YUV, SurfaceConfig.ConfigSize.s720p)
+ val expectedSurfaceConfig = SurfaceConfig.create(ConfigType.YUV, ConfigSize.s720p)
assertThat(surfaceConfig).isEqualTo(expectedSurfaceConfig)
}
@@ -812,10 +800,9 @@
supportedSurfaceCombination.transformSurfaceConfig(
CameraMode.CONCURRENT_CAMERA,
ImageFormat.JPEG,
- SizeUtil.RESOLUTION_720P
+ RESOLUTION_720P
)
- val expectedSurfaceConfig =
- SurfaceConfig.create(SurfaceConfig.ConfigType.JPEG, SurfaceConfig.ConfigSize.s720p)
+ val expectedSurfaceConfig = SurfaceConfig.create(ConfigType.JPEG, ConfigSize.s720p)
assertThat(surfaceConfig).isEqualTo(expectedSurfaceConfig)
}
@@ -832,8 +819,7 @@
ImageFormat.PRIVATE,
RESOLUTION_1440P
)
- val expectedSurfaceConfig =
- SurfaceConfig.create(SurfaceConfig.ConfigType.PRIV, SurfaceConfig.ConfigSize.s1440p)
+ val expectedSurfaceConfig = SurfaceConfig.create(ConfigType.PRIV, ConfigSize.s1440p)
assertThat(surfaceConfig).isEqualTo(expectedSurfaceConfig)
}
@@ -850,8 +836,7 @@
ImageFormat.YUV_420_888,
RESOLUTION_1440P
)
- val expectedSurfaceConfig =
- SurfaceConfig.create(SurfaceConfig.ConfigType.YUV, SurfaceConfig.ConfigSize.s1440p)
+ val expectedSurfaceConfig = SurfaceConfig.create(ConfigType.YUV, ConfigSize.s1440p)
assertThat(surfaceConfig).isEqualTo(expectedSurfaceConfig)
}
@@ -868,8 +853,7 @@
ImageFormat.JPEG,
RESOLUTION_1440P
)
- val expectedSurfaceConfig =
- SurfaceConfig.create(SurfaceConfig.ConfigType.JPEG, SurfaceConfig.ConfigSize.s1440p)
+ val expectedSurfaceConfig = SurfaceConfig.create(ConfigType.JPEG, ConfigSize.s1440p)
assertThat(surfaceConfig).isEqualTo(expectedSurfaceConfig)
}
@@ -894,12 +878,7 @@
ultraHighMaximumSize
)
)
- .isEqualTo(
- SurfaceConfig.create(
- SurfaceConfig.ConfigType.PRIV,
- SurfaceConfig.ConfigSize.ULTRA_MAXIMUM
- )
- )
+ .isEqualTo(SurfaceConfig.create(ConfigType.PRIV, ConfigSize.ULTRA_MAXIMUM))
assertThat(
supportedSurfaceCombination.transformSurfaceConfig(
CameraMode.DEFAULT,
@@ -907,12 +886,7 @@
ultraHighMaximumSize
)
)
- .isEqualTo(
- SurfaceConfig.create(
- SurfaceConfig.ConfigType.YUV,
- SurfaceConfig.ConfigSize.ULTRA_MAXIMUM
- )
- )
+ .isEqualTo(SurfaceConfig.create(ConfigType.YUV, ConfigSize.ULTRA_MAXIMUM))
assertThat(
supportedSurfaceCombination.transformSurfaceConfig(
CameraMode.DEFAULT,
@@ -920,12 +894,7 @@
ultraHighMaximumSize
)
)
- .isEqualTo(
- SurfaceConfig.create(
- SurfaceConfig.ConfigType.JPEG,
- SurfaceConfig.ConfigSize.ULTRA_MAXIMUM
- )
- )
+ .isEqualTo(SurfaceConfig.create(ConfigType.JPEG, ConfigSize.ULTRA_MAXIMUM))
}
// //////////////////////////////////////////////////////////////////////////////////////////
@@ -937,7 +906,7 @@
/** PRIV/MAXIMUM */
@Test
fun canSelectCorrectSize_singlePrivStream_inLegacyDevice() {
- val privUseCase = createUseCase(UseCaseConfigFactory.CaptureType.VIDEO_CAPTURE)
+ val privUseCase = createUseCase(CaptureType.VIDEO_CAPTURE)
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply { put(privUseCase, maximumSize) }
getSuggestedSpecsAndVerify(useCaseExpectedResultMap)
@@ -946,7 +915,7 @@
/** JPEG/MAXIMUM */
@Test
fun canSelectCorrectSize_singleJpegStream_inLegacyDevice() {
- val jpegUseCase = createUseCase(UseCaseConfigFactory.CaptureType.IMAGE_CAPTURE)
+ val jpegUseCase = createUseCase(CaptureType.IMAGE_CAPTURE)
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply { put(jpegUseCase, maximumSize) }
getSuggestedSpecsAndVerify(useCaseExpectedResultMap)
@@ -955,7 +924,7 @@
/** YUV/MAXIMUM */
@Test
fun canSelectCorrectSize_singleYuvStream_inLegacyDevice() {
- val yuvUseCase = createUseCase(UseCaseConfigFactory.CaptureType.IMAGE_ANALYSIS)
+ val yuvUseCase = createUseCase(CaptureType.IMAGE_ANALYSIS)
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply { put(yuvUseCase, maximumSize) }
getSuggestedSpecsAndVerify(useCaseExpectedResultMap)
@@ -964,8 +933,8 @@
/** PRIV/PREVIEW + JPEG/MAXIMUM */
@Test
fun canSelectCorrectSizes_privPlusJpeg_inLegacyDevice() {
- val privUseCase = createUseCase(UseCaseConfigFactory.CaptureType.PREVIEW)
- val jpegUseCase = createUseCase(UseCaseConfigFactory.CaptureType.IMAGE_CAPTURE)
+ val privUseCase = createUseCase(CaptureType.PREVIEW)
+ val jpegUseCase = createUseCase(CaptureType.IMAGE_CAPTURE)
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply {
put(privUseCase, if (Build.VERSION.SDK_INT == 21) RESOLUTION_VGA else previewSize)
@@ -977,8 +946,8 @@
/** YUV/PREVIEW + JPEG/MAXIMUM */
@Test
fun canSelectCorrectSizes_yuvPlusJpeg_inLegacyDevice() {
- val yuvUseCase = createUseCase(UseCaseConfigFactory.CaptureType.IMAGE_ANALYSIS) // YUV
- val jpegUseCase = createUseCase(UseCaseConfigFactory.CaptureType.IMAGE_CAPTURE) // JPEG
+ val yuvUseCase = createUseCase(CaptureType.IMAGE_ANALYSIS) // YUV
+ val jpegUseCase = createUseCase(CaptureType.IMAGE_CAPTURE) // JPEG
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply {
put(yuvUseCase, if (Build.VERSION.SDK_INT == 21) RESOLUTION_VGA else previewSize)
@@ -990,8 +959,8 @@
/** PRIV/PREVIEW + PRIV/PREVIEW */
@Test
fun canSelectCorrectSizes_privPlusPriv_inLegacyDevice() {
- val privUseCase1 = createUseCase(UseCaseConfigFactory.CaptureType.PREVIEW) // PRIV
- val privUseCase2 = createUseCase(UseCaseConfigFactory.CaptureType.VIDEO_CAPTURE) // PRIV
+ val privUseCase1 = createUseCase(CaptureType.PREVIEW) // PRIV
+ val privUseCase2 = createUseCase(CaptureType.VIDEO_CAPTURE) // PRIV
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply {
put(privUseCase1, if (Build.VERSION.SDK_INT == 21) RESOLUTION_VGA else previewSize)
@@ -1003,8 +972,8 @@
/** PRIV/PREVIEW + YUV/PREVIEW */
@Test
fun canSelectCorrectSizes_privPlusYuv_inLegacyDevice() {
- val privUseCase = createUseCase(UseCaseConfigFactory.CaptureType.PREVIEW) // PRIV
- val yuvUseCase = createUseCase(UseCaseConfigFactory.CaptureType.IMAGE_ANALYSIS) // YUV
+ val privUseCase = createUseCase(CaptureType.PREVIEW) // PRIV
+ val yuvUseCase = createUseCase(CaptureType.IMAGE_ANALYSIS) // YUV
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply {
put(privUseCase, if (Build.VERSION.SDK_INT == 21) RESOLUTION_VGA else previewSize)
@@ -1016,9 +985,9 @@
/** PRIV/PREVIEW + YUV/PREVIEW + JPEG/MAXIMUM */
@Test
fun canSelectCorrectSizes_privPlusYuvPlusJpeg_inLegacyDevice() {
- val privUseCase = createUseCase(UseCaseConfigFactory.CaptureType.PREVIEW) // PRIV
- val yuvUseCase = createUseCase(UseCaseConfigFactory.CaptureType.IMAGE_ANALYSIS) // YUV
- val jpegUseCase = createUseCase(UseCaseConfigFactory.CaptureType.IMAGE_CAPTURE) // JPEG
+ val privUseCase = createUseCase(CaptureType.PREVIEW) // PRIV
+ val yuvUseCase = createUseCase(CaptureType.IMAGE_ANALYSIS) // YUV
+ val jpegUseCase = createUseCase(CaptureType.IMAGE_CAPTURE) // JPEG
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply {
put(privUseCase, if (Build.VERSION.SDK_INT == 21) RESOLUTION_VGA else previewSize)
@@ -1031,9 +1000,9 @@
/** Unsupported PRIV + JPEG + PRIV for legacy level devices */
@Test
fun throwsException_unsupportedConfiguration_inLegacyDevice() {
- val privUseCase1 = createUseCase(UseCaseConfigFactory.CaptureType.PREVIEW) // PRIV
- val jpegUseCase = createUseCase(UseCaseConfigFactory.CaptureType.IMAGE_CAPTURE) // JPEG
- val privUseCas2 = createUseCase(UseCaseConfigFactory.CaptureType.VIDEO_CAPTURE) // PRIV
+ val privUseCase1 = createUseCase(CaptureType.PREVIEW) // PRIV
+ val jpegUseCase = createUseCase(CaptureType.IMAGE_CAPTURE) // JPEG
+ val privUseCas2 = createUseCase(CaptureType.VIDEO_CAPTURE) // PRIV
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply {
put(privUseCase1, RESOLUTION_VGA)
@@ -1054,8 +1023,8 @@
/** PRIV/PREVIEW + PRIV/RECORD */
@Test
fun canSelectCorrectSizes_privPlusPriv_inLimitedDevice() {
- val privUseCase1 = createUseCase(UseCaseConfigFactory.CaptureType.VIDEO_CAPTURE) // PRIV
- val privUseCas2 = createUseCase(UseCaseConfigFactory.CaptureType.PREVIEW) // PRIV
+ val privUseCase1 = createUseCase(CaptureType.VIDEO_CAPTURE) // PRIV
+ val privUseCas2 = createUseCase(CaptureType.PREVIEW) // PRIV
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply {
put(privUseCase1, recordSize)
@@ -1063,15 +1032,15 @@
}
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED
)
}
/** PRIV/PREVIEW + YUV/RECORD */
@Test
fun canSelectCorrectSizes_privPlusYuv_inLimitedDevice() {
- val privUseCase = createUseCase(UseCaseConfigFactory.CaptureType.PREVIEW) // PRIV
- val yuvUseCase = createUseCase(UseCaseConfigFactory.CaptureType.IMAGE_ANALYSIS) // YUV
+ val privUseCase = createUseCase(CaptureType.PREVIEW) // PRIV
+ val yuvUseCase = createUseCase(CaptureType.IMAGE_ANALYSIS) // YUV
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply {
put(privUseCase, previewSize)
@@ -1079,15 +1048,15 @@
}
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED
)
}
/** YUV/PREVIEW + YUV/RECORD */
@Test
fun canSelectCorrectSizes_yuvPlusYuv_inLimitedDevice() {
- val yuvUseCase1 = createUseCase(UseCaseConfigFactory.CaptureType.IMAGE_ANALYSIS) // YUV
- val yuvUseCase2 = createUseCase(UseCaseConfigFactory.CaptureType.IMAGE_ANALYSIS) // YUV
+ val yuvUseCase1 = createUseCase(CaptureType.IMAGE_ANALYSIS) // YUV
+ val yuvUseCase2 = createUseCase(CaptureType.IMAGE_ANALYSIS) // YUV
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply {
put(yuvUseCase1, recordSize)
@@ -1095,16 +1064,16 @@
}
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED
)
}
/** PRIV/PREVIEW + PRIV/RECORD + JPEG/RECORD */
@Test
fun canSelectCorrectSizes_privPlusPrivPlusJpeg_inLimitedDevice() {
- val privUseCase1 = createUseCase(UseCaseConfigFactory.CaptureType.VIDEO_CAPTURE) // PRIV
- val privUseCase2 = createUseCase(UseCaseConfigFactory.CaptureType.PREVIEW) // PRIV
- val jpegUseCase = createUseCase(UseCaseConfigFactory.CaptureType.IMAGE_CAPTURE) // JPEG
+ val privUseCase1 = createUseCase(CaptureType.VIDEO_CAPTURE) // PRIV
+ val privUseCase2 = createUseCase(CaptureType.PREVIEW) // PRIV
+ val jpegUseCase = createUseCase(CaptureType.IMAGE_CAPTURE) // JPEG
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply {
put(privUseCase1, recordSize)
@@ -1113,16 +1082,16 @@
}
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED
)
}
/** PRIV/PREVIEW + YUV/RECORD + JPEG/RECORD */
@Test
fun canSelectCorrectSizes_privPlusYuvPlusJpeg_inLimitedDevice() {
- val privUseCase = createUseCase(UseCaseConfigFactory.CaptureType.PREVIEW) // PRIV
- val yuvUseCase = createUseCase(UseCaseConfigFactory.CaptureType.IMAGE_ANALYSIS) // YUV
- val jpegUseCase = createUseCase(UseCaseConfigFactory.CaptureType.IMAGE_CAPTURE) // JPEG
+ val privUseCase = createUseCase(CaptureType.PREVIEW) // PRIV
+ val yuvUseCase = createUseCase(CaptureType.IMAGE_ANALYSIS) // YUV
+ val jpegUseCase = createUseCase(CaptureType.IMAGE_CAPTURE) // JPEG
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply {
put(privUseCase, previewSize)
@@ -1131,16 +1100,16 @@
}
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED
)
}
/** YUV/PREVIEW + YUV/PREVIEW + JPEG/MAXIMUM */
@Test
fun canSelectCorrectSizes_yuvPlusYuvPlusJpeg_inLimitedDevice() {
- val yuvUseCase1 = createUseCase(UseCaseConfigFactory.CaptureType.IMAGE_ANALYSIS) // YUV
- val yuvUseCase2 = createUseCase(UseCaseConfigFactory.CaptureType.IMAGE_ANALYSIS) // YUV
- val jpegUseCase = createUseCase(UseCaseConfigFactory.CaptureType.IMAGE_CAPTURE) // JPEG
+ val yuvUseCase1 = createUseCase(CaptureType.IMAGE_ANALYSIS) // YUV
+ val yuvUseCase2 = createUseCase(CaptureType.IMAGE_ANALYSIS) // YUV
+ val jpegUseCase = createUseCase(CaptureType.IMAGE_CAPTURE) // JPEG
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply {
put(yuvUseCase1, previewSize)
@@ -1149,16 +1118,16 @@
}
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED
)
}
/** Unsupported YUV + PRIV + YUV for limited level devices */
@Test
fun throwsException_unsupportedConfiguration_inLimitedDevice() {
- val yuvUseCase1 = createUseCase(UseCaseConfigFactory.CaptureType.IMAGE_ANALYSIS) // YUV
- val privUseCase = createUseCase(UseCaseConfigFactory.CaptureType.PREVIEW) // PRIV
- val yuvUseCase2 = createUseCase(UseCaseConfigFactory.CaptureType.IMAGE_ANALYSIS) // YUV
+ val yuvUseCase1 = createUseCase(CaptureType.IMAGE_ANALYSIS) // YUV
+ val privUseCase = createUseCase(CaptureType.PREVIEW) // PRIV
+ val yuvUseCase2 = createUseCase(CaptureType.IMAGE_ANALYSIS) // YUV
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply {
put(yuvUseCase1, RESOLUTION_VGA)
@@ -1168,7 +1137,7 @@
Assert.assertThrows(IllegalArgumentException::class.java) {
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED
)
}
}
@@ -1182,8 +1151,8 @@
/** PRIV/PREVIEW + PRIV/MAXIMUM */
@Test
fun canSelectCorrectSizes_privPlusPriv_inFullDevice() {
- val privUseCase1 = createUseCase(UseCaseConfigFactory.CaptureType.VIDEO_CAPTURE) // PRIV
- val privUseCase2 = createUseCase(UseCaseConfigFactory.CaptureType.PREVIEW) // PRIV
+ val privUseCase1 = createUseCase(CaptureType.VIDEO_CAPTURE) // PRIV
+ val privUseCase2 = createUseCase(CaptureType.PREVIEW) // PRIV
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply {
put(privUseCase1, maximumSize)
@@ -1198,8 +1167,8 @@
/** PRIV/PREVIEW + YUV/MAXIMUM */
@Test
fun canSelectCorrectSizes_privPlusYuv_inFullDevice() {
- val privUseCase = createUseCase(UseCaseConfigFactory.CaptureType.PREVIEW) // PRIV
- val yuvUseCase = createUseCase(UseCaseConfigFactory.CaptureType.IMAGE_ANALYSIS) // YUV
+ val privUseCase = createUseCase(CaptureType.PREVIEW) // PRIV
+ val yuvUseCase = createUseCase(CaptureType.IMAGE_ANALYSIS) // YUV
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply {
put(privUseCase, previewSize)
@@ -1214,8 +1183,8 @@
/** YUV/PREVIEW + YUV/MAXIMUM */
@Test
fun canSelectCorrectSizes_yuvPlusYuv_inFullDevice() {
- val yuvUseCase1 = createUseCase(UseCaseConfigFactory.CaptureType.IMAGE_ANALYSIS) // YUV
- val yuvUseCase2 = createUseCase(UseCaseConfigFactory.CaptureType.IMAGE_ANALYSIS) // YUV
+ val yuvUseCase1 = createUseCase(CaptureType.IMAGE_ANALYSIS) // YUV
+ val yuvUseCase2 = createUseCase(CaptureType.IMAGE_ANALYSIS) // YUV
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply {
put(yuvUseCase1, maximumSize)
@@ -1230,9 +1199,9 @@
/** PRIV/PREVIEW + PRIV/PREVIEW + JPEG/MAXIMUM */
@Test
fun canSelectCorrectSizes_privPlusPrivPlusJpeg_inFullDevice() {
- val jpegUseCase = createUseCase(UseCaseConfigFactory.CaptureType.IMAGE_CAPTURE) // JPEG
- val privUseCase1 = createUseCase(UseCaseConfigFactory.CaptureType.VIDEO_CAPTURE) // PRIV
- val privUseCase2 = createUseCase(UseCaseConfigFactory.CaptureType.PREVIEW) // PRIV
+ val jpegUseCase = createUseCase(CaptureType.IMAGE_CAPTURE) // JPEG
+ val privUseCase1 = createUseCase(CaptureType.VIDEO_CAPTURE) // PRIV
+ val privUseCase2 = createUseCase(CaptureType.PREVIEW) // PRIV
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply {
put(jpegUseCase, maximumSize)
@@ -1248,9 +1217,9 @@
/** YUV/VGA + PRIV/PREVIEW + YUV/MAXIMUM */
@Test
fun canSelectCorrectSizes_yuvPlusPrivPlusYuv_inFullDevice() {
- val privUseCase = createUseCase(UseCaseConfigFactory.CaptureType.PREVIEW) // PRIV
- val yuvUseCase1 = createUseCase(UseCaseConfigFactory.CaptureType.IMAGE_ANALYSIS) // YUV
- val yuvUseCase2 = createUseCase(UseCaseConfigFactory.CaptureType.IMAGE_ANALYSIS) // YUV
+ val privUseCase = createUseCase(CaptureType.PREVIEW) // PRIV
+ val yuvUseCase1 = createUseCase(CaptureType.IMAGE_ANALYSIS) // YUV
+ val yuvUseCase2 = createUseCase(CaptureType.IMAGE_ANALYSIS) // YUV
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply {
put(privUseCase, previewSize)
@@ -1266,9 +1235,9 @@
/** YUV/VGA + YUV/PREVIEW + YUV/MAXIMUM */
@Test
fun canSelectCorrectSizes_yuvPlusYuvPlusYuv_inFullDevice() {
- val yuvUseCase1 = createUseCase(UseCaseConfigFactory.CaptureType.IMAGE_ANALYSIS) // YUV
- val yuvUseCase2 = createUseCase(UseCaseConfigFactory.CaptureType.IMAGE_ANALYSIS) // YUV
- val yuvUseCase3 = createUseCase(UseCaseConfigFactory.CaptureType.IMAGE_ANALYSIS) // YUV
+ val yuvUseCase1 = createUseCase(CaptureType.IMAGE_ANALYSIS) // YUV
+ val yuvUseCase2 = createUseCase(CaptureType.IMAGE_ANALYSIS) // YUV
+ val yuvUseCase3 = createUseCase(CaptureType.IMAGE_ANALYSIS) // YUV
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply {
put(yuvUseCase1, maximumSize)
@@ -1284,9 +1253,9 @@
/** Unsupported PRIV + PRIV + YUV + RAW for full level devices */
@Test
fun throwsException_unsupportedConfiguration_inFullDevice() {
- val privUseCase1 = createUseCase(UseCaseConfigFactory.CaptureType.VIDEO_CAPTURE) // PRIV
- val privUseCase2 = createUseCase(UseCaseConfigFactory.CaptureType.PREVIEW) // PRIV
- val yuvUseCase = createUseCase(UseCaseConfigFactory.CaptureType.IMAGE_ANALYSIS) // YUV
+ val privUseCase1 = createUseCase(CaptureType.VIDEO_CAPTURE) // PRIV
+ val privUseCase2 = createUseCase(CaptureType.PREVIEW) // PRIV
+ val yuvUseCase = createUseCase(CaptureType.IMAGE_ANALYSIS) // YUV
val rawUseCase = createRawUseCase() // RAW
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply {
@@ -1298,7 +1267,7 @@
assertThrows(IllegalArgumentException::class.java) {
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED
)
}
}
@@ -1312,9 +1281,9 @@
/** PRIV/PREVIEW + PRIV/VGA + YUV/MAXIMUM + RAW/MAXIMUM */
@Test
fun canSelectCorrectSizes_privPlusPrivPlusYuvPlusRaw_inLevel3Device() {
- val privUseCase1 = createUseCase(UseCaseConfigFactory.CaptureType.VIDEO_CAPTURE) // PRIV
- val privUseCase2 = createUseCase(UseCaseConfigFactory.CaptureType.PREVIEW) // PRIV
- val yuvUseCase = createUseCase(UseCaseConfigFactory.CaptureType.IMAGE_ANALYSIS) // YUV
+ val privUseCase1 = createUseCase(CaptureType.VIDEO_CAPTURE) // PRIV
+ val privUseCase2 = createUseCase(CaptureType.PREVIEW) // PRIV
+ val yuvUseCase = createUseCase(CaptureType.IMAGE_ANALYSIS) // YUV
val rawUseCase = createRawUseCase() // RAW
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply {
@@ -1333,9 +1302,9 @@
/** PRIV/PREVIEW + PRIV/VGA + JPEG/MAXIMUM + RAW/MAXIMUM */
@Test
fun canSelectCorrectSizes_privPlusPrivPlusJpegPlusRaw_inLevel3Device() {
- val privUseCase1 = createUseCase(UseCaseConfigFactory.CaptureType.VIDEO_CAPTURE) // PRIV
- val privUseCase2 = createUseCase(UseCaseConfigFactory.CaptureType.PREVIEW) // PRIV
- val jpegUseCase = createUseCase(UseCaseConfigFactory.CaptureType.IMAGE_CAPTURE) // JPEG
+ val privUseCase1 = createUseCase(CaptureType.VIDEO_CAPTURE) // PRIV
+ val privUseCase2 = createUseCase(CaptureType.PREVIEW) // PRIV
+ val jpegUseCase = createUseCase(CaptureType.IMAGE_CAPTURE) // JPEG
val rawUseCase = createRawUseCase() // RAW
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply {
@@ -1354,9 +1323,9 @@
/** Unsupported PRIV + YUV + YUV + RAW for level-3 devices */
@Test
fun throwsException_unsupportedConfiguration_inLevel3Device() {
- val privUseCase = createUseCase(UseCaseConfigFactory.CaptureType.PREVIEW) // PRIV
- val yuvUseCase1 = createUseCase(UseCaseConfigFactory.CaptureType.IMAGE_ANALYSIS) // YUV
- val yuvUseCase2 = createUseCase(UseCaseConfigFactory.CaptureType.IMAGE_ANALYSIS) // YUV
+ val privUseCase = createUseCase(CaptureType.PREVIEW) // PRIV
+ val yuvUseCase1 = createUseCase(CaptureType.IMAGE_ANALYSIS) // YUV
+ val yuvUseCase2 = createUseCase(CaptureType.IMAGE_ANALYSIS) // YUV
val rawUseCase = createRawUseCase() // RAW
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply {
@@ -1382,8 +1351,8 @@
/** PRIV/PREVIEW + PRIV/MAXIMUM */
@Test
fun canSelectCorrectSizes_privPlusPriv_inLimitedDevice_withBurstCapability() {
- val privUseCase1 = createUseCase(UseCaseConfigFactory.CaptureType.VIDEO_CAPTURE) // PRIV
- val privUseCase2 = createUseCase(UseCaseConfigFactory.CaptureType.PREVIEW) // PRIV
+ val privUseCase1 = createUseCase(CaptureType.VIDEO_CAPTURE) // PRIV
+ val privUseCase2 = createUseCase(CaptureType.PREVIEW) // PRIV
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply {
put(privUseCase1, maximumSize)
@@ -1391,7 +1360,7 @@
}
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
capabilities =
intArrayOf(CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_BURST_CAPTURE)
)
@@ -1400,8 +1369,8 @@
/** PRIV/PREVIEW + YUV/MAXIMUM */
@Test
fun canSelectCorrectSizes_privPlusYuv_inLimitedDevice_withBurstCapability() {
- val privUseCase = createUseCase(UseCaseConfigFactory.CaptureType.PREVIEW) // PRIV
- val yuvUseCase = createUseCase(UseCaseConfigFactory.CaptureType.IMAGE_ANALYSIS) // YUV
+ val privUseCase = createUseCase(CaptureType.PREVIEW) // PRIV
+ val yuvUseCase = createUseCase(CaptureType.IMAGE_ANALYSIS) // YUV
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply {
put(privUseCase, previewSize)
@@ -1409,7 +1378,7 @@
}
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
capabilities =
intArrayOf(CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_BURST_CAPTURE)
)
@@ -1418,8 +1387,8 @@
/** YUV/PREVIEW + YUV/MAXIMUM */
@Test
fun canSelectCorrectSizes_yuvPlusYuv_inLimitedDevice_withBurstCapability() {
- val yuvUseCase1 = createUseCase(UseCaseConfigFactory.CaptureType.IMAGE_ANALYSIS) // YUV
- val yuvUseCase2 = createUseCase(UseCaseConfigFactory.CaptureType.IMAGE_ANALYSIS) // YUV
+ val yuvUseCase1 = createUseCase(CaptureType.IMAGE_ANALYSIS) // YUV
+ val yuvUseCase2 = createUseCase(CaptureType.IMAGE_ANALYSIS) // YUV
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply {
put(yuvUseCase1, maximumSize)
@@ -1427,7 +1396,7 @@
}
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
capabilities =
intArrayOf(CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_BURST_CAPTURE)
)
@@ -1447,7 +1416,7 @@
mutableMapOf<UseCase, Size>().apply { put(rawUseCase, maximumSize) }
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
capabilities = intArrayOf(CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_RAW)
)
}
@@ -1455,7 +1424,7 @@
/** PRIV/PREVIEW + RAW/MAXIMUM */
@Test
fun canSelectCorrectSizes_privPlusRAW_inLimitedDevice_withRawCapability() {
- val privUseCase = createUseCase(UseCaseConfigFactory.CaptureType.PREVIEW) // PRIV
+ val privUseCase = createUseCase(CaptureType.PREVIEW) // PRIV
val rawUseCase = createRawUseCase() // RAW
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply {
@@ -1464,7 +1433,7 @@
}
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
capabilities = intArrayOf(CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_RAW)
)
}
@@ -1472,8 +1441,8 @@
/** PRIV/PREVIEW + PRIV/PREVIEW + RAW/MAXIMUM */
@Test
fun canSelectCorrectSizes_privPlusPrivPlusRAW_inLimitedDevice_withRawCapability() {
- val privUseCase1 = createUseCase(UseCaseConfigFactory.CaptureType.VIDEO_CAPTURE) // PRIV
- val privUseCase2 = createUseCase(UseCaseConfigFactory.CaptureType.PREVIEW) // PRIV
+ val privUseCase1 = createUseCase(CaptureType.VIDEO_CAPTURE) // PRIV
+ val privUseCase2 = createUseCase(CaptureType.PREVIEW) // PRIV
val rawUseCase = createRawUseCase() // RAW
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply {
@@ -1483,7 +1452,7 @@
}
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
capabilities = intArrayOf(CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_RAW)
)
}
@@ -1491,8 +1460,8 @@
/** PRIV/PREVIEW + YUV/PREVIEW + RAW/MAXIMUM */
@Test
fun canSelectCorrectSizes_privPlusYuvPlusRAW_inLimitedDevice_withRawCapability() {
- val privUseCase = createUseCase(UseCaseConfigFactory.CaptureType.PREVIEW) // PRIV
- val yuvUseCase = createUseCase(UseCaseConfigFactory.CaptureType.IMAGE_ANALYSIS) // YUV
+ val privUseCase = createUseCase(CaptureType.PREVIEW) // PRIV
+ val yuvUseCase = createUseCase(CaptureType.IMAGE_ANALYSIS) // YUV
val rawUseCase = createRawUseCase() // RAW
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply {
@@ -1502,7 +1471,7 @@
}
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
capabilities = intArrayOf(CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_RAW)
)
}
@@ -1510,8 +1479,8 @@
/** YUV/PREVIEW + YUV/PREVIEW + RAW/MAXIMUM */
@Test
fun canSelectCorrectSizes_yuvPlusYuvPlusRAW_inLimitedDevice_withRawCapability() {
- val yuvUseCase1 = createUseCase(UseCaseConfigFactory.CaptureType.IMAGE_ANALYSIS) // YUV
- val yuvUseCase2 = createUseCase(UseCaseConfigFactory.CaptureType.IMAGE_ANALYSIS) // YUV
+ val yuvUseCase1 = createUseCase(CaptureType.IMAGE_ANALYSIS) // YUV
+ val yuvUseCase2 = createUseCase(CaptureType.IMAGE_ANALYSIS) // YUV
val rawUseCase = createRawUseCase() // RAW
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply {
@@ -1521,7 +1490,7 @@
}
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
capabilities = intArrayOf(CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_RAW)
)
}
@@ -1529,8 +1498,8 @@
/** PRIV/PREVIEW + JPEG/MAXIMUM + RAW/MAXIMUM */
@Test
fun canSelectCorrectSizes_privPlusJpegPlusRAW_inLimitedDevice_withRawCapability() {
- val privUseCase = createUseCase(UseCaseConfigFactory.CaptureType.PREVIEW) // PRIV
- val jpegUseCase = createUseCase(UseCaseConfigFactory.CaptureType.IMAGE_CAPTURE) // JPEG
+ val privUseCase = createUseCase(CaptureType.PREVIEW) // PRIV
+ val jpegUseCase = createUseCase(CaptureType.IMAGE_CAPTURE) // JPEG
val rawUseCase = createRawUseCase() // RAW
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply {
@@ -1540,7 +1509,7 @@
}
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
capabilities = intArrayOf(CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_RAW)
)
}
@@ -1548,8 +1517,8 @@
/** YUV/PREVIEW + JPEG/MAXIMUM + RAW/MAXIMUM */
@Test
fun canSelectCorrectSizes_yuvPlusJpegPlusRAW_inLimitedDevice_withRawCapability() {
- val yuvUseCase = createUseCase(UseCaseConfigFactory.CaptureType.IMAGE_ANALYSIS) // YUV
- val jpegUseCase = createUseCase(UseCaseConfigFactory.CaptureType.IMAGE_CAPTURE) // JPEG
+ val yuvUseCase = createUseCase(CaptureType.IMAGE_ANALYSIS) // YUV
+ val jpegUseCase = createUseCase(CaptureType.IMAGE_CAPTURE) // JPEG
val rawUseCase = createRawUseCase() // RAW
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply {
@@ -1559,7 +1528,7 @@
}
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
capabilities = intArrayOf(CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_RAW)
)
}
@@ -1861,10 +1830,7 @@
@Config(minSdk = Build.VERSION_CODES.TIRAMISU)
@Test
fun check10BitDynamicRangeCombinationsSupported() {
- setupCamera(
- capabilities =
- intArrayOf(CameraMetadata.REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT)
- )
+ setupCamera(capabilities = intArrayOf(REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT))
val supportedSurfaceCombination =
SupportedSurfaceCombination(context, fakeCameraMetadata, mockEncoderProfilesAdapter)
@@ -1873,7 +1839,7 @@
supportedSurfaceCombination.checkSupported(
SupportedSurfaceCombination.FeatureSettings(
CameraMode.DEFAULT,
- DynamicRange.BIT_DEPTH_10_BIT
+ BIT_DEPTH_10_BIT
),
it.surfaceConfigList
)
@@ -1886,10 +1852,7 @@
@Test
fun getSupportedStreamSpecThrows_whenUsingUnsupportedDynamicRange() {
val useCase =
- createUseCase(
- UseCaseConfigFactory.CaptureType.PREVIEW,
- dynamicRange = DynamicRange.HDR_UNSPECIFIED_10_BIT
- )
+ createUseCase(CaptureType.PREVIEW, dynamicRange = DynamicRange.HDR_UNSPECIFIED_10_BIT)
val useCaseExpectedResultMap =
mapOf(
useCase to Size(0, 0) // Should throw before verifying size
@@ -1898,8 +1861,7 @@
Assert.assertThrows(IllegalArgumentException::class.java) {
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
- capabilities =
- intArrayOf(CameraMetadata.REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT)
+ capabilities = intArrayOf(REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT)
)
}
}
@@ -1910,10 +1872,7 @@
Shadows.shadowOf(context.packageManager)
.setSystemFeature(PackageManager.FEATURE_CAMERA_CONCURRENT, true)
val useCase =
- createUseCase(
- UseCaseConfigFactory.CaptureType.PREVIEW,
- dynamicRange = DynamicRange.HDR_UNSPECIFIED_10_BIT
- )
+ createUseCase(CaptureType.PREVIEW, dynamicRange = DynamicRange.HDR_UNSPECIFIED_10_BIT)
val useCaseExpectedSizeMap =
mapOf(
useCase to Size(0, 0) // Should throw before verifying size
@@ -1934,10 +1893,7 @@
Shadows.shadowOf(context.packageManager)
.setSystemFeature(PackageManager.FEATURE_CAMERA_CONCURRENT, true)
val useCase =
- createUseCase(
- UseCaseConfigFactory.CaptureType.PREVIEW,
- dynamicRange = DynamicRange.HDR_UNSPECIFIED_10_BIT
- )
+ createUseCase(CaptureType.PREVIEW, dynamicRange = DynamicRange.HDR_UNSPECIFIED_10_BIT)
val useCaseExpectedSizeMap =
mapOf(
useCase to Size(0, 0) // Should throw before verifying size
@@ -1956,18 +1912,14 @@
@Test
fun dynamicRangeResolver_returnsHlg_dueToMandatory10Bit() {
val useCase =
- createUseCase(
- UseCaseConfigFactory.CaptureType.PREVIEW,
- dynamicRange = DynamicRange.HDR_UNSPECIFIED_10_BIT
- )
+ createUseCase(CaptureType.PREVIEW, dynamicRange = DynamicRange.HDR_UNSPECIFIED_10_BIT)
val useCaseExpectedSizeMap = mapOf(useCase to maximumSize)
- val useCaseExpectedDynamicRangeMap = mapOf(useCase to DynamicRange.HLG_10_BIT)
+ val useCaseExpectedDynamicRangeMap = mapOf(useCase to HLG_10_BIT)
getSuggestedSpecsAndVerify(
useCaseExpectedSizeMap,
dynamicRangeProfiles = HLG10_CONSTRAINED,
- capabilities =
- intArrayOf(CameraMetadata.REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT),
+ capabilities = intArrayOf(REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT),
useCasesExpectedDynamicRangeMap = useCaseExpectedDynamicRangeMap
)
}
@@ -1976,18 +1928,14 @@
@Test
fun dynamicRangeResolver_returnsHdr10_dueToRecommended10BitDynamicRange() {
val useCase =
- createUseCase(
- UseCaseConfigFactory.CaptureType.PREVIEW,
- dynamicRange = DynamicRange.HDR_UNSPECIFIED_10_BIT
- )
+ createUseCase(CaptureType.PREVIEW, dynamicRange = DynamicRange.HDR_UNSPECIFIED_10_BIT)
val useCaseExpectedSizeMap = mapOf(useCase to maximumSize)
val useCaseExpectedDynamicRangeMap = mapOf(useCase to DynamicRange.HDR10_10_BIT)
getSuggestedSpecsAndVerify(
useCaseExpectedSizeMap,
dynamicRangeProfiles = HDR10_UNCONSTRAINED,
- capabilities =
- intArrayOf(CameraMetadata.REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT),
+ capabilities = intArrayOf(REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT),
useCasesExpectedDynamicRangeMap = useCaseExpectedDynamicRangeMap,
default10BitProfile = DynamicRangeProfiles.HDR10
)
@@ -1998,7 +1946,7 @@
fun dynamicRangeResolver_returnsDolbyVision8_dueToSupportedDynamicRanges() {
val useCase =
createUseCase(
- UseCaseConfigFactory.CaptureType.PREVIEW,
+ CaptureType.PREVIEW,
dynamicRange =
DynamicRange(
DynamicRange.ENCODING_HDR_UNSPECIFIED,
@@ -2020,7 +1968,7 @@
fun dynamicRangeResolver_returnsDolbyVision8_fromUnspecifiedBitDepth() {
val useCase =
createUseCase(
- UseCaseConfigFactory.CaptureType.PREVIEW,
+ CaptureType.PREVIEW,
dynamicRange =
DynamicRange(
DynamicRange.ENCODING_DOLBY_VISION,
@@ -2042,7 +1990,7 @@
fun dynamicRangeResolver_returnsDolbyVision10_fromUnspecifiedBitDepth() {
val useCase =
createUseCase(
- UseCaseConfigFactory.CaptureType.PREVIEW,
+ CaptureType.PREVIEW,
dynamicRange =
DynamicRange(
DynamicRange.ENCODING_DOLBY_VISION,
@@ -2055,8 +2003,7 @@
getSuggestedSpecsAndVerify(
useCaseExpectedSizeMap,
dynamicRangeProfiles = DOLBY_VISION_10B_UNCONSTRAINED,
- capabilities =
- intArrayOf(CameraMetadata.REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT),
+ capabilities = intArrayOf(REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT),
useCasesExpectedDynamicRangeMap = useCaseExpectedDynamicRangeMap
)
}
@@ -2066,7 +2013,7 @@
fun dynamicRangeResolver_returnsDolbyVision8_fromUnspecifiedHdrWithUnspecifiedBitDepth() {
val useCase =
createUseCase(
- UseCaseConfigFactory.CaptureType.PREVIEW,
+ CaptureType.PREVIEW,
dynamicRange =
DynamicRange(
DynamicRange.ENCODING_HDR_UNSPECIFIED,
@@ -2088,7 +2035,7 @@
fun dynamicRangeResolver_returnsDolbyVision10_fromUnspecifiedHdrWithUnspecifiedBitDepth() {
val useCase =
createUseCase(
- UseCaseConfigFactory.CaptureType.PREVIEW,
+ CaptureType.PREVIEW,
dynamicRange =
DynamicRange(
DynamicRange.ENCODING_HDR_UNSPECIFIED,
@@ -2101,8 +2048,7 @@
getSuggestedSpecsAndVerify(
useCaseExpectedSizeMap,
dynamicRangeProfiles = DOLBY_VISION_CONSTRAINED,
- capabilities =
- intArrayOf(CameraMetadata.REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT),
+ capabilities = intArrayOf(REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT),
useCasesExpectedDynamicRangeMap = useCaseExpectedDynamicRangeMap,
default10BitProfile = DynamicRangeProfiles.DOLBY_VISION_10B_HDR_OEM
)
@@ -2111,14 +2057,10 @@
@Config(minSdk = Build.VERSION_CODES.TIRAMISU)
@Test
fun dynamicRangeResolver_returnsDolbyVision8_withUndefinedBitDepth_andFullyDefinedHlg10() {
- val videoUseCase =
- createUseCase(
- UseCaseConfigFactory.CaptureType.VIDEO_CAPTURE,
- dynamicRange = DynamicRange.HLG_10_BIT
- )
+ val videoUseCase = createUseCase(CaptureType.VIDEO_CAPTURE, dynamicRange = HLG_10_BIT)
val previewUseCase =
createUseCase(
- UseCaseConfigFactory.CaptureType.PREVIEW,
+ CaptureType.PREVIEW,
dynamicRange =
DynamicRange(
DynamicRange.ENCODING_DOLBY_VISION,
@@ -2128,16 +2070,12 @@
val useCaseExpectedSizeMap =
mutableMapOf(videoUseCase to recordSize, previewUseCase to previewSize)
val useCaseExpectedDynamicRangeMap =
- mapOf(
- videoUseCase to DynamicRange.HLG_10_BIT,
- previewUseCase to DynamicRange.DOLBY_VISION_8_BIT
- )
+ mapOf(videoUseCase to HLG_10_BIT, previewUseCase to DynamicRange.DOLBY_VISION_8_BIT)
getSuggestedSpecsAndVerify(
useCaseExpectedSizeMap,
dynamicRangeProfiles = DOLBY_VISION_8B_UNCONSTRAINED_HLG10_UNCONSTRAINED,
- capabilities =
- intArrayOf(CameraMetadata.REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT),
+ capabilities = intArrayOf(REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT),
useCasesExpectedDynamicRangeMap = useCaseExpectedDynamicRangeMap
)
}
@@ -2148,13 +2086,13 @@
// VideoCapture partially defined dynamic range
val videoUseCase =
createUseCase(
- UseCaseConfigFactory.CaptureType.VIDEO_CAPTURE,
+ CaptureType.VIDEO_CAPTURE,
dynamicRange = DynamicRange.HDR_UNSPECIFIED_10_BIT
)
// Preview fully defined dynamic range
val previewUseCase =
createUseCase(
- UseCaseConfigFactory.CaptureType.PREVIEW,
+ CaptureType.PREVIEW,
dynamicRange = DynamicRange.DOLBY_VISION_8_BIT,
)
val useCaseExpectedSizeMap =
@@ -2168,8 +2106,7 @@
getSuggestedSpecsAndVerify(
useCaseExpectedSizeMap,
dynamicRangeProfiles = DOLBY_VISION_CONSTRAINED,
- capabilities =
- intArrayOf(CameraMetadata.REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT),
+ capabilities = intArrayOf(REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT),
useCasesExpectedDynamicRangeMap = useCaseExpectedDynamicRangeMap
)
}
@@ -2180,25 +2117,21 @@
// VideoCapture partially defined dynamic range
val videoUseCase =
createUseCase(
- UseCaseConfigFactory.CaptureType.VIDEO_CAPTURE,
+ CaptureType.VIDEO_CAPTURE,
dynamicRange = DynamicRange.HDR_UNSPECIFIED_10_BIT
)
// Preview unspecified dynamic range
- val previewUseCase = createUseCase(UseCaseConfigFactory.CaptureType.PREVIEW)
+ val previewUseCase = createUseCase(CaptureType.PREVIEW)
val useCaseExpectedSizeMap =
mutableMapOf(videoUseCase to recordSize, previewUseCase to previewSize)
val useCaseExpectedDynamicRangeMap =
- mapOf(
- previewUseCase to DynamicRange.HLG_10_BIT,
- videoUseCase to DynamicRange.HLG_10_BIT
- )
+ mapOf(previewUseCase to HLG_10_BIT, videoUseCase to HLG_10_BIT)
getSuggestedSpecsAndVerify(
useCaseExpectedSizeMap,
dynamicRangeProfiles = HLG10_UNCONSTRAINED,
- capabilities =
- intArrayOf(CameraMetadata.REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT),
+ capabilities = intArrayOf(REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT),
useCasesExpectedDynamicRangeMap = useCaseExpectedDynamicRangeMap
)
}
@@ -2207,7 +2140,7 @@
@Test
fun dynamicRangeResolver_resolvesUnspecifiedDynamicRangeToSdr() {
// Preview unspecified dynamic range
- val useCase = createUseCase(UseCaseConfigFactory.CaptureType.PREVIEW)
+ val useCase = createUseCase(CaptureType.PREVIEW)
val useCaseExpectedSizeMap = mutableMapOf(useCase to maximumSize)
val useCaseExpectedDynamicRangeMap = mapOf(useCase to DynamicRange.SDR)
@@ -2215,8 +2148,7 @@
getSuggestedSpecsAndVerify(
useCaseExpectedSizeMap,
dynamicRangeProfiles = HLG10_CONSTRAINED,
- capabilities =
- intArrayOf(CameraMetadata.REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT),
+ capabilities = intArrayOf(REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT),
useCasesExpectedDynamicRangeMap = useCaseExpectedDynamicRangeMap
)
}
@@ -2224,7 +2156,7 @@
@Test
fun dynamicRangeResolver_resolvesToSdr_when10BitNotSupported() {
// Preview unspecified dynamic range
- val useCase = createUseCase(UseCaseConfigFactory.CaptureType.PREVIEW)
+ val useCase = createUseCase(CaptureType.PREVIEW)
val useCaseExpectedSizeMap = mutableMapOf(useCase to maximumSize)
val useCaseExpectedDynamicRangeMap = mapOf(useCase to DynamicRange.SDR)
@@ -2240,7 +2172,7 @@
// Preview unspecified dynamic range
val useCase =
createUseCase(
- UseCaseConfigFactory.CaptureType.PREVIEW,
+ CaptureType.PREVIEW,
dynamicRange =
DynamicRange(DynamicRange.ENCODING_SDR, DynamicRange.BIT_DEPTH_UNSPECIFIED)
)
@@ -2260,13 +2192,13 @@
// VideoCapture has 10-bit HDR range with constraint for 8-bit non-SDR range
val videoUseCase =
createUseCase(
- UseCaseConfigFactory.CaptureType.VIDEO_CAPTURE,
+ CaptureType.VIDEO_CAPTURE,
dynamicRange = DynamicRange.DOLBY_VISION_10_BIT
)
// Preview unspecified encoding but 8-bit bit depth
val previewUseCase =
createUseCase(
- UseCaseConfigFactory.CaptureType.PREVIEW,
+ CaptureType.PREVIEW,
dynamicRange =
DynamicRange(DynamicRange.ENCODING_UNSPECIFIED, DynamicRange.BIT_DEPTH_8_BIT)
)
@@ -2283,8 +2215,7 @@
getSuggestedSpecsAndVerify(
useCaseExpectedSizeMap,
useCasesExpectedDynamicRangeMap = useCaseExpectedDynamicRangeMap,
- capabilities =
- intArrayOf(CameraMetadata.REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT),
+ capabilities = intArrayOf(REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT),
dynamicRangeProfiles = DOLBY_VISION_CONSTRAINED
)
}
@@ -2294,7 +2225,7 @@
fun dynamicRangeResolver_resolvesToSdr_forUnspecified8Bit_whenNoOtherDynamicRangesPresent() {
val useCase =
createUseCase(
- UseCaseConfigFactory.CaptureType.PREVIEW,
+ CaptureType.PREVIEW,
dynamicRange =
DynamicRange(DynamicRange.ENCODING_UNSPECIFIED, DynamicRange.BIT_DEPTH_8_BIT)
)
@@ -2315,16 +2246,10 @@
fun dynamicRangeResolver_resolvesUnspecified8BitToDolbyVision8Bit_whenAlreadyPresent() {
// VideoCapture fully resolved Dolby Vision 8-bit
val videoUseCase =
- createUseCase(
- UseCaseConfigFactory.CaptureType.VIDEO_CAPTURE,
- dynamicRange = DynamicRange.DOLBY_VISION_8_BIT
- )
+ createUseCase(CaptureType.VIDEO_CAPTURE, dynamicRange = DynamicRange.DOLBY_VISION_8_BIT)
// Preview unspecified encoding / 8-bit
val previewUseCase =
- createUseCase(
- UseCaseConfigFactory.CaptureType.PREVIEW,
- dynamicRange = DynamicRange.UNSPECIFIED
- )
+ createUseCase(CaptureType.PREVIEW, dynamicRange = DynamicRange.UNSPECIFIED)
// Since there are no 10-bit dynamic ranges, the 10-bit resolution table isn't used.
// Instead, this will use the camera default LIMITED table which is limited to preview
@@ -2349,11 +2274,7 @@
@Test
fun tenBitTable_isUsed_whenAttaching10BitUseCaseToAlreadyAttachedSdrUseCases() {
// JPEG use case can't be attached with an existing PRIV + YUV in the 10-bit tables
- val useCase =
- createUseCase(
- UseCaseConfigFactory.CaptureType.IMAGE_CAPTURE,
- dynamicRange = DynamicRange.HLG_10_BIT
- )
+ val useCase = createUseCase(CaptureType.IMAGE_CAPTURE, dynamicRange = HLG_10_BIT)
val useCaseExpectedSizeMap =
mapOf(
// Size would be valid for LIMITED table
@@ -2362,24 +2283,21 @@
// existing surfaces (Preview + ImageAnalysis)
val attachedPreview =
AttachedSurfaceInfo.create(
- SurfaceConfig.create(
- SurfaceConfig.ConfigType.PRIV,
- SurfaceConfig.ConfigSize.PREVIEW
- ),
+ SurfaceConfig.create(ConfigType.PRIV, ConfigSize.PREVIEW),
ImageFormat.PRIVATE,
previewSize,
DynamicRange.SDR,
- listOf(UseCaseConfigFactory.CaptureType.PREVIEW),
+ listOf(CaptureType.PREVIEW),
useCase.currentConfig,
/*targetFrameRate=*/ null
)
val attachedAnalysis =
AttachedSurfaceInfo.create(
- SurfaceConfig.create(SurfaceConfig.ConfigType.YUV, SurfaceConfig.ConfigSize.RECORD),
+ SurfaceConfig.create(ConfigType.YUV, ConfigSize.RECORD),
ImageFormat.YUV_420_888,
recordSize,
DynamicRange.SDR,
- listOf(UseCaseConfigFactory.CaptureType.IMAGE_ANALYSIS),
+ listOf(CaptureType.IMAGE_ANALYSIS),
useCase.currentConfig,
/*targetFrameRate=*/ null
)
@@ -2389,10 +2307,9 @@
useCaseExpectedSizeMap,
attachedSurfaceInfoList = listOf(attachedPreview, attachedAnalysis),
// LIMITED allows this combination, but 10-bit table does not
- hardwareLevel = CameraMetadata.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
dynamicRangeProfiles = HLG10_SDR_CONSTRAINED,
- capabilities =
- intArrayOf(CameraMetadata.REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT)
+ capabilities = intArrayOf(REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT)
)
}
}
@@ -2400,11 +2317,7 @@
@Config(minSdk = Build.VERSION_CODES.TIRAMISU)
@Test
fun dynamicRangeConstraints_causeAutoResolutionToThrow() {
- val useCase =
- createUseCase(
- UseCaseConfigFactory.CaptureType.IMAGE_CAPTURE,
- dynamicRange = DynamicRange.HLG_10_BIT
- )
+ val useCase = createUseCase(CaptureType.IMAGE_CAPTURE, dynamicRange = HLG_10_BIT)
val useCaseExpectedSizeMap =
mapOf(
// Size would be valid for 10-bit table within constraints
@@ -2413,27 +2326,21 @@
// existing surfaces (PRIV + PRIV)
val attachedPriv1 =
AttachedSurfaceInfo.create(
- SurfaceConfig.create(
- SurfaceConfig.ConfigType.PRIV,
- SurfaceConfig.ConfigSize.PREVIEW
- ),
+ SurfaceConfig.create(ConfigType.PRIV, ConfigSize.PREVIEW),
ImageFormat.PRIVATE,
previewSize,
DynamicRange.HDR10_10_BIT,
- listOf(UseCaseConfigFactory.CaptureType.PREVIEW),
+ listOf(CaptureType.PREVIEW),
useCase.currentConfig,
/*targetFrameRate=*/ null
)
val attachedPriv2 =
AttachedSurfaceInfo.create(
- SurfaceConfig.create(
- SurfaceConfig.ConfigType.PRIV,
- SurfaceConfig.ConfigSize.RECORD
- ),
+ SurfaceConfig.create(ConfigType.PRIV, ConfigSize.RECORD),
ImageFormat.YUV_420_888,
recordSize,
DynamicRange.HDR10_PLUS_10_BIT,
- listOf(UseCaseConfigFactory.CaptureType.VIDEO_CAPTURE),
+ listOf(CaptureType.VIDEO_CAPTURE),
useCase.currentConfig,
/*targetFrameRate=*/ null
)
@@ -2459,8 +2366,7 @@
useCaseExpectedSizeMap,
attachedSurfaceInfoList = listOf(attachedPriv1, attachedPriv2),
dynamicRangeProfiles = constraintsTable,
- capabilities =
- intArrayOf(CameraMetadata.REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT)
+ capabilities = intArrayOf(REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT)
)
}
}
@@ -2469,11 +2375,7 @@
@Test
fun canAttachHlgDynamicRange_toExistingSdrStreams() {
// JPEG use case can be attached with an existing PRIV + PRIV in the 10-bit tables
- val useCase =
- createUseCase(
- UseCaseConfigFactory.CaptureType.IMAGE_CAPTURE,
- dynamicRange = DynamicRange.HLG_10_BIT
- )
+ val useCase = createUseCase(CaptureType.IMAGE_CAPTURE, dynamicRange = HLG_10_BIT)
val useCaseExpectedSizeMap =
mapOf(
// Size is valid for 10-bit table within constraints
@@ -2482,27 +2384,21 @@
// existing surfaces (PRIV + PRIV)
val attachedPriv1 =
AttachedSurfaceInfo.create(
- SurfaceConfig.create(
- SurfaceConfig.ConfigType.PRIV,
- SurfaceConfig.ConfigSize.PREVIEW
- ),
+ SurfaceConfig.create(ConfigType.PRIV, ConfigSize.PREVIEW),
ImageFormat.PRIVATE,
previewSize,
DynamicRange.SDR,
- listOf(UseCaseConfigFactory.CaptureType.PREVIEW),
+ listOf(CaptureType.PREVIEW),
useCase.currentConfig,
/*targetFrameRate=*/ null
)
val attachedPriv2 =
AttachedSurfaceInfo.create(
- SurfaceConfig.create(
- SurfaceConfig.ConfigType.PRIV,
- SurfaceConfig.ConfigSize.RECORD
- ),
+ SurfaceConfig.create(ConfigType.PRIV, ConfigSize.RECORD),
ImageFormat.YUV_420_888,
recordSize,
DynamicRange.SDR,
- listOf(UseCaseConfigFactory.CaptureType.IMAGE_ANALYSIS),
+ listOf(CaptureType.IMAGE_ANALYSIS),
useCase.currentConfig,
/*targetFrameRate=*/ null
)
@@ -2511,8 +2407,7 @@
useCaseExpectedSizeMap,
attachedSurfaceInfoList = listOf(attachedPriv1, attachedPriv2),
dynamicRangeProfiles = HLG10_SDR_CONSTRAINED,
- capabilities =
- intArrayOf(CameraMetadata.REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT)
+ capabilities = intArrayOf(REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT)
)
}
@@ -2520,14 +2415,9 @@
@Test
fun requiredSdrDynamicRangeThrows_whenCombinedWithConstrainedHlg() {
// VideoCapture HLG dynamic range
- val videoUseCase =
- createUseCase(
- UseCaseConfigFactory.CaptureType.VIDEO_CAPTURE,
- dynamicRange = DynamicRange.HLG_10_BIT
- )
+ val videoUseCase = createUseCase(CaptureType.VIDEO_CAPTURE, dynamicRange = HLG_10_BIT)
// Preview SDR dynamic range
- val previewUseCase =
- createUseCase(UseCaseConfigFactory.CaptureType.PREVIEW, dynamicRange = DynamicRange.SDR)
+ val previewUseCase = createUseCase(CaptureType.PREVIEW, dynamicRange = DynamicRange.SDR)
val useCaseExpectedSizeMap =
mutableMapOf(videoUseCase to recordSize, previewUseCase to previewSize)
@@ -2537,8 +2427,7 @@
getSuggestedSpecsAndVerify(
useCaseExpectedSizeMap,
dynamicRangeProfiles = HLG10_CONSTRAINED,
- capabilities =
- intArrayOf(CameraMetadata.REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT),
+ capabilities = intArrayOf(REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT),
)
}
}
@@ -2547,14 +2436,9 @@
@Test
fun requiredSdrDynamicRange_canBeCombinedWithUnconstrainedHlg() {
// VideoCapture HLG dynamic range
- val videoUseCase =
- createUseCase(
- UseCaseConfigFactory.CaptureType.VIDEO_CAPTURE,
- dynamicRange = DynamicRange.HLG_10_BIT
- )
+ val videoUseCase = createUseCase(CaptureType.VIDEO_CAPTURE, dynamicRange = HLG_10_BIT)
// Preview SDR dynamic range
- val previewUseCase =
- createUseCase(UseCaseConfigFactory.CaptureType.PREVIEW, dynamicRange = DynamicRange.SDR)
+ val previewUseCase = createUseCase(CaptureType.PREVIEW, dynamicRange = DynamicRange.SDR)
val useCaseExpectedSizeMap =
mutableMapOf(videoUseCase to recordSize, previewUseCase to previewSize)
@@ -2563,8 +2447,7 @@
getSuggestedSpecsAndVerify(
useCaseExpectedSizeMap,
dynamicRangeProfiles = HLG10_UNCONSTRAINED,
- capabilities =
- intArrayOf(CameraMetadata.REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT),
+ capabilities = intArrayOf(REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT),
)
}
@@ -2573,16 +2456,10 @@
fun multiple10BitUnconstrainedDynamicRanges_canBeCombined() {
// VideoCapture HDR10 dynamic range
val videoUseCase =
- createUseCase(
- UseCaseConfigFactory.CaptureType.VIDEO_CAPTURE,
- dynamicRange = DynamicRange.HDR10_10_BIT
- )
+ createUseCase(CaptureType.VIDEO_CAPTURE, dynamicRange = DynamicRange.HDR10_10_BIT)
// Preview HDR10_PLUS dynamic range
val previewUseCase =
- createUseCase(
- UseCaseConfigFactory.CaptureType.PREVIEW,
- dynamicRange = DynamicRange.HDR10_PLUS_10_BIT
- )
+ createUseCase(CaptureType.PREVIEW, dynamicRange = DynamicRange.HDR10_PLUS_10_BIT)
val useCaseExpectedSizeMap =
mutableMapOf(videoUseCase to recordSize, previewUseCase to previewSize)
@@ -2591,8 +2468,7 @@
getSuggestedSpecsAndVerify(
useCaseExpectedSizeMap,
dynamicRangeProfiles = HDR10_HDR10_PLUS_UNCONSTRAINED,
- capabilities =
- intArrayOf(CameraMetadata.REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT),
+ capabilities = intArrayOf(REQUEST_AVAILABLE_CAPABILITIES_DYNAMIC_RANGE_TEN_BIT),
)
}
@@ -2605,48 +2481,32 @@
@Test
fun getSupportedOutputSizes_single_valid_targetFPS() {
// a valid target means the device is capable of that fps
- val useCase =
- createUseCase(
- UseCaseConfigFactory.CaptureType.PREVIEW,
- targetFrameRate = Range<Int>(25, 30)
- )
+ val useCase = createUseCase(CaptureType.PREVIEW, targetFrameRate = Range<Int>(25, 30))
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply { put(useCase, Size(3840, 2160)) }
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED
)
}
@Test
fun getSuggestedStreamSpec_single_invalid_targetFPS() {
// an invalid target means the device would neve be able to reach that fps
- val useCase =
- createUseCase(
- UseCaseConfigFactory.CaptureType.PREVIEW,
- targetFrameRate = Range<Int>(65, 70)
- )
+ val useCase = createUseCase(CaptureType.PREVIEW, targetFrameRate = Range<Int>(65, 70))
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply { put(useCase, Size(800, 450)) }
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED
)
}
@Test
fun getSuggestedStreamSpec_multiple_targetFPS_first_is_larger() {
// a valid target means the device is capable of that fps
- val useCase1 =
- createUseCase(
- UseCaseConfigFactory.CaptureType.PREVIEW,
- targetFrameRate = Range<Int>(30, 35)
- )
- val useCase2 =
- createUseCase(
- UseCaseConfigFactory.CaptureType.PREVIEW,
- targetFrameRate = Range<Int>(15, 25)
- )
+ val useCase1 = createUseCase(CaptureType.PREVIEW, targetFrameRate = Range<Int>(30, 35))
+ val useCase2 = createUseCase(CaptureType.PREVIEW, targetFrameRate = Range<Int>(15, 25))
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply {
// both selected size should be no larger than 1920 x 1445
@@ -2663,16 +2523,8 @@
@Test
fun getSuggestedStreamSpec_multiple_targetFPS_first_is_smaller() {
// a valid target means the device is capable of that fps
- val useCase1 =
- createUseCase(
- UseCaseConfigFactory.CaptureType.PREVIEW,
- targetFrameRate = Range<Int>(30, 35)
- )
- val useCase2 =
- createUseCase(
- UseCaseConfigFactory.CaptureType.PREVIEW,
- targetFrameRate = Range<Int>(45, 50)
- )
+ val useCase1 = createUseCase(CaptureType.PREVIEW, targetFrameRate = Range<Int>(30, 35))
+ val useCase2 = createUseCase(CaptureType.PREVIEW, targetFrameRate = Range<Int>(45, 50))
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply {
// both selected size should be no larger than 1920 x 1440
@@ -2681,7 +2533,7 @@
}
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
compareWithAtMost = true
)
}
@@ -2689,16 +2541,8 @@
@Test
fun getSuggestedStreamSpec_multiple_targetFPS_intersect() {
// first and second new use cases have target fps that intersect each other
- val useCase1 =
- createUseCase(
- UseCaseConfigFactory.CaptureType.PREVIEW,
- targetFrameRate = Range<Int>(30, 40)
- )
- val useCase2 =
- createUseCase(
- UseCaseConfigFactory.CaptureType.PREVIEW,
- targetFrameRate = Range<Int>(35, 45)
- )
+ val useCase1 = createUseCase(CaptureType.PREVIEW, targetFrameRate = Range<Int>(30, 40))
+ val useCase2 = createUseCase(CaptureType.PREVIEW, targetFrameRate = Range<Int>(35, 45))
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply {
// effective target fps becomes 35-40
@@ -2708,7 +2552,7 @@
}
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
compareWithAtMost = true
)
}
@@ -2716,12 +2560,8 @@
@Test
fun getSuggestedStreamSpec_multiple_cases_first_has_targetFPS() {
// first new use case has a target fps, second new use case does not
- val useCase1 =
- createUseCase(
- UseCaseConfigFactory.CaptureType.PREVIEW,
- targetFrameRate = Range<Int>(30, 35)
- )
- val useCase2 = createUseCase(UseCaseConfigFactory.CaptureType.PREVIEW)
+ val useCase1 = createUseCase(CaptureType.PREVIEW, targetFrameRate = Range<Int>(30, 35))
+ val useCase2 = createUseCase(CaptureType.PREVIEW)
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply {
// both selected size should be no larger than 1920 x 1440
@@ -2730,7 +2570,7 @@
}
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
compareWithAtMost = true
)
}
@@ -2738,12 +2578,8 @@
@Test
fun getSuggestedStreamSpec_multiple_cases_second_has_targetFPS() {
// second new use case does not have a target fps, first new use case does not
- val useCase1 = createUseCase(UseCaseConfigFactory.CaptureType.PREVIEW)
- val useCase2 =
- createUseCase(
- UseCaseConfigFactory.CaptureType.PREVIEW,
- targetFrameRate = Range<Int>(30, 35)
- )
+ val useCase1 = createUseCase(CaptureType.PREVIEW)
+ val useCase2 = createUseCase(CaptureType.PREVIEW, targetFrameRate = Range<Int>(30, 35))
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply {
// both selected size should be no larger than 1920 x 1440
@@ -2752,7 +2588,7 @@
}
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
compareWithAtMost = true
)
}
@@ -2760,7 +2596,7 @@
@Test
fun getSuggestedStreamSpec_attached_with_targetFPS_no_new_targetFPS() {
// existing surface with target fps + new use case without a target fps
- val useCase = createUseCase(UseCaseConfigFactory.CaptureType.PREVIEW)
+ val useCase = createUseCase(CaptureType.PREVIEW)
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply {
// size should be no larger than 1280 x 960
@@ -2769,21 +2605,18 @@
// existing surface w/ target fps
val attachedSurfaceInfo =
AttachedSurfaceInfo.create(
- SurfaceConfig.create(
- SurfaceConfig.ConfigType.JPEG,
- SurfaceConfig.ConfigSize.PREVIEW
- ),
+ SurfaceConfig.create(ConfigType.JPEG, ConfigSize.PREVIEW),
ImageFormat.JPEG,
Size(1280, 720),
DynamicRange.SDR,
- listOf(UseCaseConfigFactory.CaptureType.PREVIEW),
+ listOf(CaptureType.PREVIEW),
useCase.currentConfig,
Range(40, 50)
)
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
attachedSurfaceInfoList = listOf(attachedSurfaceInfo),
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
compareWithAtMost = true
)
}
@@ -2791,11 +2624,7 @@
@Test
fun getSuggestedStreamSpec_attached_with_targetFPS_and_new_targetFPS_no_intersect() {
// existing surface with target fps + new use case with target fps that does not intersect
- val useCase =
- createUseCase(
- UseCaseConfigFactory.CaptureType.PREVIEW,
- targetFrameRate = Range<Int>(30, 35)
- )
+ val useCase = createUseCase(CaptureType.PREVIEW, targetFrameRate = Range<Int>(30, 35))
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply {
// size of new surface should be no larger than 1280 x 960
@@ -2804,21 +2633,18 @@
// existing surface w/ target fps
val attachedSurfaceInfo =
AttachedSurfaceInfo.create(
- SurfaceConfig.create(
- SurfaceConfig.ConfigType.JPEG,
- SurfaceConfig.ConfigSize.PREVIEW
- ),
+ SurfaceConfig.create(ConfigType.JPEG, ConfigSize.PREVIEW),
ImageFormat.JPEG,
Size(1280, 720),
DynamicRange.SDR,
- listOf(UseCaseConfigFactory.CaptureType.PREVIEW),
+ listOf(CaptureType.PREVIEW),
useCase.currentConfig,
Range(40, 50)
)
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
attachedSurfaceInfoList = listOf(attachedSurfaceInfo),
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
compareWithAtMost = true
)
}
@@ -2826,11 +2652,7 @@
@Test
fun getSuggestedStreamSpec_attached_with_targetFPS_and_new_targetFPS_with_intersect() {
// existing surface with target fps + new use case with target fps that intersect each other
- val useCase =
- createUseCase(
- UseCaseConfigFactory.CaptureType.PREVIEW,
- targetFrameRate = Range<Int>(45, 50)
- )
+ val useCase = createUseCase(CaptureType.PREVIEW, targetFrameRate = Range<Int>(45, 50))
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply {
// size of new surface should be no larger than 1280 x 720
@@ -2839,21 +2661,18 @@
// existing surface w/ target fps
val attachedSurfaceInfo =
AttachedSurfaceInfo.create(
- SurfaceConfig.create(
- SurfaceConfig.ConfigType.JPEG,
- SurfaceConfig.ConfigSize.PREVIEW
- ),
+ SurfaceConfig.create(ConfigType.JPEG, ConfigSize.PREVIEW),
ImageFormat.JPEG,
Size(1280, 720),
DynamicRange.SDR,
- listOf(UseCaseConfigFactory.CaptureType.PREVIEW),
+ listOf(CaptureType.PREVIEW),
useCase.currentConfig,
Range(40, 50)
)
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
attachedSurfaceInfoList = listOf(attachedSurfaceInfo),
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
compareWithAtMost = true
)
}
@@ -2861,11 +2680,7 @@
@Test
fun getSuggestedStreamSpec_has_device_supported_expectedFrameRateRange() {
// use case with target fps
- val useCase1 =
- createUseCase(
- UseCaseConfigFactory.CaptureType.PREVIEW,
- targetFrameRate = Range<Int>(15, 25)
- )
+ val useCase1 = createUseCase(CaptureType.PREVIEW, targetFrameRate = Range<Int>(15, 25))
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply { put(useCase1, Size(4032, 3024)) }
getSuggestedSpecsAndVerify(
@@ -2880,11 +2695,7 @@
@Test
fun getSuggestedStreamSpec_has_exact_device_supported_expectedFrameRateRange() {
// use case with target fps
- val useCase1 =
- createUseCase(
- UseCaseConfigFactory.CaptureType.PREVIEW,
- targetFrameRate = Range<Int>(30, 30)
- )
+ val useCase1 = createUseCase(CaptureType.PREVIEW, targetFrameRate = Range<Int>(30, 30))
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply { put(useCase1, Size(1920, 1440)) }
getSuggestedSpecsAndVerify(
@@ -2899,11 +2710,7 @@
@Test
fun getSuggestedStreamSpec_has_no_device_supported_expectedFrameRateRange() {
// use case with target fps
- val useCase1 =
- createUseCase(
- UseCaseConfigFactory.CaptureType.PREVIEW,
- targetFrameRate = Range<Int>(65, 65)
- )
+ val useCase1 = createUseCase(CaptureType.PREVIEW, targetFrameRate = Range<Int>(65, 65))
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply { put(useCase1, Size(800, 450)) }
@@ -2920,11 +2727,7 @@
fun getSuggestedStreamSpec_has_multiple_device_supported_expectedFrameRateRange() {
// use case with target fps
- val useCase1 =
- createUseCase(
- UseCaseConfigFactory.CaptureType.PREVIEW,
- targetFrameRate = Range<Int>(36, 45)
- )
+ val useCase1 = createUseCase(CaptureType.PREVIEW, targetFrameRate = Range<Int>(36, 45))
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply { put(useCase1, Size(1280, 960)) }
@@ -2945,11 +2748,7 @@
// target fps is between ranges, but within device capability (for some reason lol)
// use case with target fps
- val useCase1 =
- createUseCase(
- UseCaseConfigFactory.CaptureType.PREVIEW,
- targetFrameRate = Range<Int>(26, 27)
- )
+ val useCase1 = createUseCase(CaptureType.PREVIEW, targetFrameRate = Range<Int>(26, 27))
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply { put(useCase1, Size(1920, 1440)) }
@@ -2966,11 +2765,7 @@
fun getSuggestedStreamSpec_has_no_device_intersection_equidistant_expectedFrameRateRange() {
// use case with target fps
- val useCase1 =
- createUseCase(
- UseCaseConfigFactory.CaptureType.PREVIEW,
- targetFrameRate = Range<Int>(26, 26)
- )
+ val useCase1 = createUseCase(CaptureType.PREVIEW, targetFrameRate = Range<Int>(26, 26))
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply { put(useCase1, Size(1920, 1440)) }
@@ -2990,7 +2785,7 @@
// a valid target means the device is capable of that fps
// use case with no target fps
- val useCase1 = createUseCase(UseCaseConfigFactory.CaptureType.PREVIEW)
+ val useCase1 = createUseCase(CaptureType.PREVIEW)
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply { put(useCase1, Size(4032, 3024)) }
@@ -3010,7 +2805,7 @@
// use case with no target fps
val useCase1 =
createUseCase(
- UseCaseConfigFactory.CaptureType.PREVIEW,
+ CaptureType.PREVIEW,
targetFrameRate = StreamSpec.FRAME_RATE_RANGE_UNSPECIFIED
)
@@ -3191,7 +2986,7 @@
fun applyResolutionCorrectorWorkaroundCorrectly() {
ReflectionHelpers.setStaticField(Build::class.java, "BRAND", "Samsung")
ReflectionHelpers.setStaticField(Build::class.java, "MODEL", "SM-J710MN")
- setupCamera(hardwareLevel = CameraMetadata.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED)
+ setupCamera(hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED)
val supportedSurfaceCombination =
SupportedSurfaceCombination(context, fakeCameraMetadata, mockEncoderProfilesAdapter)
val resultList =
@@ -3225,10 +3020,7 @@
@Test
fun canPopulateStreamUseCaseStreamSpecOption_jpeg() {
val jpegUseCase =
- createUseCase(
- UseCaseConfigFactory.CaptureType.IMAGE_CAPTURE,
- streamUseCaseOverride = true
- ) // JPEG
+ createUseCase(CaptureType.IMAGE_CAPTURE, streamUseCaseOverride = true) // JPEG
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply { put(jpegUseCase, landscapePixelArraySize) }
val resultPair = getSuggestedSpecsAndVerify(useCaseExpectedResultMap)
@@ -3245,15 +3037,9 @@
@Test
fun throwException_PopulateStreamUseCaseStreamSpecOption_notFullyOverride() {
val jpegUseCase =
- createUseCase(
- UseCaseConfigFactory.CaptureType.IMAGE_CAPTURE,
- streamUseCaseOverride = true
- ) // JPEG
+ createUseCase(CaptureType.IMAGE_CAPTURE, streamUseCaseOverride = true) // JPEG
val yuvUseCase =
- createUseCase(
- UseCaseConfigFactory.CaptureType.PREVIEW,
- streamUseCaseOverride = false
- ) // PREVIEW
+ createUseCase(CaptureType.PREVIEW, streamUseCaseOverride = false) // PREVIEW
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply {
put(jpegUseCase, landscapePixelArraySize)
@@ -3267,16 +3053,8 @@
@Config(minSdk = Build.VERSION_CODES.TIRAMISU)
@Test
fun skipPopulateStreamUseCaseStreamSpecOption_unsupportedCombination() {
- val useCase1 =
- createUseCase(
- UseCaseConfigFactory.CaptureType.PREVIEW,
- streamUseCaseOverride = true
- ) // PREVIEW
- val useCase2 =
- createUseCase(
- UseCaseConfigFactory.CaptureType.PREVIEW,
- streamUseCaseOverride = true
- ) // PREVIEW
+ val useCase1 = createUseCase(CaptureType.PREVIEW, streamUseCaseOverride = true) // PREVIEW
+ val useCase2 = createUseCase(CaptureType.PREVIEW, streamUseCaseOverride = true) // PREVIEW
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply {
put(useCase1, previewSize)
@@ -3307,10 +3085,7 @@
@Test
fun skipPopulateStreamUseCaseStreamSpecOption_unsupportedOs() {
val jpegUseCase =
- createUseCase(
- UseCaseConfigFactory.CaptureType.IMAGE_CAPTURE,
- streamUseCaseOverride = true
- ) // JPEG
+ createUseCase(CaptureType.IMAGE_CAPTURE, streamUseCaseOverride = true) // JPEG
val useCaseExpectedResultMap =
mutableMapOf<UseCase, Size>().apply { put(jpegUseCase, landscapePixelArraySize) }
val resultPair =
@@ -3763,16 +3538,16 @@
val cameraX: CameraX =
try {
CameraXUtil.getOrCreateInstance(context) { cameraXConfig }.get()
- } catch (e: ExecutionException) {
+ } catch (_: ExecutionException) {
throw IllegalStateException("Unable to initialize CameraX for test.")
- } catch (e: InterruptedException) {
+ } catch (_: InterruptedException) {
throw IllegalStateException("Unable to initialize CameraX for test.")
}
useCaseConfigFactory = cameraX.defaultConfigFactory
}
private fun createUseCase(
- captureType: UseCaseConfigFactory.CaptureType,
+ captureType: CaptureType,
targetFrameRate: Range<Int>? = null,
dynamicRange: DynamicRange = DynamicRange.UNSPECIFIED,
surfaceOccupancyPriority: Int? = null
@@ -3787,7 +3562,7 @@
}
private fun createUseCase(
- captureType: UseCaseConfigFactory.CaptureType,
+ captureType: CaptureType,
targetFrameRate: Range<Int>? = null,
dynamicRange: DynamicRange? = DynamicRange.UNSPECIFIED,
streamUseCaseOverride: Boolean = false,
@@ -3799,8 +3574,8 @@
captureType,
imageFormat
?: when (captureType) {
- UseCaseConfigFactory.CaptureType.IMAGE_CAPTURE -> ImageFormat.JPEG
- UseCaseConfigFactory.CaptureType.IMAGE_ANALYSIS -> ImageFormat.YUV_420_888
+ CaptureType.IMAGE_CAPTURE -> ImageFormat.JPEG
+ CaptureType.IMAGE_ANALYSIS -> ImageFormat.YUV_420_888
else -> ImageFormatConstants.INTERNAL_DEFINED_IMAGE_FORMAT_PRIVATE
}
)
diff --git a/camera/camera-camera2/build.gradle b/camera/camera-camera2/build.gradle
index cf174ef..45bc114 100644
--- a/camera/camera-camera2/build.gradle
+++ b/camera/camera-camera2/build.gradle
@@ -81,6 +81,8 @@
androidTestImplementation("androidx.test.espresso:espresso-core:3.3.0")
}
android {
+ compileSdk 35
+
buildTypes.configureEach {
consumerProguardFiles("proguard-rules.pro")
}
diff --git a/camera/camera-camera2/src/androidTest/java/androidx/camera/camera2/internal/Camera2CameraControlImplDeviceTest.java b/camera/camera-camera2/src/androidTest/java/androidx/camera/camera2/internal/Camera2CameraControlImplDeviceTest.java
index d43e3f6..96d36ea 100644
--- a/camera/camera-camera2/src/androidTest/java/androidx/camera/camera2/internal/Camera2CameraControlImplDeviceTest.java
+++ b/camera/camera-camera2/src/androidTest/java/androidx/camera/camera2/internal/Camera2CameraControlImplDeviceTest.java
@@ -21,6 +21,7 @@
import static android.hardware.camera2.CameraMetadata.CONTROL_AE_MODE_ON_ALWAYS_FLASH;
import static android.hardware.camera2.CameraMetadata.CONTROL_AE_MODE_ON_AUTO_FLASH;
import static android.hardware.camera2.CameraMetadata.CONTROL_AE_MODE_ON_EXTERNAL_FLASH;
+import static android.hardware.camera2.CameraMetadata.CONTROL_AE_MODE_ON_LOW_LIGHT_BOOST_BRIGHTNESS_PRIORITY;
import static android.hardware.camera2.CameraMetadata.CONTROL_AF_MODE_AUTO;
import static android.hardware.camera2.CameraMetadata.CONTROL_AF_MODE_CONTINUOUS_PICTURE;
import static android.hardware.camera2.CameraMetadata.CONTROL_AF_MODE_OFF;
@@ -397,20 +398,8 @@
public void enableTorch_aeModeSetAndRequestUpdated() throws InterruptedException {
assumeTrue(mHasFlashUnit);
mCamera2CameraControlImpl.enableTorch(true);
-
HandlerUtil.waitForLooperToIdle(mHandler);
-
- verify(mControlUpdateCallback, times(1)).onCameraControlUpdateSessionConfig();
- SessionConfig sessionConfig = mCamera2CameraControlImpl.getSessionConfig();
- Camera2ImplConfig camera2Config = new Camera2ImplConfig(
- sessionConfig.getImplementationOptions());
-
- assertAeMode(camera2Config, CONTROL_AE_MODE_ON);
-
- assertThat(
- camera2Config.getCaptureRequestOption(
- CaptureRequest.FLASH_MODE, FLASH_MODE_OFF))
- .isEqualTo(FLASH_MODE_TORCH);
+ verifyControlAeModeAndFlashMode(CONTROL_AE_MODE_ON, FLASH_MODE_TORCH);
}
@Test
@@ -442,6 +431,47 @@
}
+ @SdkSuppress(minSdkVersion = 35)
+ @Test
+ public void enableLowLightBoost_aeModeSetAndRequestUpdated() throws InterruptedException {
+ assumeTrue(mCamera2CameraControlImpl.getLowLightBoostControl().isLowLightBoostSupported());
+ mCamera2CameraControlImpl.enableLowLightBoostAsync(true);
+ HandlerUtil.waitForLooperToIdle(mHandler);
+ verifyControlAeModeAndFlashMode(CONTROL_AE_MODE_ON_LOW_LIGHT_BOOST_BRIGHTNESS_PRIORITY,
+ FLASH_MODE_OFF);
+ }
+
+ @SdkSuppress(minSdkVersion = 35)
+ @Test
+ public void enableLowLightBoostCanOverrideTorch_aeModeSetAndRequestUpdated()
+ throws InterruptedException {
+ assumeTrue(mCamera2CameraControlImpl.getLowLightBoostControl().isLowLightBoostSupported());
+ assumeTrue(mHasFlashUnit);
+
+ mCamera2CameraControlImpl.enableTorch(true);
+ HandlerUtil.waitForLooperToIdle(mHandler);
+ verifyControlAeModeAndFlashMode(CONTROL_AE_MODE_ON, FLASH_MODE_TORCH);
+
+ mCamera2CameraControlImpl.enableTorch(true);
+ HandlerUtil.waitForLooperToIdle(mHandler);
+ verifyControlAeModeAndFlashMode(CONTROL_AE_MODE_ON_LOW_LIGHT_BOOST_BRIGHTNESS_PRIORITY,
+ FLASH_MODE_OFF);
+ }
+
+ private void verifyControlAeModeAndFlashMode(int expectedAeMode, int expectedFlashMode) {
+ verify(mControlUpdateCallback, times(1)).onCameraControlUpdateSessionConfig();
+ SessionConfig sessionConfig = mCamera2CameraControlImpl.getSessionConfig();
+ Camera2ImplConfig camera2Config = new Camera2ImplConfig(
+ sessionConfig.getImplementationOptions());
+
+ assertAeMode(camera2Config, expectedAeMode);
+
+ assertThat(
+ camera2Config.getCaptureRequestOption(
+ CaptureRequest.FLASH_MODE, FLASH_MODE_OFF))
+ .isEqualTo(expectedFlashMode);
+ }
+
@Test
@LargeTest
public void triggerAf_futureSucceeds() throws Exception {
diff --git a/camera/camera-camera2/src/androidTest/java/androidx/camera/camera2/internal/LowLightBoostControlDeviceTest.kt b/camera/camera-camera2/src/androidTest/java/androidx/camera/camera2/internal/LowLightBoostControlDeviceTest.kt
new file mode 100644
index 0000000..b0a8f1d
--- /dev/null
+++ b/camera/camera-camera2/src/androidTest/java/androidx/camera/camera2/internal/LowLightBoostControlDeviceTest.kt
@@ -0,0 +1,100 @@
+/*
+ * Copyright 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.camera.camera2.internal
+
+import android.content.Context
+import androidx.camera.camera2.Camera2Config
+import androidx.camera.camera2.internal.util.TestUtil
+import androidx.camera.core.CameraSelector
+import androidx.camera.core.Preview
+import androidx.camera.core.internal.CameraUseCaseAdapter
+import androidx.camera.testing.impl.CameraUtil
+import androidx.camera.testing.impl.CameraUtil.PreTestCameraIdList
+import androidx.camera.testing.impl.CameraXUtil
+import androidx.test.core.app.ApplicationProvider
+import androidx.test.ext.junit.runners.AndroidJUnit4
+import androidx.test.filters.LargeTest
+import androidx.test.filters.SdkSuppress
+import androidx.test.platform.app.InstrumentationRegistry
+import java.util.concurrent.TimeUnit
+import org.junit.After
+import org.junit.Assume.assumeTrue
+import org.junit.Before
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+
+private val DEFAULT_CAMERA_SELECTOR = CameraSelector.DEFAULT_BACK_CAMERA
+
+@LargeTest
+@RunWith(AndroidJUnit4::class)
+@SdkSuppress(minSdkVersion = 35)
+class LowLightBoostControlDeviceTest {
+
+ @get:Rule
+ val cameraRule =
+ CameraUtil.grantCameraPermissionAndPreTestAndPostTest(
+ PreTestCameraIdList(Camera2Config.defaultConfig())
+ )
+
+ val context = ApplicationProvider.getApplicationContext() as Context
+
+ private lateinit var camera: CameraUseCaseAdapter
+
+ @Before
+ fun setUp() {
+ assumeTrue(CameraUtil.hasCameraWithLensFacing(DEFAULT_CAMERA_SELECTOR.lensFacing!!))
+ // Init CameraX
+ val config = Camera2Config.defaultConfig()
+ CameraXUtil.initialize(context, config)
+
+ // Prepare LowLightBoostControl
+ // To get a functional Camera2CameraControlImpl, it needs to bind an active UseCase and the
+ // UseCase must have repeating surface. Create and bind Preview as repeating surface.
+ camera =
+ CameraUtil.createCameraAndAttachUseCase(
+ context,
+ DEFAULT_CAMERA_SELECTOR,
+ Preview.Builder().build()
+ )
+ }
+
+ @After
+ fun tearDown() {
+ if (::camera.isInitialized) {
+ InstrumentationRegistry.getInstrumentation().runOnMainSync {
+ // TODO: The removeUseCases() call might be removed after clarifying the
+ // abortCaptures() issue in b/162314023.
+ camera.removeUseCases(camera.getUseCases())
+ }
+ }
+
+ CameraXUtil.shutdown().get(10000, TimeUnit.MILLISECONDS)
+ }
+
+ @Test
+ fun enableDisableLowLightBoost_futureWillCompleteSuccessfully_whenLlbIsSupported() {
+ assumeTrue(camera.cameraInfo.isLowLightBoostSupported)
+ TestUtil.getCamera2CameraControlImpl(camera.cameraControl).lowLightBoostControl.apply {
+ // Future should return with no exception
+ enableLowLightBoost(true).get(3, TimeUnit.SECONDS)
+
+ // Future should return with no exception
+ enableLowLightBoost(false).get(3, TimeUnit.SECONDS)
+ }
+ }
+}
diff --git a/camera/camera-camera2/src/main/java/androidx/camera/camera2/internal/Camera2CameraControlImpl.java b/camera/camera-camera2/src/main/java/androidx/camera/camera2/internal/Camera2CameraControlImpl.java
index 2b9b8a2..ef38ab5 100644
--- a/camera/camera-camera2/src/main/java/androidx/camera/camera2/internal/Camera2CameraControlImpl.java
+++ b/camera/camera-camera2/src/main/java/androidx/camera/camera2/internal/Camera2CameraControlImpl.java
@@ -16,6 +16,8 @@
package androidx.camera.camera2.internal;
+import static android.hardware.camera2.CameraMetadata.CONTROL_AE_MODE_ON_LOW_LIGHT_BOOST_BRIGHTNESS_PRIORITY;
+
import static androidx.camera.core.ImageCapture.FLASH_MODE_AUTO;
import static androidx.camera.core.ImageCapture.FLASH_MODE_OFF;
import static androidx.camera.core.ImageCapture.FLASH_MODE_ON;
@@ -124,6 +126,7 @@
private final FocusMeteringControl mFocusMeteringControl;
private final ZoomControl mZoomControl;
private final TorchControl mTorchControl;
+ private final LowLightBoostControl mLowLightBoostControl;
private final ExposureControl mExposureControl;
@VisibleForTesting
ZslControl mZslControl;
@@ -137,6 +140,7 @@
// use volatile modifier to make these variables in sync in all threads.
private volatile boolean mIsTorchOn = false;
+ private volatile boolean mIsLowLightBoostOn = false;
@ImageCapture.FlashMode
private volatile int mFlashMode = FLASH_MODE_OFF;
@@ -201,6 +205,7 @@
this, scheduler, mExecutor, cameraQuirks);
mZoomControl = new ZoomControl(this, mCameraCharacteristics, mExecutor);
mTorchControl = new TorchControl(this, mCameraCharacteristics, mExecutor);
+ mLowLightBoostControl = new LowLightBoostControl(this, mCameraCharacteristics, mExecutor);
if (Build.VERSION.SDK_INT >= 23) {
mZslControl = new ZslControlImpl(mCameraCharacteristics, mExecutor);
} else {
@@ -262,6 +267,10 @@
return mTorchControl;
}
+ public @NonNull LowLightBoostControl getLowLightBoostControl() {
+ return mLowLightBoostControl;
+ }
+
public @NonNull ExposureControl getExposureControl() {
return mExposureControl;
}
@@ -307,6 +316,7 @@
Logger.d(TAG, "setActive: isActive = " + isActive);
mFocusMeteringControl.setActive(isActive);
mZoomControl.setActive(isActive);
+ mLowLightBoostControl.setActive(isActive);
mTorchControl.setActive(isActive);
mExposureControl.setActive(isActive);
mCamera2CameraControl.setActive(isActive);
@@ -424,6 +434,17 @@
return Futures.nonCancellationPropagating(mTorchControl.enableTorch(torch));
}
+ /** {@inheritDoc} */
+ @Override
+ public @NonNull ListenableFuture<Void> enableLowLightBoostAsync(final boolean lowLightBoost) {
+ if (!isControlInUse()) {
+ return Futures.immediateFailedFuture(
+ new OperationCanceledException("Camera is not active."));
+ }
+ return Futures.nonCancellationPropagating(
+ mLowLightBoostControl.enableLowLightBoost(lowLightBoost));
+ }
+
@ExecutedBy("mExecutor")
private @NonNull ListenableFuture<Void> waitForSessionUpdateId(long sessionUpdateIdToWait) {
return CallbackToFutureAdapter.getFuture(completer -> {
@@ -623,30 +644,66 @@
@SuppressWarnings("WeakerAccess") /* synthetic accessor */
@ExecutedBy("mExecutor")
void enableTorchInternal(boolean torch) {
+ // When low-light boost is on, any torch related operations will be ignored.
+ if (mIsLowLightBoostOn) {
+ return;
+ }
+
mIsTorchOn = torch;
if (!torch) {
- // Send capture request with AE_MODE_ON + FLASH_MODE_OFF to turn off torch.
- CaptureConfig.Builder singleRequestBuilder = new CaptureConfig.Builder();
- singleRequestBuilder.setTemplateType(mTemplate);
- singleRequestBuilder.setUseRepeatingSurface(true);
- Camera2ImplConfig.Builder configBuilder = new Camera2ImplConfig.Builder();
- configBuilder.setCaptureRequestOption(CaptureRequest.CONTROL_AE_MODE,
- getSupportedAeMode(CaptureRequest.CONTROL_AE_MODE_ON));
- configBuilder.setCaptureRequestOption(CaptureRequest.FLASH_MODE,
- CaptureRequest.FLASH_MODE_OFF);
- singleRequestBuilder.addImplementationOptions(configBuilder.build());
- submitCaptureRequestsInternal(
- Collections.singletonList(singleRequestBuilder.build()));
+ // On some devices, needs to reset the AE/flash state to ensure that the torch can be
+ // turned off.
+ resetAeFlashState();
}
updateSessionConfigSynchronous();
}
+ @SuppressWarnings("WeakerAccess") /* synthetic accessor */
+ @ExecutedBy("mExecutor")
+ void enableLowLightBoostInternal(boolean lowLightBoost) {
+ if (mIsLowLightBoostOn == lowLightBoost) {
+ return;
+ }
+
+ // Forces turn off torch before enabling low-light boost.
+ if (lowLightBoost && mIsTorchOn) {
+ // On some devices, needs to reset the AE/flash state to ensure that the torch can be
+ // turned off.
+ resetAeFlashState();
+ mIsTorchOn = false;
+ mTorchControl.forceUpdateTorchStateToOff();
+ }
+
+ mIsLowLightBoostOn = lowLightBoost;
+ updateSessionConfigSynchronous();
+ }
+
+ private void resetAeFlashState() {
+ // Send capture request with AE_MODE_ON + FLASH_MODE_OFF to reset the AE/flash state.
+ CaptureConfig.Builder singleRequestBuilder = new CaptureConfig.Builder();
+ singleRequestBuilder.setTemplateType(mTemplate);
+ singleRequestBuilder.setUseRepeatingSurface(true);
+ Camera2ImplConfig.Builder configBuilder = new Camera2ImplConfig.Builder();
+ configBuilder.setCaptureRequestOption(CaptureRequest.CONTROL_AE_MODE,
+ getSupportedAeMode(CaptureRequest.CONTROL_AE_MODE_ON));
+ configBuilder.setCaptureRequestOption(CaptureRequest.FLASH_MODE,
+ CaptureRequest.FLASH_MODE_OFF);
+ singleRequestBuilder.addImplementationOptions(configBuilder.build());
+ submitCaptureRequestsInternal(
+ Collections.singletonList(singleRequestBuilder.build()));
+ }
+
@ExecutedBy("mExecutor")
boolean isTorchOn() {
return mIsTorchOn;
}
@ExecutedBy("mExecutor")
+ boolean isLowLightBoostOn() {
+ return mIsLowLightBoostOn;
+ }
+
+ @ExecutedBy("mExecutor")
void submitCaptureRequestsInternal(final List<CaptureConfig> captureConfigs) {
mControlUpdateCallback.onCameraControlCaptureRequests(captureConfigs);
}
@@ -676,7 +733,9 @@
aeMode = CaptureRequest.CONTROL_AE_MODE_ON_EXTERNAL_FLASH;
}
- if (mIsTorchOn) {
+ if (mIsLowLightBoostOn) {
+ aeMode = CONTROL_AE_MODE_ON_LOW_LIGHT_BOOST_BRIGHTNESS_PRIORITY;
+ } else if (mIsTorchOn) {
builder.setCaptureRequestOptionWithPriority(CaptureRequest.FLASH_MODE,
CaptureRequest.FLASH_MODE_TORCH, Config.OptionPriority.REQUIRED);
} else {
diff --git a/camera/camera-camera2/src/main/java/androidx/camera/camera2/internal/Camera2CameraInfoImpl.java b/camera/camera-camera2/src/main/java/androidx/camera/camera2/internal/Camera2CameraInfoImpl.java
index 65ed945..81a5d90 100644
--- a/camera/camera-camera2/src/main/java/androidx/camera/camera2/internal/Camera2CameraInfoImpl.java
+++ b/camera/camera-camera2/src/main/java/androidx/camera/camera2/internal/Camera2CameraInfoImpl.java
@@ -110,6 +110,8 @@
@GuardedBy("mLock")
private @Nullable RedirectableLiveData<Integer> mRedirectTorchStateLiveData = null;
@GuardedBy("mLock")
+ private @Nullable RedirectableLiveData<Integer> mRedirectLowLightBoostStateLiveData = null;
+ @GuardedBy("mLock")
private @Nullable RedirectableLiveData<ZoomState> mRedirectZoomStateLiveData = null;
private final @NonNull RedirectableLiveData<CameraState> mCameraStateLiveData;
@GuardedBy("mLock")
@@ -159,6 +161,11 @@
mCamera2CameraControlImpl.getTorchControl().getTorchState());
}
+ if (mRedirectLowLightBoostStateLiveData != null) {
+ mRedirectLowLightBoostStateLiveData.redirectTo(mCamera2CameraControlImpl
+ .getLowLightBoostControl().getLowLightBoostState());
+ }
+
if (mCameraCaptureCallbacks != null) {
for (Pair<CameraCaptureCallback, Executor> pair :
mCameraCaptureCallbacks) {
@@ -291,6 +298,31 @@
}
@Override
+ public boolean isLowLightBoostSupported() {
+ return LowLightBoostControl.checkLowLightBoostAvailability(mCameraCharacteristicsCompat);
+ }
+
+ @Override
+ public @NonNull LiveData<Integer> getLowLightBoostState() {
+ synchronized (mLock) {
+ if (mCamera2CameraControlImpl == null) {
+ if (mRedirectLowLightBoostStateLiveData == null) {
+ mRedirectLowLightBoostStateLiveData =
+ new RedirectableLiveData<>(LowLightBoostControl.DEFAULT_LLB_STATE);
+ }
+ return mRedirectLowLightBoostStateLiveData;
+ }
+
+ // if RedirectableLiveData exists, use it directly.
+ if (mRedirectLowLightBoostStateLiveData != null) {
+ return mRedirectLowLightBoostStateLiveData;
+ }
+
+ return mCamera2CameraControlImpl.getLowLightBoostControl().getLowLightBoostState();
+ }
+ }
+
+ @Override
public @NonNull LiveData<ZoomState> getZoomState() {
synchronized (mLock) {
if (mCamera2CameraControlImpl == null) {
diff --git a/camera/camera-camera2/src/main/java/androidx/camera/camera2/internal/Camera2CapturePipeline.java b/camera/camera-camera2/src/main/java/androidx/camera/camera2/internal/Camera2CapturePipeline.java
index d000354..42a38eb 100644
--- a/camera/camera-camera2/src/main/java/androidx/camera/camera2/internal/Camera2CapturePipeline.java
+++ b/camera/camera-camera2/src/main/java/androidx/camera/camera2/internal/Camera2CapturePipeline.java
@@ -326,7 +326,8 @@
null) : Futures.immediateFuture(null);
preCapture = FutureChain.from(getResult).transformAsync(captureResult -> {
- if (isFlashRequired(flashMode, captureResult)) {
+ if (!mCameraControl.isLowLightBoostOn() && isFlashRequired(flashMode,
+ captureResult)) {
setTimeout3A(CHECK_3A_WITH_FLASH_TIMEOUT_IN_NS);
}
return mPipelineSubTask.preCapture(captureResult);
@@ -625,7 +626,9 @@
Logger.d(TAG, "TorchTask#preCapture: isFlashRequired = " + isFlashRequired);
if (isFlashRequired(mFlashMode, captureResult)) {
- if (mCameraControl.isTorchOn()) {
+ if (mCameraControl.isLowLightBoostOn()) {
+ Logger.d(TAG, "Low-light boost already on, not turn on");
+ } else if (mCameraControl.isTorchOn()) {
Logger.d(TAG, "Torch already on, not turn on");
} else {
Logger.d(TAG, "Turn on torch");
@@ -694,7 +697,7 @@
@Override
public @NonNull ListenableFuture<Boolean> preCapture(
@Nullable TotalCaptureResult captureResult) {
- if (isFlashRequired(mFlashMode, captureResult)) {
+ if (!mCameraControl.isLowLightBoostOn() && isFlashRequired(mFlashMode, captureResult)) {
Logger.d(TAG, "Trigger AE");
mIsExecuted = true;
diff --git a/camera/camera-camera2/src/main/java/androidx/camera/camera2/internal/LowLightBoostControl.java b/camera/camera-camera2/src/main/java/androidx/camera/camera2/internal/LowLightBoostControl.java
new file mode 100644
index 0000000..78bcb35
--- /dev/null
+++ b/camera/camera-camera2/src/main/java/androidx/camera/camera2/internal/LowLightBoostControl.java
@@ -0,0 +1,266 @@
+/*
+ * Copyright 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.camera.camera2.internal;
+
+import static android.hardware.camera2.CameraMetadata.CONTROL_AE_MODE_ON_LOW_LIGHT_BOOST_BRIGHTNESS_PRIORITY;
+import static android.hardware.camera2.CaptureResult.CONTROL_LOW_LIGHT_BOOST_STATE;
+
+import android.hardware.camera2.CameraCharacteristics;
+import android.hardware.camera2.CaptureRequest;
+import android.os.Build;
+
+import androidx.annotation.VisibleForTesting;
+import androidx.camera.camera2.internal.annotation.CameraExecutor;
+import androidx.camera.camera2.internal.compat.CameraCharacteristicsCompat;
+import androidx.camera.core.CameraControl;
+import androidx.camera.core.Logger;
+import androidx.camera.core.LowLightBoostState;
+import androidx.camera.core.impl.annotation.ExecutedBy;
+import androidx.camera.core.impl.utils.Threads;
+import androidx.camera.core.impl.utils.futures.Futures;
+import androidx.concurrent.futures.CallbackToFutureAdapter;
+import androidx.concurrent.futures.CallbackToFutureAdapter.Completer;
+import androidx.lifecycle.LiveData;
+import androidx.lifecycle.MutableLiveData;
+
+import com.google.common.util.concurrent.ListenableFuture;
+
+import org.jspecify.annotations.NonNull;
+import org.jspecify.annotations.Nullable;
+
+import java.util.concurrent.Executor;
+
+/**
+ * Implementation of low-light boost control used within CameraControl and CameraInfo.
+ *
+ * It is used to control the low-light boost mode of camera device that
+ * {@link Camera2CameraControlImpl} operates. The low-light boost control must be activated via
+ * {@link #setActive(boolean)} when the camera device is ready to do low-light boost operations
+ * and be deactivated when the camera device is closing or closed.
+ */
+final class LowLightBoostControl {
+ private static final String TAG = "LowLightBoostControl";
+ static final int DEFAULT_LLB_STATE = LowLightBoostState.OFF;
+
+ @SuppressWarnings("WeakerAccess") /* synthetic accessor */
+ private final Camera2CameraControlImpl mCamera2CameraControlImpl;
+ private final MutableLiveData<Integer> mLowLightBoostState;
+ private final boolean mIsLowLightBoostSupported;
+ @CameraExecutor
+ private final Executor mExecutor;
+
+ private boolean mIsActive;
+ @SuppressWarnings("WeakerAccess") /* synthetic accessor */
+ CallbackToFutureAdapter.Completer<Void> mEnableLlbCompleter;
+ @SuppressWarnings("WeakerAccess") /* synthetic accessor */
+ boolean mTargetLlbEnabled;
+
+ @VisibleForTesting
+ final Camera2CameraControlImpl.CaptureResultListener mCaptureResultListener;
+
+ /**
+ * Constructs a LowLightBoostControl.
+ *
+ * @param camera2CameraControlImpl the camera control this LowLightBoostControl belongs.
+ * @param cameraCharacteristics the characteristics for the camera being controlled.
+ * @param executor the camera executor used to run camera task.
+ */
+ LowLightBoostControl(@NonNull Camera2CameraControlImpl camera2CameraControlImpl,
+ @NonNull CameraCharacteristicsCompat cameraCharacteristics,
+ @CameraExecutor @NonNull Executor executor) {
+ mCamera2CameraControlImpl = camera2CameraControlImpl;
+ mExecutor = executor;
+
+ mIsLowLightBoostSupported = checkLowLightBoostAvailability(cameraCharacteristics);
+ mLowLightBoostState = new MutableLiveData<>(DEFAULT_LLB_STATE);
+
+ mCaptureResultListener = captureResult -> {
+ if (mEnableLlbCompleter != null) {
+ CaptureRequest captureRequest = captureResult.getRequest();
+ Integer aeMode = captureRequest.get(CaptureRequest.CONTROL_AE_MODE);
+
+ // Skips the check if capture result doesn't contain AE mode related info.
+ if (aeMode == null) {
+ return false;
+ }
+
+ // mTargetLlbEnabled might be either true or false.
+ // - When mTargetLlbEnabled is true: complete the completer when
+ // AE mode becomes CONTROL_AE_MODE_ON_LOW_LIGHT_BOOST_BRIGHTNESS_PRIORITY.
+ // - When mTargetLlbEnabled is false: complete the completer when
+ // AE mode becomes non-CONTROL_AE_MODE_ON_LOW_LIGHT_BOOST_BRIGHTNESS_PRIORITY.
+ boolean llbEnabled =
+ aeMode == CONTROL_AE_MODE_ON_LOW_LIGHT_BOOST_BRIGHTNESS_PRIORITY;
+ if (llbEnabled == mTargetLlbEnabled) {
+ mEnableLlbCompleter.set(null);
+ mEnableLlbCompleter = null;
+ } else {
+ return false;
+ }
+ }
+
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.VANILLA_ICE_CREAM
+ && mTargetLlbEnabled) {
+ Integer currentState = captureResult.get(CONTROL_LOW_LIGHT_BOOST_STATE);
+ if (currentState != null) {
+ setLiveDataValue(mLowLightBoostState, currentState);
+ }
+ }
+
+ // Return false to keep getting captureResult.
+ return false;
+ };
+
+ if (mIsLowLightBoostSupported) {
+ mCamera2CameraControlImpl.addCaptureResultListener(mCaptureResultListener);
+ }
+ }
+
+ /**
+ * Set current active state. Set active if it is ready to do low-light boost operations.
+ *
+ * @param isActive true to activate or false otherwise.
+ */
+ @ExecutedBy("mExecutor")
+ void setActive(boolean isActive) {
+ if (mIsActive == isActive) {
+ return;
+ }
+
+ mIsActive = isActive;
+
+ if (!isActive) {
+ if (mTargetLlbEnabled) {
+ mTargetLlbEnabled = false;
+ mCamera2CameraControlImpl.enableLowLightBoostInternal(false);
+ setLiveDataValue(mLowLightBoostState, LowLightBoostState.OFF);
+ }
+
+ if (mEnableLlbCompleter != null) {
+ mEnableLlbCompleter.setException(
+ new CameraControl.OperationCanceledException("Camera is not active."));
+ mEnableLlbCompleter = null;
+ }
+ }
+ }
+
+ /**
+ * Enable or disable the low-light boost.
+ *
+ * <p>The returned {@link ListenableFuture} will succeed when the request is sent to camera
+ * device. But it may get an {@link CameraControl.OperationCanceledException} result when:
+ * <ol>
+ * <li>There are multiple {@code enableLowLightBoost(boolean)} requests in the same time, the
+ * older and incomplete futures will get cancelled.
+ * <li>When the LowLightBoostControl is set to inactive.
+ * </ol>
+ *
+ * <p>The returned {@link ListenableFuture} will fail immediately when:
+ * <ol>
+ * <li>The LowLightBoostControl is not in active state.
+ * <li>The camera doesn't support low-light boost mode.
+ * </ol>
+ *
+ * @param enabled true to open the low-light boost, false to close it.
+ * @return A {@link ListenableFuture} which is successful when the low-light boost was changed
+ * to the value specified. It fails when it is unable to change the low-light boost state.
+ */
+ ListenableFuture<Void> enableLowLightBoost(boolean enabled) {
+ if (!mIsLowLightBoostSupported) {
+ Logger.d(TAG, "Unable to enable low-light boost due to it is not supported.");
+ return Futures.immediateFailedFuture(
+ new IllegalStateException("Low-light boost is not supported"));
+ }
+
+ setLiveDataValue(mLowLightBoostState,
+ enabled ? LowLightBoostState.INACTIVE : LowLightBoostState.OFF);
+
+ return CallbackToFutureAdapter.getFuture(completer -> {
+ mExecutor.execute(() -> enableLowLightBoostInternal(completer, enabled));
+ return "enableLowLightBoost: " + enabled;
+ });
+ }
+
+ /**
+ * Returns a {@link LiveData} of current {@link LowLightBoostState}.
+ *
+ * <p>The low-light boost state can be enabled or disabled via
+ * {@link #enableLowLightBoost(boolean)} which will trigger the change event to the returned
+ * {@link LiveData}.
+ *
+ * @return a {@link LiveData} containing current low-light boost state.
+ */
+ @NonNull
+ LiveData<Integer> getLowLightBoostState() {
+ return mLowLightBoostState;
+ }
+
+ @SuppressWarnings("WeakerAccess") /* synthetic accessor */
+ @ExecutedBy("mExecutor")
+ void enableLowLightBoostInternal(@Nullable Completer<Void> completer, boolean enabled) {
+ if (!mIsActive) {
+ setLiveDataValue(mLowLightBoostState, LowLightBoostState.OFF);
+ if (completer != null) {
+ completer.setException(
+ new CameraControl.OperationCanceledException("Camera is not active."));
+ }
+ return;
+ }
+
+ mTargetLlbEnabled = enabled;
+ mCamera2CameraControlImpl.enableLowLightBoostInternal(enabled);
+ setLiveDataValue(mLowLightBoostState,
+ enabled ? LowLightBoostState.INACTIVE : LowLightBoostState.OFF);
+ if (mEnableLlbCompleter != null) {
+ mEnableLlbCompleter.setException(new CameraControl.OperationCanceledException(
+ "There is a new enableLowLightBoost being set"));
+ }
+ mEnableLlbCompleter = completer;
+ }
+
+ boolean isLowLightBoostSupported() {
+ return mIsLowLightBoostSupported;
+ }
+
+ static boolean checkLowLightBoostAvailability(
+ @NonNull CameraCharacteristicsCompat cameraCharacteristics) {
+ if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+ return false;
+ }
+
+ int[] availableAeModes = cameraCharacteristics.get(
+ CameraCharacteristics.CONTROL_AE_AVAILABLE_MODES);
+ if (availableAeModes != null) {
+ for (int availableAeMode : availableAeModes) {
+ if (availableAeMode
+ == CONTROL_AE_MODE_ON_LOW_LIGHT_BOOST_BRIGHTNESS_PRIORITY) {
+ return true;
+ }
+ }
+ }
+
+ return false;
+ }
+
+ private <T> void setLiveDataValue(@NonNull MutableLiveData<T> liveData, T value) {
+ if (Threads.isMainThread()) {
+ liveData.setValue(value);
+ } else {
+ liveData.postValue(value);
+ }
+ }
+}
diff --git a/camera/camera-camera2/src/main/java/androidx/camera/camera2/internal/TorchControl.java b/camera/camera-camera2/src/main/java/androidx/camera/camera2/internal/TorchControl.java
index c18d7b0..d4c634e 100644
--- a/camera/camera-camera2/src/main/java/androidx/camera/camera2/internal/TorchControl.java
+++ b/camera/camera-camera2/src/main/java/androidx/camera/camera2/internal/TorchControl.java
@@ -61,9 +61,9 @@
private boolean mIsActive;
@SuppressWarnings("WeakerAccess") /* synthetic accessor */
- CallbackToFutureAdapter.Completer<Void> mEnableTorchCompleter;
+ CallbackToFutureAdapter.Completer<Void> mEnableTorchCompleter;
@SuppressWarnings("WeakerAccess") /* synthetic accessor */
- boolean mTargetTorchEnabled;
+ boolean mTargetTorchEnabled;
/**
* Constructs a TorchControl.
@@ -193,6 +193,14 @@
return;
}
+ if (mCamera2CameraControlImpl.isLowLightBoostOn()) {
+ if (completer != null) {
+ completer.setException(new IllegalStateException(
+ "Torch can not be enabled when low-light boost is on!"));
+ }
+ return;
+ }
+
mTargetTorchEnabled = enabled;
mCamera2CameraControlImpl.enableTorchInternal(enabled);
setLiveDataValue(mTorchState, enabled ? TorchState.ON : TorchState.OFF);
@@ -203,6 +211,23 @@
mEnableTorchCompleter = completer;
}
+ /**
+ * Force update the torch state to OFF.
+ *
+ * <p>This can be invoked when low-light boost is turned on. The torch state will also be
+ * updated as {@link TorchState#OFF}.
+ */
+ @ExecutedBy("mExecutor")
+ void forceUpdateTorchStateToOff() {
+ // Directly return if torch is originally off
+ if (!mTargetTorchEnabled) {
+ return;
+ }
+
+ mTargetTorchEnabled = false;
+ setLiveDataValue(mTorchState, TorchState.OFF);
+ }
+
private <T> void setLiveDataValue(@NonNull MutableLiveData<T> liveData, T value) {
if (Threads.isMainThread()) {
liveData.setValue(value);
diff --git a/camera/camera-camera2/src/test/java/androidx/camera/camera2/internal/Camera2CameraInfoImplTest.java b/camera/camera-camera2/src/test/java/androidx/camera/camera2/internal/Camera2CameraInfoImplTest.java
index 3228d2b..529c505 100644
--- a/camera/camera-camera2/src/test/java/androidx/camera/camera2/internal/Camera2CameraInfoImplTest.java
+++ b/camera/camera-camera2/src/test/java/androidx/camera/camera2/internal/Camera2CameraInfoImplTest.java
@@ -17,6 +17,7 @@
package androidx.camera.camera2.internal;
import static android.hardware.camera2.CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES;
+import static android.hardware.camera2.CameraMetadata.CONTROL_AE_MODE_ON_LOW_LIGHT_BOOST_BRIGHTNESS_PRIORITY;
import static android.hardware.camera2.CameraMetadata.CONTROL_VIDEO_STABILIZATION_MODE_OFF;
import static android.hardware.camera2.CameraMetadata.CONTROL_VIDEO_STABILIZATION_MODE_ON;
import static android.hardware.camera2.CameraMetadata.CONTROL_VIDEO_STABILIZATION_MODE_PREVIEW_STABILIZATION;
@@ -62,6 +63,7 @@
import androidx.camera.core.DynamicRange;
import androidx.camera.core.ExposureState;
import androidx.camera.core.FocusMeteringAction;
+import androidx.camera.core.LowLightBoostState;
import androidx.camera.core.SurfaceOrientedMeteringPointFactory;
import androidx.camera.core.TorchState;
import androidx.camera.core.ZoomState;
@@ -163,6 +165,7 @@
private CameraManagerCompat mCameraManagerCompat;
private ZoomControl mMockZoomControl;
private TorchControl mMockTorchControl;
+ private LowLightBoostControl mMockLowLightBoostControl;
private ExposureControl mExposureControl;
private FocusMeteringControl mFocusMeteringControl;
private Camera2CameraControlImpl mMockCameraControl;
@@ -254,6 +257,27 @@
assertThat(cameraInfoInternal.hasFlashUnit()).isEqualTo(CAMERA1_FLASH_INFO_BOOLEAN);
}
+ @Config(minSdk = 35)
+ @Test
+ public void cameraInfo_canReturnLowLightBoostSupported_forBackCamera()
+ throws CameraAccessExceptionCompat {
+ init(/* hasAvailableCapabilities = */ false);
+
+ CameraInfoInternal cameraInfoInternal =
+ new Camera2CameraInfoImpl(CAMERA0_ID, mCameraManagerCompat);
+ assertThat(cameraInfoInternal.isLowLightBoostSupported()).isTrue();
+ }
+
+ @Test
+ public void cameraInfo_canReturnLowLightBoostSupported_forFrontCamera()
+ throws CameraAccessExceptionCompat {
+ init(/* hasAvailableCapabilities = */ false);
+
+ CameraInfoInternal cameraInfoInternal =
+ new Camera2CameraInfoImpl(CAMERA1_ID, mCameraManagerCompat);
+ assertThat(cameraInfoInternal.isLowLightBoostSupported()).isFalse();
+ }
+
@Test
public void cameraInfoWithoutCameraControl_canReturnDefaultTorchState()
throws CameraAccessExceptionCompat {
@@ -296,6 +320,46 @@
assertThat(camera2CameraInfoImpl.getTorchState().getValue()).isEqualTo(TorchState.ON);
}
+ @Config(minSdk = 35)
+ @Test
+ public void cameraInfoWithCameraControl_canReturnLowLightBoostState()
+ throws CameraAccessExceptionCompat {
+ init(/* hasAvailableCapabilities = */ false);
+
+ when(mMockLowLightBoostControl.getLowLightBoostState()).thenReturn(
+ new MutableLiveData<>(LowLightBoostState.ACTIVE));
+ Camera2CameraInfoImpl camera2CameraInfoImpl =
+ new Camera2CameraInfoImpl(CAMERA0_ID, mCameraManagerCompat);
+ camera2CameraInfoImpl.linkWithCameraControl(mMockCameraControl);
+ assertThat(camera2CameraInfoImpl.getLowLightBoostState().getValue()).isEqualTo(
+ LowLightBoostState.ACTIVE);
+ }
+
+ @Config(minSdk = 35)
+ @Test
+ public void lowLightBoostStateLiveData_SameInstanceBeforeAndAfterCameraControlLink()
+ throws CameraAccessExceptionCompat {
+ init(/* hasAvailableCapabilities = */ false);
+
+ Camera2CameraInfoImpl camera2CameraInfoImpl =
+ new Camera2CameraInfoImpl(CAMERA0_ID, mCameraManagerCompat);
+
+ // Calls getLowLightBoostState() to trigger RedirectableLiveData
+ LiveData<Integer> lowLightBoostStateLiveData =
+ camera2CameraInfoImpl.getLowLightBoostState();
+
+ when(mMockLowLightBoostControl.getLowLightBoostState()).thenReturn(
+ new MutableLiveData<>(LowLightBoostState.ACTIVE));
+ camera2CameraInfoImpl.linkWithCameraControl(mMockCameraControl);
+
+ // LowLightBoostState LiveData instances are the same before and after the
+ // linkWithCameraControl.
+ assertThat(camera2CameraInfoImpl.getLowLightBoostState()).isSameInstanceAs(
+ lowLightBoostStateLiveData);
+ assertThat(camera2CameraInfoImpl.getLowLightBoostState().getValue()).isEqualTo(
+ LowLightBoostState.ACTIVE);
+ }
+
// zoom related tests just ensure it uses ZoomControl to get the value
// Full tests are performed at ZoomControlDeviceTest / ZoomControlTest.
@Test
@@ -937,12 +1001,14 @@
mMockZoomControl = mock(ZoomControl.class);
mMockTorchControl = mock(TorchControl.class);
+ mMockLowLightBoostControl = mock(LowLightBoostControl.class);
mExposureControl = mock(ExposureControl.class);
mMockCameraControl = mock(Camera2CameraControlImpl.class);
mFocusMeteringControl = mock(FocusMeteringControl.class);
when(mMockCameraControl.getZoomControl()).thenReturn(mMockZoomControl);
when(mMockCameraControl.getTorchControl()).thenReturn(mMockTorchControl);
+ when(mMockCameraControl.getLowLightBoostControl()).thenReturn(mMockLowLightBoostControl);
when(mMockCameraControl.getExposureControl()).thenReturn(mExposureControl);
when(mMockCameraControl.getFocusMeteringControl()).thenReturn(mFocusMeteringControl);
}
@@ -1022,6 +1088,16 @@
});
}
+ // Adds low-light boost support for the back camera since API 35
+ if (Build.VERSION.SDK_INT >= 35) {
+ shadowCharacteristics0.set(
+ CameraCharacteristics.CONTROL_AE_AVAILABLE_MODES,
+ new int[]{
+ CONTROL_AE_MODE_ON_LOW_LIGHT_BOOST_BRIGHTNESS_PRIORITY
+ }
+ );
+ }
+
// Mock the request capability
if (hasAvailableCapabilities) {
shadowCharacteristics0.set(REQUEST_AVAILABLE_CAPABILITIES,
diff --git a/camera/camera-camera2/src/test/java/androidx/camera/camera2/internal/Camera2CapturePipelineTest.kt b/camera/camera-camera2/src/test/java/androidx/camera/camera2/internal/Camera2CapturePipelineTest.kt
index a9e2c9d..0a8d0c7 100644
--- a/camera/camera-camera2/src/test/java/androidx/camera/camera2/internal/Camera2CapturePipelineTest.kt
+++ b/camera/camera-camera2/src/test/java/androidx/camera/camera2/internal/Camera2CapturePipelineTest.kt
@@ -23,13 +23,13 @@
import android.hardware.camera2.CameraDevice
import android.hardware.camera2.CameraManager
import android.hardware.camera2.CameraMetadata
+import android.hardware.camera2.CameraMetadata.CONTROL_AE_MODE_ON_LOW_LIGHT_BOOST_BRIGHTNESS_PRIORITY
import android.hardware.camera2.CaptureRequest
import android.hardware.camera2.CaptureResult
import android.hardware.camera2.TotalCaptureResult
import android.media.Image
import android.media.ImageWriter
import android.os.Build
-import android.os.Looper
import android.view.Surface
import androidx.annotation.RequiresApi
import androidx.camera.camera2.impl.Camera2ImplConfig
@@ -79,15 +79,14 @@
import kotlinx.coroutines.withTimeout
import org.junit.After
import org.junit.Assert.assertThrows
-import org.junit.Assert.assertTrue
+import org.junit.Assume.assumeTrue
import org.junit.Before
import org.junit.Ignore
import org.junit.Test
import org.junit.runner.RunWith
import org.mockito.Mockito
import org.mockito.Mockito.mock
-import org.robolectric.RobolectricTestRunner
-import org.robolectric.Shadows
+import org.robolectric.ParameterizedRobolectricTestRunner
import org.robolectric.annotation.Config
import org.robolectric.annotation.internal.DoNotInstrument
import org.robolectric.shadow.api.Shadow
@@ -96,12 +95,12 @@
private const val CAMERA_ID_0 = "0"
-@RunWith(RobolectricTestRunner::class)
+@RunWith(ParameterizedRobolectricTestRunner::class)
@DoNotInstrument
@Config(
minSdk = Build.VERSION_CODES.LOLLIPOP,
)
-class Camera2CapturePipelineTest {
+class Camera2CapturePipelineTest(private val isLowLightBoostEnabled: Boolean) {
private val context = ApplicationProvider.getApplicationContext() as Context
private val executorService = Executors.newSingleThreadScheduledExecutor()
@@ -151,8 +150,17 @@
private lateinit var testScreenFlash: MockScreenFlash
+ companion object {
+ @JvmStatic
+ @ParameterizedRobolectricTestRunner.Parameters(name = "isLowLightBoostEnabled: {0}")
+ fun data() = listOf(true, false)
+ }
+
@Before
fun setUp() {
+ if (isLowLightBoostEnabled) {
+ assumeTrue(Build.VERSION.SDK_INT >= 35)
+ }
initCameras()
testScreenFlash = MockScreenFlash()
}
@@ -212,8 +220,8 @@
)
// Assert.
- assertTrue(fakeTask.preCaptureCountDown.await(3, TimeUnit.SECONDS))
- assertTrue(fakeTask.postCaptureCountDown.await(3, TimeUnit.SECONDS))
+ assertThat(fakeTask.preCaptureCountDown.await(3, TimeUnit.SECONDS)).isTrue()
+ assertThat(fakeTask.postCaptureCountDown.await(3, TimeUnit.SECONDS)).isTrue()
}
@Test
@@ -288,12 +296,19 @@
simulateRepeatingResult(initialDelay = 100)
}
- // Assert 1, verify the CONTROL_AE_PRECAPTURE_TRIGGER is triggered
+ // Assert 1, verify the CONTROL_AE_PRECAPTURE_TRIGGER is triggered when low-light boost is
+ // off, otherwise, is not triggered.
immediateCompleteCapture.verifyRequestResult {
it.requestContains(
CaptureRequest.CONTROL_AE_PRECAPTURE_TRIGGER,
CaptureRequest.CONTROL_AE_PRECAPTURE_TRIGGER_START
- )
+ ) != isLowLightBoostEnabled
+ }
+
+ // When low-light boost is on, AE pre-capture is not triggered. Therefore, converged stage
+ // is not required.
+ if (isLowLightBoostEnabled) {
+ return
}
// Switch the repeating result to 3A converged state.
@@ -302,7 +317,8 @@
resultParameters = resultConverged
)
- // Assert 2 that CONTROL_AE_PRECAPTURE_TRIGGER should be cancelled finally.
+ // Assert 2 that CONTROL_AE_PRECAPTURE_TRIGGER should be cancelled finally when low-light
+ // boost is off, otherwise, TRIGGER_CANCEL is not triggered.
if (Build.VERSION.SDK_INT >= 23) {
immediateCompleteCapture.verifyRequestResult {
it.requestContains(
@@ -345,12 +361,19 @@
)
}
- // Assert 1, verify the CONTROL_AE_PRECAPTURE_TRIGGER is triggered
+ // Assert 1, verify the CONTROL_AE_PRECAPTURE_TRIGGER is triggered when low-light boost is
+ // off, otherwise, is not triggered.
immediateCompleteCapture.verifyRequestResult {
it.requestContains(
CaptureRequest.CONTROL_AE_PRECAPTURE_TRIGGER,
CaptureRequest.CONTROL_AE_PRECAPTURE_TRIGGER_START
- )
+ ) != isLowLightBoostEnabled
+ }
+
+ // When low-light boost is on, AE pre-capture is not triggered. Therefore, converged stage
+ // is not required.
+ if (isLowLightBoostEnabled) {
+ return
}
// Switch the repeating result to 3A converged state.
@@ -359,7 +382,8 @@
resultParameters = resultConverged
)
- // Assert 2 that CONTROL_AE_PRECAPTURE_TRIGGER should be cancelled finally.
+ // Assert 2 that CONTROL_AE_PRECAPTURE_TRIGGER should be cancelled finally when low-light
+ // boost is off, otherwise, TRIGGER_CANCEL is not triggered.
if (Build.VERSION.SDK_INT >= 23) {
immediateCompleteCapture.verifyRequestResult {
it.requestContains(
@@ -430,7 +454,19 @@
}
// Assert 1 torch should be turned on
- cameraControl.waitForSessionConfig { it.isTorchParameterEnabled() }
+ cameraControl.waitForSessionConfig {
+ if (isLowLightBoostEnabled) {
+ it.isLowLightBoostEnabled()
+ } else {
+ it.isTorchParameterEnabled()
+ }
+ }
+
+ // When low-light boost is on, AE pre-capture is not triggered. Therefore, converged stage
+ // is not required.
+ if (isLowLightBoostEnabled) {
+ return
+ }
// Switch the repeating result to 3A converged state.
cameraControl.simulateRepeatingResult(
@@ -468,7 +504,19 @@
}
// Assert 1 torch should be turned on
- cameraControl.waitForSessionConfig { it.isTorchParameterEnabled() }
+ cameraControl.waitForSessionConfig {
+ if (isLowLightBoostEnabled) {
+ it.isLowLightBoostEnabled()
+ } else {
+ it.isTorchParameterEnabled()
+ }
+ }
+
+ // When low-light boost is on, AE pre-capture is not triggered. Therefore, converged stage
+ // is not required.
+ if (isLowLightBoostEnabled) {
+ return
+ }
// Switch the repeating result to 3A converged state.
cameraControl.simulateRepeatingResult(
@@ -503,7 +551,19 @@
}
// Assert 1 torch should be turned on
- cameraControl.waitForSessionConfig { it.isTorchParameterEnabled() }
+ cameraControl.waitForSessionConfig {
+ if (isLowLightBoostEnabled) {
+ it.isLowLightBoostEnabled()
+ } else {
+ it.isTorchParameterEnabled()
+ }
+ }
+
+ // When low-light boost is on, AE pre-capture is not triggered. Therefore, converged stage
+ // is not required.
+ if (isLowLightBoostEnabled) {
+ return
+ }
// Switch the repeating result to 3A converged state.
cameraControl.simulateRepeatingResult(
@@ -794,7 +854,7 @@
// Assert.
val exception =
assertThrows(ExecutionException::class.java) { future.get(1, TimeUnit.SECONDS) }
- assertTrue(exception.cause is ImageCaptureException)
+ assertThat(exception.cause).isInstanceOf(ImageCaptureException::class.java)
assertThat((exception.cause as ImageCaptureException).imageCaptureError)
.isEqualTo(ImageCapture.ERROR_CAPTURE_FAILED)
}
@@ -830,7 +890,7 @@
// Assert.
val exception =
assertThrows(ExecutionException::class.java) { future.get(1, TimeUnit.SECONDS) }
- assertTrue(exception.cause is ImageCaptureException)
+ assertThat(exception.cause).isInstanceOf(ImageCaptureException::class.java)
assertThat((exception.cause as ImageCaptureException).imageCaptureError)
.isEqualTo(ImageCapture.ERROR_CAMERA_CLOSED)
}
@@ -1170,6 +1230,13 @@
CameraMetadata.FLASH_MODE_TORCH
}
+ private fun SessionConfig.isLowLightBoostEnabled(): Boolean {
+ val config = toCamera2Config()
+
+ return config.getCaptureRequestOption(CaptureRequest.CONTROL_AE_MODE, null) ==
+ CONTROL_AE_MODE_ON_LOW_LIGHT_BOOST_BRIGHTNESS_PRIORITY
+ }
+
private fun List<CaptureConfig>.isTorchParameterDisabled() =
requestContains(
CaptureRequest.CONTROL_AE_MODE,
@@ -1283,6 +1350,8 @@
setActive(true)
incrementUseCount()
this.screenFlash = testScreenFlash
+ // Applies low-light boost setting
+ enableLowLightBoostAndAssert(this)
}
}
@@ -1297,14 +1366,19 @@
set(CameraCharacteristics.FLASH_INFO_AVAILABLE, true)
set(
CameraCharacteristics.CONTROL_AE_AVAILABLE_MODES,
- intArrayOf(
- CaptureRequest.CONTROL_AE_MODE_OFF,
- CaptureRequest.CONTROL_AE_MODE_ON,
- CaptureRequest.CONTROL_AE_MODE_ON_AUTO_FLASH,
- CaptureRequest.CONTROL_AE_MODE_ON_ALWAYS_FLASH,
- CaptureRequest.CONTROL_AE_MODE_ON_AUTO_FLASH_REDEYE,
- CaptureRequest.CONTROL_AE_MODE_ON_EXTERNAL_FLASH
- )
+ mutableListOf<Int>()
+ .apply {
+ add(CaptureRequest.CONTROL_AE_MODE_OFF)
+ add(CaptureRequest.CONTROL_AE_MODE_ON)
+ add(CaptureRequest.CONTROL_AE_MODE_ON_AUTO_FLASH)
+ add(CaptureRequest.CONTROL_AE_MODE_ON_ALWAYS_FLASH)
+ add(CaptureRequest.CONTROL_AE_MODE_ON_AUTO_FLASH_REDEYE)
+ add(CaptureRequest.CONTROL_AE_MODE_ON_EXTERNAL_FLASH)
+ if (Build.VERSION.SDK_INT >= 35) {
+ add(CONTROL_AE_MODE_ON_LOW_LIGHT_BOOST_BRIGHTNESS_PRIORITY)
+ }
+ }
+ .toIntArray()
)
set(CameraCharacteristics.LENS_FACING, CameraMetadata.LENS_FACING_BACK)
}
@@ -1334,7 +1408,7 @@
}
waitingList.add(resultPair)
}
- assertTrue(resultPair.first.await(timeout, TimeUnit.MILLISECONDS))
+ assertThat(resultPair.first.await(timeout, TimeUnit.MILLISECONDS)).isTrue()
waitingList.remove(resultPair)
}
@@ -1459,13 +1533,16 @@
cameraControl.mZslControl = zslControl
+ // Applies low-light boost setting
+ enableLowLightBoostAndAssert(cameraControl)
+
return cameraControl
}
- private fun Looper.advanceUntilIdle() {
- val shadowLooper = Shadows.shadowOf(this)
- while (!shadowLooper.isIdle) {
- shadowLooper.idle()
+ private fun enableLowLightBoostAndAssert(cameraControlImpl: Camera2CameraControlImpl) {
+ if (isLowLightBoostEnabled) {
+ executorService.run { cameraControlImpl.enableLowLightBoostInternal(true) }
}
+ assertThat(cameraControlImpl.isLowLightBoostOn).isEqualTo(isLowLightBoostEnabled)
}
}
diff --git a/camera/camera-camera2/src/test/java/androidx/camera/camera2/internal/LowLightBoostControlTest.kt b/camera/camera-camera2/src/test/java/androidx/camera/camera2/internal/LowLightBoostControlTest.kt
new file mode 100644
index 0000000..bed297c
--- /dev/null
+++ b/camera/camera-camera2/src/test/java/androidx/camera/camera2/internal/LowLightBoostControlTest.kt
@@ -0,0 +1,294 @@
+/*
+ * Copyright 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.camera.camera2.internal
+
+import android.content.Context
+import android.hardware.camera2.CameraCharacteristics
+import android.hardware.camera2.CameraManager
+import android.hardware.camera2.CameraMetadata
+import android.hardware.camera2.CameraMetadata.CONTROL_AE_MODE_ON_LOW_LIGHT_BOOST_BRIGHTNESS_PRIORITY
+import android.hardware.camera2.CaptureRequest
+import android.hardware.camera2.CaptureResult.CONTROL_LOW_LIGHT_BOOST_STATE
+import android.hardware.camera2.TotalCaptureResult
+import android.os.Looper.getMainLooper
+import androidx.camera.camera2.internal.compat.CameraCharacteristicsCompat
+import androidx.camera.core.CameraControl.OperationCanceledException
+import androidx.camera.core.LowLightBoostState
+import androidx.camera.core.impl.CameraControlInternal
+import androidx.camera.core.impl.utils.executor.CameraXExecutors
+import androidx.test.core.app.ApplicationProvider
+import com.google.common.truth.Truth.assertThat
+import com.google.common.util.concurrent.ListenableFuture
+import java.util.concurrent.ExecutionException
+import java.util.concurrent.Executors
+import java.util.concurrent.TimeUnit
+import kotlinx.coroutines.delay
+import kotlinx.coroutines.runBlocking
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.mockito.Mockito
+import org.mockito.Mockito.mock
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.Shadows.shadowOf
+import org.robolectric.annotation.Config
+import org.robolectric.annotation.internal.DoNotInstrument
+import org.robolectric.shadow.api.Shadow
+import org.robolectric.shadows.ShadowCameraCharacteristics
+import org.robolectric.shadows.ShadowCameraManager
+import org.robolectric.shadows.ShadowLog
+
+private const val CAMERA_ID_0 = "0"
+
+@RunWith(RobolectricTestRunner::class)
+@DoNotInstrument
+@Config(
+ minSdk = 35,
+)
+class LowLightBoostControlTest {
+
+ private val context = ApplicationProvider.getApplicationContext() as Context
+
+ @Test
+ fun enableLowLightBoostThrowException_stateActive_whenIsSupported() {
+ ShadowLog.stream = System.out
+ initCamera(supportedLlb = true)
+ createLowLightBoostControl().apply {
+ setActive(true)
+ val future = enableLowLightBoost(true)
+
+ // Issue CONTROL_AE_MODE_ON_LOW_LIGHT_BOOST_BRIGHTNESS_PRIORITY AE mode capture result
+ // to check whether the future can be completed or not.
+ issueControlAeModeCaptureResult(mCaptureResultListener)
+ shadowOf(getMainLooper()).idle()
+
+ future.get(1, TimeUnit.SECONDS)
+ }
+ }
+
+ @Test
+ fun enableLowLightBoost_stateInactive_whenIsSupported() {
+ initCamera(supportedLlb = true)
+ createLowLightBoostControl().apply {
+ setActive(false)
+ val future = enableLowLightBoost(true)
+ shadowOf(getMainLooper()).idle()
+ assertFutureCompleteWithException(future, OperationCanceledException::class.java)
+ }
+ }
+
+ @Test
+ fun enableLowLightBoostThrowException_stateActive_whenIsNotSupported() {
+ initCamera(supportedLlb = false)
+ createLowLightBoostControl().apply {
+ setActive(true)
+ val future = enableLowLightBoost(true)
+ assertFutureCompleteWithException(future, IllegalStateException::class.java)
+ }
+ }
+
+ @Test
+ fun getLowLightBoostState_stateActive_whenIsNotSupported() {
+ initCamera(supportedLlb = false)
+ createLowLightBoostControl().apply {
+ setActive(true)
+ enableLowLightBoost(true)
+ shadowOf(getMainLooper()).idle()
+ assertThat(lowLightBoostState.value).isEqualTo(LowLightBoostState.OFF)
+ }
+ }
+
+ @Test
+ fun getLowLightBoostState_stateActive_whenIsSupported() {
+ initCamera(supportedLlb = true)
+ createLowLightBoostControl().apply {
+ setActive(true)
+ // State is OFF before low-light boost is enabled
+ assertThat(lowLightBoostState.value).isEqualTo(LowLightBoostState.OFF)
+
+ enableLowLightBoost(true)
+ shadowOf(getMainLooper()).idle()
+ // State is INACTIVE after low-light boost is enabled but no ACTIVE state is received
+ assertThat(lowLightBoostState.value).isEqualTo(LowLightBoostState.INACTIVE)
+
+ issueControlAeModeCaptureResult(
+ mCaptureResultListener,
+ llbState = LowLightBoostState.ACTIVE
+ )
+ // When low-light boost state is updated, postValue method is invoked. In robolectric
+ // test, it is hard to know when will the task is added to the main thread. Adding
+ // delay 100ms here to make sure that the value update task has been posted to the main
+ // thread.
+ runBlocking { delay(100) }
+ shadowOf(getMainLooper()).idle()
+ // State is ACTIVE after ACTIVE state is received
+ assertThat(lowLightBoostState.value).isEqualTo(LowLightBoostState.ACTIVE)
+
+ issueControlAeModeCaptureResult(
+ mCaptureResultListener,
+ llbState = LowLightBoostState.INACTIVE
+ )
+ runBlocking { delay(100) }
+ shadowOf(getMainLooper()).idle()
+ // State is INACTIVE after INACTIVE state is received again
+ assertThat(lowLightBoostState.value).isEqualTo(LowLightBoostState.INACTIVE)
+ }
+ }
+
+ @Test
+ fun getLowLightBoostState_stateInactive_whenIsSupported() {
+ initCamera(supportedLlb = true)
+ createLowLightBoostControl().apply {
+ setActive(false)
+ assertThat(lowLightBoostState.value).isEqualTo(LowLightBoostState.OFF)
+ }
+ }
+
+ @Test
+ fun enableTorchTwice_cancelPreviousFuture() {
+ initCamera(supportedLlb = true)
+ createLowLightBoostControl().apply {
+ setActive(true)
+ val future1 = enableLowLightBoost(true)
+ val future2 = enableLowLightBoost(true)
+ shadowOf(getMainLooper()).idle()
+
+ // Verifies that the first future has been canceled.
+ assertFutureCompleteWithException(future1, OperationCanceledException::class.java)
+
+ // Verifies that the second future can be completed after issue the AE mode capture
+ // result
+ issueControlAeModeCaptureResult(mCaptureResultListener)
+ shadowOf(getMainLooper()).idle()
+ future2.get(1, TimeUnit.SECONDS)
+ }
+ }
+
+ @Test
+ fun setInActive_cancelPreviousFuture() {
+ initCamera(supportedLlb = true)
+ createLowLightBoostControl().apply {
+ setActive(true)
+ val future = enableLowLightBoost(true)
+ shadowOf(getMainLooper()).idle()
+
+ setActive(false)
+ assertFutureCompleteWithException(future, OperationCanceledException::class.java)
+ }
+ }
+
+ @Test
+ fun setInActive_changeToStateOff() {
+ initCamera(supportedLlb = true)
+ createLowLightBoostControl().apply {
+ setActive(true)
+ enableLowLightBoost(true)
+ assertThat(lowLightBoostState.value).isEqualTo(LowLightBoostState.INACTIVE)
+
+ setActive(false)
+ shadowOf(getMainLooper()).idle()
+ assertThat(lowLightBoostState.value).isEqualTo(LowLightBoostState.OFF)
+ }
+ }
+
+ private fun assertFutureCompleteWithException(future: ListenableFuture<Void>, clazz: Class<*>) {
+ assertThat(future.isDone).isTrue()
+ try {
+ future.get()
+ } catch (exception: ExecutionException) {
+ assertThat(exception.cause).isInstanceOf(clazz)
+ }
+ }
+
+ private fun createLowLightBoostControl(): LowLightBoostControl {
+ val cameraManager = context.getSystemService(Context.CAMERA_SERVICE) as CameraManager
+ val cameraCharacteristics = cameraManager.getCameraCharacteristics(CAMERA_ID_0)
+ val characteristicsCompat =
+ CameraCharacteristicsCompat.toCameraCharacteristicsCompat(
+ cameraCharacteristics,
+ CAMERA_ID_0
+ )
+
+ val cameraControlImpl =
+ Camera2CameraControlImpl(
+ characteristicsCompat,
+ CameraXExecutors.mainThreadExecutor(),
+ CameraXExecutors.mainThreadExecutor(),
+ mock(CameraControlInternal.ControlUpdateCallback::class.java)
+ )
+
+ return LowLightBoostControl(
+ cameraControlImpl,
+ characteristicsCompat,
+ CameraXExecutors.mainThreadExecutor()
+ )
+ }
+
+ private fun issueControlAeModeCaptureResult(
+ captureResultListener: Camera2CameraControlImpl.CaptureResultListener,
+ resultAeMode: Int = CONTROL_AE_MODE_ON_LOW_LIGHT_BOOST_BRIGHTNESS_PRIORITY,
+ llbState: Int? = null
+ ) {
+ Executors.newSingleThreadScheduledExecutor()
+ .schedule(
+ {
+ val captureRequest = mock(CaptureRequest::class.java)
+ Mockito.`when`(captureRequest.get(CaptureRequest.CONTROL_AE_MODE))
+ .thenReturn(resultAeMode)
+
+ val totalCaptureResult = mock(TotalCaptureResult::class.java)
+ Mockito.`when`(totalCaptureResult.request).thenReturn(captureRequest)
+
+ llbState?.let {
+ Mockito.`when`(totalCaptureResult.get(CONTROL_LOW_LIGHT_BOOST_STATE))
+ .thenReturn(llbState)
+ }
+ captureResultListener.onCaptureResult(totalCaptureResult)
+ },
+ 20,
+ TimeUnit.MILLISECONDS
+ )
+ }
+
+ private fun initCamera(supportedLlb: Boolean) {
+ val cameraCharacteristics =
+ ShadowCameraCharacteristics.newCameraCharacteristics().also {
+ Shadow.extract<ShadowCameraCharacteristics>(it).apply {
+ set(
+ CameraCharacteristics.CONTROL_AE_AVAILABLE_MODES,
+ mutableListOf<Int>()
+ .apply {
+ add(CaptureRequest.CONTROL_AE_MODE_OFF)
+ add(CaptureRequest.CONTROL_AE_MODE_ON)
+ add(CaptureRequest.CONTROL_AE_MODE_ON_AUTO_FLASH)
+ add(CaptureRequest.CONTROL_AE_MODE_ON_ALWAYS_FLASH)
+ add(CaptureRequest.CONTROL_AE_MODE_ON_AUTO_FLASH_REDEYE)
+ add(CaptureRequest.CONTROL_AE_MODE_ON_EXTERNAL_FLASH)
+
+ if (supportedLlb) {
+ add(CONTROL_AE_MODE_ON_LOW_LIGHT_BOOST_BRIGHTNESS_PRIORITY)
+ }
+ }
+ .toIntArray()
+ )
+ set(CameraCharacteristics.LENS_FACING, CameraMetadata.LENS_FACING_BACK)
+ }
+ }
+
+ Shadow.extract<ShadowCameraManager>(context.getSystemService(Context.CAMERA_SERVICE))
+ .apply { addCamera(CAMERA_ID_0, cameraCharacteristics) }
+ }
+}
diff --git a/camera/camera-camera2/src/test/java/androidx/camera/camera2/internal/SupportedSurfaceCombinationTest.kt b/camera/camera-camera2/src/test/java/androidx/camera/camera2/internal/SupportedSurfaceCombinationTest.kt
index cf9f36b..7f11ecb 100644
--- a/camera/camera-camera2/src/test/java/androidx/camera/camera2/internal/SupportedSurfaceCombinationTest.kt
+++ b/camera/camera-camera2/src/test/java/androidx/camera/camera2/internal/SupportedSurfaceCombinationTest.kt
@@ -123,7 +123,6 @@
private val RECORD_SIZE = Size(3840, 2160)
private val MAXIMUM_SIZE = Size(4032, 3024)
private val LEGACY_VIDEO_MAXIMUM_SIZE = Size(1920, 1080)
-private val VIDEO_MAXIMUM_SIZE = Size(3840, 2160)
private val DEFAULT_SUPPORTED_SIZES =
arrayOf(
Size(4032, 3024), // 4:3
@@ -310,9 +309,7 @@
@Test
fun checkLimitedSurfaceCombinationSupportedInLimitedDevice() {
- setupCameraAndInitCameraX(
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED
- )
+ setupCameraAndInitCameraX(hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED)
val supportedSurfaceCombination =
SupportedSurfaceCombination(
context,
@@ -333,9 +330,7 @@
@Test
fun checkFullSurfaceCombinationNotSupportedInLimitedDevice() {
- setupCameraAndInitCameraX(
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED
- )
+ setupCameraAndInitCameraX(hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED)
val supportedSurfaceCombination =
SupportedSurfaceCombination(
context,
@@ -356,9 +351,7 @@
@Test
fun checkLevel3SurfaceCombinationNotSupportedInLimitedDevice() {
- setupCameraAndInitCameraX(
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED
- )
+ setupCameraAndInitCameraX(hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED)
val supportedSurfaceCombination =
SupportedSurfaceCombination(
context,
@@ -1154,7 +1147,7 @@
}
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED
)
}
@@ -1170,7 +1163,7 @@
}
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED
)
}
@@ -1186,7 +1179,7 @@
}
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED
)
}
@@ -1204,7 +1197,7 @@
}
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED
)
}
@@ -1222,7 +1215,7 @@
}
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED
)
}
@@ -1240,7 +1233,7 @@
}
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED
)
}
@@ -1259,7 +1252,7 @@
assertThrows(IllegalArgumentException::class.java) {
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED
)
}
}
@@ -1389,7 +1382,7 @@
assertThrows(IllegalArgumentException::class.java) {
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED
)
}
}
@@ -1482,7 +1475,7 @@
}
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
capabilities =
intArrayOf(CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_BURST_CAPTURE)
)
@@ -1500,7 +1493,7 @@
}
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
capabilities =
intArrayOf(CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_BURST_CAPTURE)
)
@@ -1518,7 +1511,7 @@
}
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
capabilities =
intArrayOf(CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_BURST_CAPTURE)
)
@@ -1538,7 +1531,7 @@
mutableMapOf<UseCase, Size>().apply { put(rawUseCase, MAXIMUM_SIZE) }
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
capabilities = intArrayOf(CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_RAW)
)
}
@@ -1555,7 +1548,7 @@
}
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
capabilities = intArrayOf(CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_RAW)
)
}
@@ -1574,7 +1567,7 @@
}
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
capabilities = intArrayOf(CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_RAW)
)
}
@@ -1593,7 +1586,7 @@
}
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
capabilities = intArrayOf(CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_RAW)
)
}
@@ -1612,7 +1605,7 @@
}
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
capabilities = intArrayOf(CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_RAW)
)
}
@@ -1631,7 +1624,7 @@
}
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
capabilities = intArrayOf(CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_RAW)
)
}
@@ -1650,7 +1643,7 @@
}
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
capabilities = intArrayOf(CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES_RAW)
)
}
@@ -2047,7 +2040,7 @@
assertThrows(IllegalArgumentException::class.java) {
getSuggestedSpecsAndVerify(
useCaseExpectedSizeMap,
- cameraMode = CameraMode.ULTRA_HIGH_RESOLUTION_CAMERA,
+ cameraMode = ULTRA_HIGH_RESOLUTION_CAMERA,
dynamicRangeProfiles = HLG10_CONSTRAINED
)
}
@@ -2604,7 +2597,7 @@
mutableMapOf<UseCase, Size>().apply { put(useCase, Size(3840, 2160)) }
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED
)
}
@@ -2616,7 +2609,7 @@
mutableMapOf<UseCase, Size>().apply { put(useCase, Size(800, 450)) }
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED
)
}
@@ -2651,7 +2644,7 @@
}
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
compareWithAtMost = true
)
}
@@ -2670,7 +2663,7 @@
}
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
compareWithAtMost = true
)
}
@@ -2688,7 +2681,7 @@
}
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
compareWithAtMost = true
)
}
@@ -2706,7 +2699,7 @@
}
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
compareWithAtMost = true
)
}
@@ -2734,7 +2727,7 @@
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
attachedSurfaceInfoList = listOf(attachedSurfaceInfo),
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
compareWithAtMost = true
)
}
@@ -2762,7 +2755,7 @@
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
attachedSurfaceInfoList = listOf(attachedSurfaceInfo),
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
compareWithAtMost = true
)
}
@@ -2790,7 +2783,7 @@
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
attachedSurfaceInfoList = listOf(attachedSurfaceInfo),
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED,
compareWithAtMost = true
)
}
@@ -3082,7 +3075,7 @@
}
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
- hardwareLevel = CameraCharacteristics.INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED
+ hardwareLevel = INFO_SUPPORTED_HARDWARE_LEVEL_LIMITED
)
}
@@ -3242,7 +3235,7 @@
val resultPair =
getSuggestedSpecsAndVerify(
useCaseExpectedResultMap,
- cameraMode = CameraMode.ULTRA_HIGH_RESOLUTION_CAMERA,
+ cameraMode = ULTRA_HIGH_RESOLUTION_CAMERA,
)
assertThat(resultPair.first.size).isEqualTo(2)
assertThat(
@@ -3641,7 +3634,7 @@
Mockito.mock(StreamConfigurationMap::class.java).also { map ->
supportedSizes?.let {
// Sets up the supported sizes
- Mockito.`when`(map.getOutputSizes(ArgumentMatchers.anyInt())).thenReturn(it)
+ Mockito.`when`(map.getOutputSizes(anyInt())).thenReturn(it)
// ImageFormat.PRIVATE was supported since API level 23. Before that, the
// supported
// output sizes need to be retrieved via SurfaceTexture.class.
@@ -3657,7 +3650,7 @@
// minimum frame durations were designated only for the purpose of testing
Mockito.`when`(
map.getOutputMinFrameDuration(
- ArgumentMatchers.anyInt(),
+ anyInt(),
ArgumentMatchers.eq(Size(4032, 3024))
)
)
@@ -3665,7 +3658,7 @@
Mockito.`when`(
map.getOutputMinFrameDuration(
- ArgumentMatchers.anyInt(),
+ anyInt(),
ArgumentMatchers.eq(Size(3840, 2160))
)
)
@@ -3673,7 +3666,7 @@
Mockito.`when`(
map.getOutputMinFrameDuration(
- ArgumentMatchers.anyInt(),
+ anyInt(),
ArgumentMatchers.eq(Size(1920, 1440))
)
)
@@ -3681,7 +3674,7 @@
Mockito.`when`(
map.getOutputMinFrameDuration(
- ArgumentMatchers.anyInt(),
+ anyInt(),
ArgumentMatchers.eq(Size(1920, 1080))
)
)
@@ -3689,7 +3682,7 @@
Mockito.`when`(
map.getOutputMinFrameDuration(
- ArgumentMatchers.anyInt(),
+ anyInt(),
ArgumentMatchers.eq(Size(1280, 960))
)
)
@@ -3697,39 +3690,30 @@
Mockito.`when`(
map.getOutputMinFrameDuration(
- ArgumentMatchers.anyInt(),
+ anyInt(),
ArgumentMatchers.eq(Size(1280, 720))
)
)
.thenReturn(22222222L) // 45, size preview/display
Mockito.`when`(
- map.getOutputMinFrameDuration(
- ArgumentMatchers.anyInt(),
- ArgumentMatchers.eq(Size(960, 544))
- )
+ map.getOutputMinFrameDuration(anyInt(), ArgumentMatchers.eq(Size(960, 544)))
)
.thenReturn(20000000L) // 50
Mockito.`when`(
- map.getOutputMinFrameDuration(
- ArgumentMatchers.anyInt(),
- ArgumentMatchers.eq(Size(800, 450))
- )
+ map.getOutputMinFrameDuration(anyInt(), ArgumentMatchers.eq(Size(800, 450)))
)
.thenReturn(16666666L) // 60fps
Mockito.`when`(
- map.getOutputMinFrameDuration(
- ArgumentMatchers.anyInt(),
- ArgumentMatchers.eq(Size(640, 480))
- )
+ map.getOutputMinFrameDuration(anyInt(), ArgumentMatchers.eq(Size(640, 480)))
)
.thenReturn(16666666L) // 60fps
// Sets up the supported high resolution sizes
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
- Mockito.`when`(map.getHighResolutionOutputSizes(ArgumentMatchers.anyInt()))
+ Mockito.`when`(map.getHighResolutionOutputSizes(anyInt()))
.thenReturn(supportedHighResolutionSizes)
}
@@ -3773,11 +3757,11 @@
maximumResolutionHighResolutionSupportedSizes != null)
) {
Mockito.mock(StreamConfigurationMap::class.java).also {
- Mockito.`when`(it.getOutputSizes(ArgumentMatchers.anyInt()))
+ Mockito.`when`(it.getOutputSizes(anyInt()))
.thenReturn(maximumResolutionSupportedSizes)
Mockito.`when`(it.getOutputSizes(SurfaceTexture::class.java))
.thenReturn(maximumResolutionSupportedSizes)
- Mockito.`when`(it.getHighResolutionOutputSizes(ArgumentMatchers.anyInt()))
+ Mockito.`when`(it.getHighResolutionOutputSizes(anyInt()))
.thenReturn(maximumResolutionHighResolutionSupportedSizes)
}
} else {
@@ -3839,21 +3823,19 @@
set(CameraCharacteristics.SCALER_AVAILABLE_STREAM_USE_CASES, uc)
}
- val vs: IntArray
- if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
- vs =
+ val vs: IntArray =
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
intArrayOf(
CameraCharacteristics.CONTROL_VIDEO_STABILIZATION_MODE_OFF,
CameraCharacteristics.CONTROL_VIDEO_STABILIZATION_MODE_ON,
CameraCharacteristics.CONTROL_VIDEO_STABILIZATION_MODE_PREVIEW_STABILIZATION
)
- } else {
- vs =
+ } else {
intArrayOf(
CameraCharacteristics.CONTROL_VIDEO_STABILIZATION_MODE_OFF,
CameraCharacteristics.CONTROL_VIDEO_STABILIZATION_MODE_ON
)
- }
+ }
set(CameraCharacteristics.CONTROL_AVAILABLE_VIDEO_STABILIZATION_MODES, vs)
capabilities?.let { set(CameraCharacteristics.REQUEST_AVAILABLE_CAPABILITIES, it) }
@@ -3889,9 +3871,9 @@
val cameraX: CameraX =
try {
CameraXUtil.getOrCreateInstance(context) { cameraXConfig }.get()
- } catch (e: ExecutionException) {
+ } catch (_: ExecutionException) {
throw IllegalStateException("Unable to initialize CameraX for test.")
- } catch (e: InterruptedException) {
+ } catch (_: InterruptedException) {
throw IllegalStateException("Unable to initialize CameraX for test.")
}
useCaseConfigFactory = cameraX.defaultConfigFactory
diff --git a/camera/camera-camera2/src/test/java/androidx/camera/camera2/internal/TorchControlTest.java b/camera/camera-camera2/src/test/java/androidx/camera/camera2/internal/TorchControlTest.java
index 4937e7b..d725f7f 100644
--- a/camera/camera-camera2/src/test/java/androidx/camera/camera2/internal/TorchControlTest.java
+++ b/camera/camera-camera2/src/test/java/androidx/camera/camera2/internal/TorchControlTest.java
@@ -16,6 +16,7 @@
package androidx.camera.camera2.internal;
+import static android.hardware.camera2.CameraMetadata.CONTROL_AE_MODE_ON_LOW_LIGHT_BOOST_BRIGHTNESS_PRIORITY;
import static android.os.Looper.getMainLooper;
import static com.google.common.truth.Truth.assertThat;
@@ -29,6 +30,7 @@
import static org.mockito.internal.verification.VerificationModeFactory.times;
import static org.robolectric.Shadows.shadowOf;
+import android.annotation.SuppressLint;
import android.content.Context;
import android.hardware.camera2.CameraAccessException;
import android.hardware.camera2.CameraCharacteristics;
@@ -75,6 +77,8 @@
private TorchControl mNoFlashUnitTorchControl;
private TorchControl mTorchControl;
+ private CameraCharacteristicsCompat mLlbEnabledCameraCharacteristicsCompat;
+ private Camera2CameraControlImpl mLlbEnabledCamera2CameraControl;
private Camera2CameraControlImpl.CaptureResultListener mCaptureResultListener;
private TestLifecycleOwner mLifecycleOwner;
@@ -104,22 +108,25 @@
/* Prepare CameraControl 1 which flash is available */
CameraCharacteristics cameraCharacteristics1 =
cameraManager.getCameraCharacteristics(CAMERA1_ID);
- CameraCharacteristicsCompat characteristicsCompat1 =
+ mLlbEnabledCameraCharacteristicsCompat =
CameraCharacteristicsCompat.toCameraCharacteristicsCompat(cameraCharacteristics1,
CAMERA1_ID);
- Camera2CameraControlImpl camera2CameraControlImpl1 =
- spy(new Camera2CameraControlImpl(characteristicsCompat1,
- CameraXExecutors.mainThreadExecutor(),
- CameraXExecutors.mainThreadExecutor(),
- mock(CameraControlInternal.ControlUpdateCallback.class)));
- mTorchControl = new TorchControl(camera2CameraControlImpl1, characteristicsCompat1,
+ mLlbEnabledCamera2CameraControl = new Camera2CameraControlImpl(
+ mLlbEnabledCameraCharacteristicsCompat,
+ CameraXExecutors.mainThreadExecutor(),
+ CameraXExecutors.mainThreadExecutor(),
+ mock(CameraControlInternal.ControlUpdateCallback.class));
+ Camera2CameraControlImpl camera2CameraControl1 = spy(mLlbEnabledCamera2CameraControl);
+ mTorchControl = new TorchControl(camera2CameraControl1,
+ mLlbEnabledCameraCharacteristicsCompat,
CameraXExecutors.mainThreadExecutor());
mTorchControl.setActive(true);
ArgumentCaptor<Camera2CameraControlImpl.CaptureResultListener> argumentCaptor =
ArgumentCaptor.forClass(Camera2CameraControlImpl.CaptureResultListener.class);
- verify(camera2CameraControlImpl1).addCaptureResultListener(argumentCaptor.capture());
+ verify(camera2CameraControl1).addCaptureResultListener(
+ argumentCaptor.capture());
mCaptureResultListener = argumentCaptor.getValue();
/* Prepare Lifecycle for test LiveData */
@@ -305,6 +312,60 @@
assertThat(torchStates.get(2)).isEqualTo(TorchState.OFF); // by enableTorch(false)
}
+ @Config(minSdk = 35)
+ @Test
+ public void enableTorchIsCanceled_whenLowLightBoostIsOn() {
+ // Activates the Camera2CameraControlImpl and ensures low-light boost is turned on
+ mLlbEnabledCamera2CameraControl.incrementUseCount();
+ mLlbEnabledCamera2CameraControl.setActive(true);
+
+ TorchControl torchControl = mLlbEnabledCamera2CameraControl.getTorchControl();
+
+ mLlbEnabledCamera2CameraControl.enableLowLightBoostAsync(true);
+ shadowOf(getMainLooper()).idle();
+ assertThat(mLlbEnabledCamera2CameraControl.isLowLightBoostOn()).isTrue();
+
+ // Verifies that enabling torch operation will run failed with IllegalStateException cause
+ ListenableFuture<Void> future = torchControl.enableTorch(true);
+ shadowOf(getMainLooper()).idle();
+ Throwable cause = null;
+ try {
+ future.get();
+ } catch (ExecutionException | InterruptedException e) {
+ // The real cause is wrapped in ExecutionException, retrieve it and check.
+ cause = e.getCause();
+ }
+
+ assertThat(cause).isInstanceOf(IllegalStateException.class);
+ }
+
+ @SuppressLint("BanThreadSleep")
+ @Config(minSdk = 35)
+ @Test
+ public void torchIsDisabled_whenLowLightBoostIsTurnedOn() {
+ // Activates the Camera2CameraControlImpl
+ mLlbEnabledCamera2CameraControl.incrementUseCount();
+ mLlbEnabledCamera2CameraControl.setActive(true);
+
+ TorchControl torchControl = mLlbEnabledCamera2CameraControl.getTorchControl();
+ assertThat(torchControl.getTorchState().getValue()).isEqualTo(TorchState.OFF);
+
+ // Turns on torch
+ torchControl.enableTorch(true);
+ shadowOf(getMainLooper()).idle();
+ assertThat(mLlbEnabledCamera2CameraControl.isTorchOn()).isTrue();
+ assertThat(torchControl.getTorchState().getValue()).isEqualTo(TorchState.ON);
+
+ // Turns on low-light boost
+ mLlbEnabledCamera2CameraControl.enableLowLightBoostAsync(true);
+ shadowOf(getMainLooper()).idle();
+
+ // Verifies that enabling torch operation will run failed with IllegalStateException cause
+ assertThat(mLlbEnabledCamera2CameraControl.isLowLightBoostOn()).isTrue();
+ assertThat(mLlbEnabledCamera2CameraControl.isTorchOn()).isFalse();
+ assertThat(torchControl.getTorchState().getValue()).isEqualTo(TorchState.OFF);
+ }
+
private void initShadowCameraManager() {
// **** Camera 0 characteristics ****//
CameraCharacteristics characteristics0 =
@@ -326,6 +387,11 @@
ShadowCameraCharacteristics shadowCharacteristics1 = Shadow.extract(characteristics1);
shadowCharacteristics1.set(CameraCharacteristics.FLASH_INFO_AVAILABLE, true);
+ if (Build.VERSION.SDK_INT >= 35) {
+ // Adds low-light boost capability for related tests
+ shadowCharacteristics1.set(CameraCharacteristics.CONTROL_AE_AVAILABLE_MODES,
+ new int[]{CONTROL_AE_MODE_ON_LOW_LIGHT_BOOST_BRIGHTNESS_PRIORITY});
+ }
((ShadowCameraManager)
Shadow.extract(
diff --git a/camera/camera-core/build.gradle b/camera/camera-core/build.gradle
index 191b670..b00dd05 100644
--- a/camera/camera-core/build.gradle
+++ b/camera/camera-core/build.gradle
@@ -85,6 +85,8 @@
}
android {
+ compileSdk 35
+
defaultConfig {
externalNativeBuild {
def versionScript = file("src/main/cpp/jni.lds").getAbsolutePath()
diff --git a/camera/camera-core/src/main/java/androidx/camera/core/CameraControl.java b/camera/camera-core/src/main/java/androidx/camera/core/CameraControl.java
index beff098..9dbfa50 100644
--- a/camera/camera-core/src/main/java/androidx/camera/core/CameraControl.java
+++ b/camera/camera-core/src/main/java/androidx/camera/core/CameraControl.java
@@ -18,6 +18,7 @@
import androidx.annotation.FloatRange;
import androidx.annotation.RestrictTo;
+import androidx.camera.core.impl.utils.futures.Futures;
import com.google.common.util.concurrent.ListenableFuture;
@@ -63,6 +64,53 @@
@NonNull ListenableFuture<Void> enableTorch(boolean torch);
/**
+ * Enables low-light boost mode.
+ *
+ * <p>Devices running Android 15 or higher can provide support for low-light boost. This
+ * feature can automatically adjust the brightness of the preview, video or image analysis
+ * streams in low-light conditions. This is different from how the night mode camera
+ * extension creates still images, because night mode combines a burst of photos to create a
+ * single, enhanced image. While night mode works very well for creating a still image, it
+ * can't create a continuous stream of frames, but Low Light Boost can. Thus, Low Light Boost
+ * enables new camera capabilities, such as the following:
+ *
+ * <ul>
+ * <li>Providing an enhanced image preview, so users can better frame their low-light pictures.
+ * <li>Recording brighter videos in low-light conditions.
+ * <li>Scanning QR codes in low-light conditions.
+ * </ul>
+ *
+ * <p>Applications can query the low-light boost availability via
+ * {@link CameraInfo#isLowLightBoostSupported()}. If you enable Low Light Boost, it
+ * automatically turns on when there's a low light level, and turns off when there's more light.
+ *
+ * <p>If the camera device does not support low-light boost, the value obtained via
+ * {@link CameraInfo#getLowLightBoostState()} will always be {@link LowLightBoostState#OFF}.
+ *
+ * <p>Note that this mode may interact with other configurations:
+ *
+ * <ul>
+ * <li>When low-light boost is on, the flash or torch functionality may be unavailable.
+ * <li>When frame rate configuration results in an FPS exceeding 30, low-light boost will be
+ * disabled and the state will always be ({@link LowLightBoostState#OFF}).
+ * </ul>
+ *
+ * <p>Therefore, to use flash or torch functionality, low-light boost mode must be disabled.
+ * To ensure low-light boost mode functions correctly, avoid frame rate settings that result
+ * in an FPS exceeding 30.
+ *
+ * @param lowLightBoost true to turn on the low-light boost mode, false to turn it off.
+ * @return A {@link ListenableFuture} which is successful when the low-light boost mode was
+ * changed to the value specified. It fails when it is unable to change the log-light boost
+ * state. Cancellation of this future is a no-op.
+ * @see CameraInfo#isLowLightBoostSupported()
+ */
+ @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
+ default @NonNull ListenableFuture<Void> enableLowLightBoostAsync(boolean lowLightBoost) {
+ return Futures.immediateFailedFuture(new OperationCanceledException("Not supported!"));
+ }
+
+ /**
* Starts a focus and metering action configured by the {@link FocusMeteringAction}.
*
* <p>It will trigger an auto focus action and enable AF/AE/AWB metering regions. The action
diff --git a/camera/camera-core/src/main/java/androidx/camera/core/CameraInfo.java b/camera/camera-core/src/main/java/androidx/camera/core/CameraInfo.java
index 805440f..e2f6556 100644
--- a/camera/camera-core/src/main/java/androidx/camera/core/CameraInfo.java
+++ b/camera/camera-core/src/main/java/androidx/camera/core/CameraInfo.java
@@ -17,6 +17,7 @@
package androidx.camera.core;
import android.graphics.ImageFormat;
+import android.hardware.camera2.CaptureRequest;
import android.media.MediaActionSound;
import android.util.Range;
import android.view.Surface;
@@ -30,6 +31,7 @@
import androidx.camera.core.internal.compat.MediaActionSoundCompat;
import androidx.lifecycle.LifecycleOwner;
import androidx.lifecycle.LiveData;
+import androidx.lifecycle.MutableLiveData;
import androidx.lifecycle.Observer;
import org.jspecify.annotations.NonNull;
@@ -430,4 +432,38 @@
@RestrictTo(Scope.LIBRARY_GROUP)
@interface ImplementationType {
}
+
+ /**
+ * Returns if low-light boost is supported on the device. Low-light boost can be turned on via
+ * {@link CameraControl#enableLowLightBoostAsync(boolean)}.
+ *
+ * @return true if
+ * {@link CaptureRequest#CONTROL_AE_MODE_ON_LOW_LIGHT_BOOST_BRIGHTNESS_PRIORITY} is supported,
+ * otherwise false.
+ * @see CameraControl#enableLowLightBoostAsync(boolean)
+ * @see CaptureRequest#CONTROL_AE_MODE_ON_LOW_LIGHT_BOOST_BRIGHTNESS_PRIORITY
+ */
+ @RestrictTo(Scope.LIBRARY_GROUP)
+ default boolean isLowLightBoostSupported() {
+ return false;
+ }
+
+ /**
+ * Returns a {@link LiveData} of current {@link LowLightBoostState}.
+ *
+ * <p>Low-light boost can be turned on via
+ * {@link CameraControl#enableLowLightBoostAsync(boolean)} which will trigger the change
+ * event to the returned {@link LiveData}. Apps can either get immediate value via
+ * {@link LiveData#getValue()} or observe it via
+ * {@link LiveData#observe(LifecycleOwner, Observer)} to update low-light boost UI accordingly.
+ *
+ * <p>If the camera doesn't support low-light boost, then the state will always be
+ * {@link LowLightBoostState#OFF}.
+ *
+ * @return a {@link LiveData} containing current low-light boost state.
+ */
+ @RestrictTo(Scope.LIBRARY_GROUP)
+ default @NonNull LiveData<Integer> getLowLightBoostState() {
+ return new MutableLiveData<>(LowLightBoostState.OFF);
+ }
}
diff --git a/camera/camera-core/src/main/java/androidx/camera/core/LowLightBoostState.java b/camera/camera-core/src/main/java/androidx/camera/core/LowLightBoostState.java
new file mode 100644
index 0000000..94d37b3
--- /dev/null
+++ b/camera/camera-core/src/main/java/androidx/camera/core/LowLightBoostState.java
@@ -0,0 +1,51 @@
+/*
+ * Copyright 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.camera.core;
+
+import androidx.annotation.IntDef;
+import androidx.annotation.RestrictTo;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+
+/**
+ * Defines the valid states for Low Light Boost, as returned by
+ * {@link CameraInfo#getLowLightBoostState()}.
+ *
+ * <p>These states indicate whether the camera device supports low light boost and if it is
+ * currently active.
+ */
+@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
+public class LowLightBoostState {
+ /** Low-light boost is off. */
+ public static final int OFF = -1;
+ /** Low-light boost is on but inactive. */
+ public static final int INACTIVE = 0;
+ /** Low-light boost is on and active. */
+ public static final int ACTIVE = 1;
+
+ private LowLightBoostState() {
+ }
+
+ /**
+ */
+ @IntDef({OFF, INACTIVE, ACTIVE})
+ @Retention(RetentionPolicy.SOURCE)
+ @RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
+ public @interface State {
+ }
+}
diff --git a/camera/camera-core/src/main/java/androidx/camera/core/impl/ForwardingCameraControl.java b/camera/camera-core/src/main/java/androidx/camera/core/impl/ForwardingCameraControl.java
index f3531bb..66ea978 100644
--- a/camera/camera-core/src/main/java/androidx/camera/core/impl/ForwardingCameraControl.java
+++ b/camera/camera-core/src/main/java/androidx/camera/core/impl/ForwardingCameraControl.java
@@ -52,6 +52,11 @@
}
@Override
+ public @NonNull ListenableFuture<Void> enableLowLightBoostAsync(boolean lowLightBoost) {
+ return mCameraControlInternal.enableLowLightBoostAsync(lowLightBoost);
+ }
+
+ @Override
public @NonNull ListenableFuture<FocusMeteringResult> startFocusAndMetering(
@NonNull FocusMeteringAction action) {
return mCameraControlInternal.startFocusAndMetering(action);
diff --git a/camera/camera-core/src/main/java/androidx/camera/core/impl/ForwardingCameraInfo.java b/camera/camera-core/src/main/java/androidx/camera/core/impl/ForwardingCameraInfo.java
index 267475d..fd752fd 100644
--- a/camera/camera-core/src/main/java/androidx/camera/core/impl/ForwardingCameraInfo.java
+++ b/camera/camera-core/src/main/java/androidx/camera/core/impl/ForwardingCameraInfo.java
@@ -73,6 +73,16 @@
}
@Override
+ public boolean isLowLightBoostSupported() {
+ return mCameraInfoInternal.isLowLightBoostSupported();
+ }
+
+ @Override
+ public @NonNull LiveData<Integer> getLowLightBoostState() {
+ return mCameraInfoInternal.getLowLightBoostState();
+ }
+
+ @Override
public @NonNull LiveData<ZoomState> getZoomState() {
return mCameraInfoInternal.getZoomState();
}
diff --git a/camera/camera-core/src/main/java/androidx/camera/core/impl/StreamSpec.java b/camera/camera-core/src/main/java/androidx/camera/core/impl/StreamSpec.java
index bbd3ff2..2552a60 100644
--- a/camera/camera-core/src/main/java/androidx/camera/core/impl/StreamSpec.java
+++ b/camera/camera-core/src/main/java/androidx/camera/core/impl/StreamSpec.java
@@ -21,6 +21,8 @@
import android.util.Size;
import androidx.camera.core.DynamicRange;
+import androidx.camera.core.ViewPort;
+import androidx.camera.core.streamsharing.StreamSharing;
import com.google.auto.value.AutoValue;
@@ -46,6 +48,25 @@
public abstract @NonNull Size getResolution();
/**
+ * Returns the original resolution configured by the camera. This value is useful for
+ * debugging and analysis, as it represents the initial resolution intended for the stream,
+ * even if the stream is later modified.
+ *
+ * <p>This value typically matches the resolution returned by {@link #getResolution()},
+ * but may differ if the stream is modified (e.g., cropped, scaled, or rotated)
+ * after being configured by the camera. For example, {@link StreamSharing} first determines
+ * which child use case's requested resolution to be its configured resolution and then
+ * request a larger resolution from the camera. The camera stream is further modified (e.g.,
+ * cropped, scaled, or rotated) to fit the configured resolution and other requirements such
+ * as {@link ViewPort} and rotation. The final resolution after these
+ * modifications would be reflected by {@link #getResolution()}, while this method returns the
+ * original configured resolution.
+ *
+ * @return The originally configured camera resolution.
+ */
+ public abstract @NonNull Size getOriginalConfiguredResolution();
+
+ /**
* Returns the {@link DynamicRange} for the stream associated with this stream specification.
* @return the dynamic range for the stream.
*/
@@ -74,6 +95,7 @@
public static @NonNull Builder builder(@NonNull Size resolution) {
return new AutoValue_StreamSpec.Builder()
.setResolution(resolution)
+ .setOriginalConfiguredResolution(resolution)
.setExpectedFrameRateRange(FRAME_RATE_RANGE_UNSPECIFIED)
.setDynamicRange(DynamicRange.SDR)
.setZslDisabled(false);
@@ -93,6 +115,25 @@
public abstract @NonNull Builder setResolution(@NonNull Size resolution);
/**
+ * Sets the original resolution configured by the camera. This value is useful for
+ * debugging and analysis, as it represents the initial resolution intended by the stream
+ * consumer, even if the stream is later modified.
+ *
+ * <p>This value typically matches the resolution set by {@link #setResolution(Size)},
+ * but may differ if the stream is modified (e.g., cropped, scaled, or rotated)
+ * after being configured by the camera. For example, {@link StreamSharing} first
+ * determines which child use case's requested resolution to be its configured resolution
+ * and then request a larger resolution from the camera. The camera stream is further
+ * modified (e.g., cropped, scaled, or rotated) to fit the configured resolution and other
+ * requirements such as {@link ViewPort} and rotation. The final resolution after these
+ * modifications is set by {@link #setResolution(Size)}, while this method retains the
+ * original configured resolution.
+ *
+ * <p>If not set, this value will default to the resolution set in this builder.
+ */
+ public abstract @NonNull Builder setOriginalConfiguredResolution(@NonNull Size resolution);
+
+ /**
* Sets the dynamic range.
*
* <p>If not set, the default dynamic range is {@link DynamicRange#SDR}.
diff --git a/camera/camera-core/src/main/java/androidx/camera/core/streamsharing/PreferredChildSize.kt b/camera/camera-core/src/main/java/androidx/camera/core/streamsharing/PreferredChildSize.kt
new file mode 100644
index 0000000..1b65043
--- /dev/null
+++ b/camera/camera-core/src/main/java/androidx/camera/core/streamsharing/PreferredChildSize.kt
@@ -0,0 +1,35 @@
+/*
+ * Copyright 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.camera.core.streamsharing
+
+import android.graphics.Rect
+import android.util.Size
+
+/** Data class representing the preferred size information for a child. */
+internal data class PreferredChildSize(
+ /** The cropping rectangle to apply before scaling. */
+ val cropRectBeforeScaling: Rect,
+
+ /** The size of the child after scaling. */
+ val childSizeToScale: Size,
+
+ /**
+ * The original selected size from the child's preferred sizes before any scaling, cropping, or
+ * rotating.
+ */
+ val originalSelectedChildSize: Size
+)
diff --git a/camera/camera-core/src/main/java/androidx/camera/core/streamsharing/ResolutionsMerger.java b/camera/camera-core/src/main/java/androidx/camera/core/streamsharing/ResolutionsMerger.java
index 3ad3c04..deef99f 100644
--- a/camera/camera-core/src/main/java/androidx/camera/core/streamsharing/ResolutionsMerger.java
+++ b/camera/camera-core/src/main/java/androidx/camera/core/streamsharing/ResolutionsMerger.java
@@ -130,10 +130,11 @@
}
/**
- * Returns a preferred pair composed of a crop rect before scaling and a size after scaling.
+ * Returns a {@link PreferredChildSize} object containing the preferred size information for a
+ * child.
*
* <p>The first size in the child's ordered size list that does not require the parent to
- * upscale and does not cause double-cropping will be used to generate the pair, or {@code
+ * upscale and does not cause double-cropping will be used to generate the result, or {@code
* parentCropRect} will be used if no matching is found.
*
* <p>The returned crop rect and size will have the same aspect-ratio. When {@code
@@ -143,8 +144,10 @@
* <p>Notes that the input {@code childConfig} is expected to be one of the values that use to
* construct the {@link ResolutionsMerger}, if not an IllegalArgumentException will be thrown.
*/
- @NonNull Pair<Rect, Size> getPreferredChildSizePair(@NonNull UseCaseConfig<?> childConfig,
- @NonNull Rect parentCropRect, int sensorToBufferRotationDegrees,
+ @NonNull PreferredChildSize getPreferredChildSize(
+ @NonNull UseCaseConfig<?> childConfig,
+ @NonNull Rect parentCropRect,
+ int sensorToBufferRotationDegrees,
boolean isViewportSet) {
// For easier in following computations, width and height are reverted when the rotation
// degrees of sensor-to-buffer is 90 or 270.
@@ -154,27 +157,27 @@
isWidthHeightRevertedForComputation = true;
}
- // Get preferred child size pair.
- Pair<Rect, Size> pair = getPreferredChildSizePairInternal(parentCropRect, childConfig,
- isViewportSet);
- Rect cropRectBeforeScaling = pair.first;
- Size childSizeToScale = pair.second;
+ // Get preferred child size.
+ PreferredChildSize preferredChildSize = getPreferredChildSizeInternal(
+ parentCropRect, childConfig, isViewportSet);
// Restore the reversion of width and height
if (isWidthHeightRevertedForComputation) {
- childSizeToScale = reverseSize(childSizeToScale);
- cropRectBeforeScaling = reverseRect(cropRectBeforeScaling);
+ preferredChildSize = new PreferredChildSize(
+ reverseRect(preferredChildSize.getCropRectBeforeScaling()),
+ reverseSize(preferredChildSize.getChildSizeToScale()),
+ preferredChildSize.getOriginalSelectedChildSize());
}
- return new Pair<>(cropRectBeforeScaling, childSizeToScale);
-
+ return preferredChildSize;
}
- private @NonNull Pair<Rect, Size> getPreferredChildSizePairInternal(
+ private @NonNull PreferredChildSize getPreferredChildSizeInternal(
@NonNull Rect parentCropRect, @NonNull UseCaseConfig<?> childConfig,
boolean isViewportSet) {
Rect cropRectBeforeScaling;
Size childSizeToScale;
+ Size selectedChildSize;
if (isViewportSet) {
cropRectBeforeScaling = parentCropRect;
@@ -182,14 +185,16 @@
// When viewport is set, child size needs to be cropped to match viewport's
// aspect-ratio.
Size viewPortSize = rectToSize(parentCropRect);
- childSizeToScale = getPreferredChildSizeForViewport(viewPortSize, childConfig);
+ Pair<Size, Size> pair = getPreferredChildSizeForViewport(viewPortSize, childConfig);
+ selectedChildSize = pair.first;
+ childSizeToScale = pair.second;
} else {
Size parentSize = rectToSize(parentCropRect);
- childSizeToScale = getPreferredChildSize(parentSize, childConfig);
+ childSizeToScale = selectedChildSize = getPreferredChildSize(parentSize, childConfig);
cropRectBeforeScaling = getCropRectOfReferenceAspectRatio(parentSize, childSizeToScale);
}
- return new Pair<>(cropRectBeforeScaling, childSizeToScale);
+ return new PreferredChildSize(cropRectBeforeScaling, childSizeToScale, selectedChildSize);
}
/**
@@ -242,7 +247,7 @@
* construct the {@link ResolutionsMerger}, if not an IllegalArgumentException will be thrown.
*/
@VisibleForTesting
- @NonNull Size getPreferredChildSizeForViewport(@NonNull Size parentSize,
+ @NonNull Pair<Size, Size> getPreferredChildSizeForViewport(@NonNull Size parentSize,
@NonNull UseCaseConfig<?> childConfig) {
List<Size> candidateChildSizes = getSortedChildSizes(childConfig);
@@ -251,11 +256,11 @@
getCropRectOfReferenceAspectRatio(childSize, parentSize));
if (!hasUpscaling(childSizeToCrop, parentSize)) {
- return childSizeToCrop;
+ return Pair.create(childSize, childSizeToCrop);
}
}
- return parentSize;
+ return Pair.create(parentSize, parentSize);
}
private @NonNull List<Size> getCameraSupportedResolutions() {
diff --git a/camera/camera-core/src/main/java/androidx/camera/core/streamsharing/StreamSharing.java b/camera/camera-core/src/main/java/androidx/camera/core/streamsharing/StreamSharing.java
index ec4402b..565ee32 100644
--- a/camera/camera-core/src/main/java/androidx/camera/core/streamsharing/StreamSharing.java
+++ b/camera/camera-core/src/main/java/androidx/camera/core/streamsharing/StreamSharing.java
@@ -287,7 +287,10 @@
outputEdges.put(entry.getKey(), out.get(entry.getValue()));
}
- mVirtualCameraAdapter.setChildrenEdges(outputEdges);
+ Map<UseCase, Size> selectedChildSizeMap = mVirtualCameraAdapter.getSelectedChildSizes(
+ mSharingInputEdge, isViewportSet);
+
+ mVirtualCameraAdapter.setChildrenEdges(outputEdges, selectedChildSizeMap);
return List.of(mSessionConfigBuilder.build());
} else {
@@ -323,7 +326,11 @@
for (Map.Entry<UseCase, DualOutConfig> entry : outConfigMap.entrySet()) {
outputEdges.put(entry.getKey(), out.get(entry.getValue()));
}
- mVirtualCameraAdapter.setChildrenEdges(outputEdges);
+
+ Map<UseCase, Size> primarySelectedChildSizes =
+ mVirtualCameraAdapter.getSelectedChildSizes(mSharingInputEdge, isViewportSet);
+
+ mVirtualCameraAdapter.setChildrenEdges(outputEdges, primarySelectedChildSizes);
return List.of(mSessionConfigBuilder.build(),
mSecondarySessionConfigBuilder.build());
diff --git a/camera/camera-core/src/main/java/androidx/camera/core/streamsharing/VirtualCameraAdapter.java b/camera/camera-core/src/main/java/androidx/camera/core/streamsharing/VirtualCameraAdapter.java
index 3121dbd..d903782 100644
--- a/camera/camera-core/src/main/java/androidx/camera/core/streamsharing/VirtualCameraAdapter.java
+++ b/camera/camera-core/src/main/java/androidx/camera/core/streamsharing/VirtualCameraAdapter.java
@@ -37,7 +37,6 @@
import android.graphics.ImageFormat;
import android.graphics.Rect;
-import android.util.Pair;
import android.util.Range;
import android.util.Size;
import android.view.Surface;
@@ -222,7 +221,8 @@
/**
* Gets {@link OutConfig} for children {@link UseCase} based on the input edge.
*/
- @NonNull Map<UseCase, OutConfig> getChildrenOutConfigs(@NonNull SurfaceEdge sharingInputEdge,
+ @NonNull Map<UseCase, OutConfig> getChildrenOutConfigs(
+ @NonNull SurfaceEdge sharingInputEdge,
@ImageOutputConfig.RotationValue int parentTargetRotation, boolean isViewportSet) {
Map<UseCase, OutConfig> outConfigs = new HashMap<>();
for (UseCase useCase : mChildren) {
@@ -233,6 +233,24 @@
return outConfigs;
}
+ /**
+ * Gets original selected size for children {@link UseCase} based on the input edge.
+ */
+ @NonNull Map<UseCase, Size> getSelectedChildSizes(@NonNull SurfaceEdge sharingInputEdge,
+ boolean isViewportSet) {
+ Map<UseCase, Size> selectedChildSizes = new HashMap<>();
+ for (UseCase useCase : mChildren) {
+ PreferredChildSize preferredChildSize = mResolutionsMerger
+ .getPreferredChildSize(
+ requireNonNull(mChildrenConfigsMap.get(useCase)),
+ sharingInputEdge.getCropRect(),
+ getRotationDegrees(sharingInputEdge.getSensorToBufferTransform()),
+ isViewportSet);
+ selectedChildSizes.put(useCase, preferredChildSize.getOriginalSelectedChildSize());
+ }
+ return selectedChildSizes;
+ }
+
@NonNull Map<UseCase, DualOutConfig> getChildrenOutConfigs(
@NonNull SurfaceEdge primaryInputEdge,
@NonNull SurfaceEdge secondaryInputEdge,
@@ -247,7 +265,7 @@
parentTargetRotation, isViewportSet);
// secondary
OutConfig secondaryOutConfig = calculateOutConfig(
- useCase, mSecondaryResolutionsMerger,
+ useCase, requireNonNull(mSecondaryResolutionsMerger),
requireNonNull(mSecondaryParentCamera),
secondaryInputEdge,
parentTargetRotation, isViewportSet);
@@ -270,14 +288,14 @@
.getSensorRotationDegrees(parentTargetRotation);
boolean parentIsMirrored = isMirrored(
cameraInputEdge.getSensorToBufferTransform());
- Pair<Rect, Size> preferredSizePair = resolutionsMerger
- .getPreferredChildSizePair(
+ PreferredChildSize preferredChildSize = resolutionsMerger
+ .getPreferredChildSize(
requireNonNull(mChildrenConfigsMap.get(useCase)),
cameraInputEdge.getCropRect(),
getRotationDegrees(cameraInputEdge.getSensorToBufferTransform()),
isViewportSet);
- Rect cropRectBeforeScaling = preferredSizePair.first;
- Size childSizeToScale = preferredSizePair.second;
+ Rect cropRectBeforeScaling = preferredChildSize.getCropRectBeforeScaling();
+ Size childSizeToScale = preferredChildSize.getChildSizeToScale();
// Only use primary camera info for output surface
int childRotationDegrees = getChildRotationDegrees(useCase, mParentCamera);
@@ -299,7 +317,8 @@
/**
* Update children {@link SurfaceEdge} calculated by {@link StreamSharing}.
*/
- void setChildrenEdges(@NonNull Map<UseCase, SurfaceEdge> childrenEdges) {
+ void setChildrenEdges(@NonNull Map<UseCase, SurfaceEdge> childrenEdges,
+ @NonNull Map<UseCase, @NonNull Size> selectedChildSizes) {
mChildrenEdges.clear();
mChildrenEdges.putAll(childrenEdges);
for (Map.Entry<UseCase, SurfaceEdge> entry : mChildrenEdges.entrySet()) {
@@ -307,7 +326,9 @@
SurfaceEdge surfaceEdge = entry.getValue();
useCase.setViewPortCropRect(surfaceEdge.getCropRect());
useCase.setSensorToBufferTransformMatrix(surfaceEdge.getSensorToBufferTransform());
- useCase.updateSuggestedStreamSpec(surfaceEdge.getStreamSpec(), null);
+ StreamSpec streamSpec = getChildStreamSpec(useCase, surfaceEdge.getStreamSpec(),
+ selectedChildSizes);
+ useCase.updateSuggestedStreamSpec(streamSpec, null);
useCase.notifyState();
}
}
@@ -401,6 +422,17 @@
return cameraInternal.getCameraInfo().getSensorRotationDegrees(childTargetRotation);
}
+ @NonNull
+ private static StreamSpec getChildStreamSpec(@NonNull UseCase useCase,
+ @NonNull StreamSpec baseStreamSpec, @NonNull Map<UseCase, Size> selectedChildSizes) {
+ StreamSpec.Builder builder = baseStreamSpec.toBuilder();
+ Size selectedChildSize = selectedChildSizes.get(useCase);
+ if (selectedChildSize != null) {
+ builder.setOriginalConfiguredResolution(selectedChildSize);
+ }
+ return builder.build();
+ }
+
private static int getChildFormat(@NonNull UseCase useCase) {
return useCase instanceof ImageCapture ? ImageFormat.JPEG
: INTERNAL_DEFINED_IMAGE_FORMAT_PRIVATE;
@@ -517,8 +549,8 @@
Range<Integer> resolvedTargetFrameRate = StreamSpec.FRAME_RATE_RANGE_UNSPECIFIED;
for (UseCaseConfig<?> useCaseConfig : useCaseConfigs) {
- Range<Integer> targetFrameRate = useCaseConfig.getTargetFrameRate(
- resolvedTargetFrameRate);
+ Range<Integer> targetFrameRate = requireNonNull(useCaseConfig.getTargetFrameRate(
+ resolvedTargetFrameRate));
if (StreamSpec.FRAME_RATE_RANGE_UNSPECIFIED.equals(resolvedTargetFrameRate)) {
resolvedTargetFrameRate = targetFrameRate;
diff --git a/camera/camera-core/src/test/java/androidx/camera/core/streamsharing/ResolutionsMergerTest.kt b/camera/camera-core/src/test/java/androidx/camera/core/streamsharing/ResolutionsMergerTest.kt
index e7bbbd3..0a227b2 100644
--- a/camera/camera-core/src/test/java/androidx/camera/core/streamsharing/ResolutionsMergerTest.kt
+++ b/camera/camera-core/src/test/java/androidx/camera/core/streamsharing/ResolutionsMergerTest.kt
@@ -18,6 +18,7 @@
import android.graphics.Rect
import android.os.Build
+import android.util.Pair
import android.util.Rational
import android.util.Size
import androidx.camera.core.impl.ImageFormatConstants.INTERNAL_DEFINED_IMAGE_FORMAT_PRIVATE
@@ -337,7 +338,7 @@
}
@Test(expected = IllegalArgumentException::class)
- fun getPreferredChildSizePair_whenConfigNotPassedToConstructor_throwsException() {
+ fun getPreferredChildSize_whenUseCaseConfigNotPassedToConstructor_throwsException() {
// Arrange.
val config = createUseCaseConfig()
val sorter = FakeSupportedOutputSizesSorter(mapOf(config to SIZES_16_9))
@@ -345,11 +346,11 @@
// Act.
val useCaseConfigNotPassed = createUseCaseConfig()
- merger.getPreferredChildSizePair(useCaseConfigNotPassed, SIZE_1920_1440.toRect(), 0, false)
+ merger.getPreferredChildSize(useCaseConfigNotPassed, SIZE_1920_1440.toRect(), 0, false)
}
@Test
- fun getPreferredChildSizePair_whenViewportIsNotSet_canReturnCorrectly() {
+ fun getPreferredChildSize_whenViewportIsNotSet_canReturnCorrectly() {
// Arrange.
val config = createUseCaseConfig()
val candidateChildSizes =
@@ -367,21 +368,18 @@
// Act & Assert, should returns the first child size that do not need upscale and cause
// double-cropping.
- merger
- .getPreferredChildSizePair(config, SIZE_2560_1440.toRect(), 0, false)
- .containsExactly(SIZE_2560_1440.toRect(), SIZE_1920_1080)
- merger
- .getPreferredChildSizePair(config, SIZE_1280_720.toRect(), 0, false)
- .containsExactly(SIZE_1280_720.toRect(), SIZE_960_540)
+ assertThat(merger.getPreferredChildSize(config, SIZE_2560_1440.toRect(), 0, false))
+ .isEqualTo(PreferredChildSize(SIZE_2560_1440.toRect(), SIZE_1920_1080, SIZE_1920_1080))
+ assertThat(merger.getPreferredChildSize(config, SIZE_1280_720.toRect(), 0, false))
+ .isEqualTo(PreferredChildSize(SIZE_1280_720.toRect(), SIZE_960_540, SIZE_960_540))
// Act & Assert, should returns parent size when no matching.
- merger
- .getPreferredChildSizePair(config, SIZE_192_108.toRect(), 0, false)
- .containsExactly(SIZE_192_108.toRect(), SIZE_192_108)
+ assertThat(merger.getPreferredChildSize(config, SIZE_192_108.toRect(), 0, false))
+ .isEqualTo(PreferredChildSize(SIZE_192_108.toRect(), SIZE_192_108, SIZE_192_108))
}
@Test
- fun getPreferredChildSizePair_whenViewportIsSet_canReturnCorrectly() {
+ fun getPreferredChildSize_whenViewportIsSet_canReturnCorrectly() {
// Arrange.
val config = createUseCaseConfig()
val candidateChildSizes =
@@ -396,25 +394,22 @@
// Act & Assert, should returns 1:1 crop rect and size, that are generated from the first
// child size that do not need upscale.
val rect1440To1440 = SIZE_2560_1920.crop(Size(1440, 1440))
- merger
- .getPreferredChildSizePair(config, rect1440To1440, 0, true)
- .containsExactly(rect1440To1440, Size(1080, 1080))
+ assertThat(merger.getPreferredChildSize(config, rect1440To1440, 0, true))
+ .isEqualTo(PreferredChildSize(rect1440To1440, Size(1080, 1080), SIZE_1920_1080))
val rect720To720 = SIZE_1280_720.crop(Size(720, 720))
- merger
- .getPreferredChildSizePair(config, rect720To720, 0, true)
- .containsExactly(rect720To720, Size(540, 540))
+ assertThat(merger.getPreferredChildSize(config, rect720To720, 0, true))
+ .isEqualTo(PreferredChildSize(rect720To720, Size(540, 540), SIZE_960_540))
// Act & Assert, should returns crop rect and size, that are generated from parent size
// when no matching.
val size108To108 = Size(108, 108)
val rect108To108 = SIZE_192_108.crop(size108To108)
- merger
- .getPreferredChildSizePair(config, rect108To108, 0, true)
- .containsExactly(rect108To108, size108To108)
+ assertThat(merger.getPreferredChildSize(config, rect108To108, 0, true))
+ .isEqualTo(PreferredChildSize(rect108To108, size108To108, size108To108))
}
@Test
- fun getPreferredChildSizePair_whenViewportIsSetAndRotationIs90_canReturnCorrectly() {
+ fun getPreferredChildSize_whenViewportIsSetAndRotationIs90_canReturnCorrectly() {
// Arrange.
val config = createUseCaseConfig()
val candidateChildSizes =
@@ -429,20 +424,18 @@
// Act & Assert, should returns 1:2 crop rect and size, that are generated from the first
// child size that do not need upscale.
val rect1280To2560 = SIZE_2560_1440.crop(Size(2560, 1280)).reverse()
- merger
- .getPreferredChildSizePair(config, rect1280To2560, 90, true)
- .containsExactly(rect1280To2560, Size(960, 1920))
+ assertThat(merger.getPreferredChildSize(config, rect1280To2560, 90, true))
+ .isEqualTo(PreferredChildSize(rect1280To2560, Size(960, 1920), SIZE_1920_1080))
val rect640To1280 = SIZE_1280_720.crop(Size(1280, 640)).reverse()
- merger
- .getPreferredChildSizePair(config, rect640To1280, 90, true)
- .containsExactly(rect640To1280, Size(480, 960))
+ assertThat(merger.getPreferredChildSize(config, rect640To1280, 90, true))
+ .isEqualTo(PreferredChildSize(rect640To1280, Size(480, 960), SIZE_960_540))
// Act & Assert, should returns crop rect and size, that are generated from parent size
// when no matching.
- val rect96To192 = SIZE_192_108.crop(Size(192, 96)).reverse()
- merger
- .getPreferredChildSizePair(config, rect96To192, 90, true)
- .containsExactly(rect96To192, rectToSize(rect96To192))
+ val size192To96 = Size(192, 96)
+ val rect96To192 = SIZE_192_108.crop(size192To96).reverse()
+ assertThat(merger.getPreferredChildSize(config, rect96To192, 90, true))
+ .isEqualTo(PreferredChildSize(rect96To192, rectToSize(rect96To192), size192To96))
}
@Test(expected = IllegalArgumentException::class)
@@ -531,13 +524,13 @@
// Act & Assert, should returns the first child size that can be cropped to parent
// aspect-ratio and do not cause upscaling.
assertThat(merger.getPreferredChildSizeForViewport(SIZE_2560_1920, config))
- .isEqualTo(SIZE_1920_1440)
+ .isEqualTo(Pair.create(SIZE_1920_1440, SIZE_1920_1440))
assertThat(merger.getPreferredChildSizeForViewport(SIZE_1280_960, config))
- .isEqualTo(SIZE_960_720)
+ .isEqualTo(Pair.create(SIZE_960_720, SIZE_960_720))
// Act & Assert, should returns parent size when no matching.
assertThat(merger.getPreferredChildSizeForViewport(SIZE_640_480, config))
- .isEqualTo(SIZE_640_480)
+ .isEqualTo(Pair.create(SIZE_640_480, SIZE_640_480))
}
@Test
@@ -556,13 +549,13 @@
// Act & Assert, should returns the first child size that can be cropped to parent
// aspect-ratio and do not cause upscaling.
assertThat(merger.getPreferredChildSizeForViewport(SIZE_1920_1440, config))
- .isEqualTo(Size(1440, 1080))
+ .isEqualTo(Pair.create(SIZE_1920_1080, Size(1440, 1080)))
assertThat(merger.getPreferredChildSizeForViewport(SIZE_1280_960, config))
- .isEqualTo(SIZE_960_720)
+ .isEqualTo(Pair.create(SIZE_1280_720, SIZE_960_720))
// Act & Assert, should returns parent size when no matching.
assertThat(merger.getPreferredChildSizeForViewport(SIZE_640_480, config))
- .isEqualTo(SIZE_640_480)
+ .isEqualTo(Pair.create(SIZE_640_480, SIZE_640_480))
}
@Test
@@ -776,11 +769,6 @@
return FakeUseCaseConfig.Builder().useCaseConfig
}
- private fun android.util.Pair<Rect, Size>.containsExactly(rect: Rect, size: Size) {
- assertThat(first).isEqualTo(rect)
- assertThat(second).isEqualTo(size)
- }
-
private fun Rect.hasMatchingAspectRatio(resolution: Size): Boolean {
return AspectRatioUtil.hasMatchingAspectRatio(resolution, Rational(width(), height()))
}
diff --git a/camera/camera-core/src/test/java/androidx/camera/core/streamsharing/VirtualCameraAdapterTest.kt b/camera/camera-core/src/test/java/androidx/camera/core/streamsharing/VirtualCameraAdapterTest.kt
index 2d8f0f8..1049990 100644
--- a/camera/camera-core/src/test/java/androidx/camera/core/streamsharing/VirtualCameraAdapterTest.kt
+++ b/camera/camera-core/src/test/java/androidx/camera/core/streamsharing/VirtualCameraAdapterTest.kt
@@ -97,6 +97,8 @@
Pair(child1 as UseCase, createSurfaceEdge()),
Pair(child2 as UseCase, createSurfaceEdge())
)
+ private val selectedChildSizes =
+ mapOf<UseCase, Size>(child1 to INPUT_SIZE, child2 to INPUT_SIZE)
private val useCaseConfigFactory = FakeUseCaseConfigFactory()
private lateinit var adapter: VirtualCameraAdapter
private var snapshotTriggered = false
@@ -223,7 +225,7 @@
fun setUseCaseActiveAndInactive_surfaceConnectsAndDisconnects() {
// Arrange.
adapter.bindChildren()
- adapter.setChildrenEdges(childrenEdges)
+ adapter.setChildrenEdges(childrenEdges, selectedChildSizes)
child1.updateSessionConfigForTesting(SESSION_CONFIG_WITH_SURFACE)
// Assert: edge open by default.
verifyEdge(child1, OPEN, NO_PROVIDER)
@@ -242,7 +244,7 @@
fun resetWithClosedChildSurface_invokesErrorListener() {
// Arrange.
adapter.bindChildren()
- adapter.setChildrenEdges(childrenEdges)
+ adapter.setChildrenEdges(childrenEdges, selectedChildSizes)
child1.updateSessionConfigForTesting(SESSION_CONFIG_WITH_SURFACE)
child1.notifyActiveForTesting()
@@ -260,7 +262,7 @@
fun resetUseCase_edgeInvalidated() {
// Arrange: setup and get the old DeferrableSurface.
adapter.bindChildren()
- adapter.setChildrenEdges(childrenEdges)
+ adapter.setChildrenEdges(childrenEdges, selectedChildSizes)
child1.updateSessionConfigForTesting(SESSION_CONFIG_WITH_SURFACE)
child1.notifyActiveForTesting()
val oldSurface = childrenEdges[child1]!!.deferrableSurfaceForTesting
@@ -277,7 +279,7 @@
fun updateUseCaseWithAndWithoutSurface_surfaceConnectsAndDisconnects() {
// Arrange
adapter.bindChildren()
- adapter.setChildrenEdges(childrenEdges)
+ adapter.setChildrenEdges(childrenEdges, selectedChildSizes)
child1.notifyActiveForTesting()
verifyEdge(child1, OPEN, NO_PROVIDER)
@@ -364,10 +366,17 @@
@Test
fun updateChildrenSpec_updateAndNotifyChildren() {
// Act: update children with the map.
- adapter.setChildrenEdges(childrenEdges)
- // Assert: surface size, crop rect and transformation propagated to children
+ val selectedChildSizes =
+ mapOf<UseCase, Size>(child1 to Size(400, 300), child2 to Size(720, 480))
+ adapter.setChildrenEdges(childrenEdges, selectedChildSizes)
+ // Assert: surface size, original selected size, crop rect and transformation propagated
+ // to children
assertThat(child1.attachedStreamSpec!!.resolution).isEqualTo(INPUT_SIZE)
+ assertThat(child1.attachedStreamSpec!!.originalConfiguredResolution)
+ .isEqualTo(Size(400, 300))
assertThat(child2.attachedStreamSpec!!.resolution).isEqualTo(INPUT_SIZE)
+ assertThat(child2.attachedStreamSpec!!.originalConfiguredResolution)
+ .isEqualTo(Size(720, 480))
assertThat(child1.viewPortCropRect).isEqualTo(CROP_RECT)
assertThat(child2.viewPortCropRect).isEqualTo(CROP_RECT)
assertThat(child1.sensorToBufferTransformMatrix).isEqualTo(SENSOR_TO_BUFFER)
diff --git a/camera/camera-effects/build.gradle b/camera/camera-effects/build.gradle
index 647f2fd..8bb2c7e 100644
--- a/camera/camera-effects/build.gradle
+++ b/camera/camera-effects/build.gradle
@@ -49,6 +49,7 @@
androidTestImplementation("androidx.concurrent:concurrent-futures-ktx:1.1.0")
}
android {
+ compileSdk 35
testOptions.unitTests.includeAndroidResources = true
namespace = "androidx.camera.effects"
}
diff --git a/camera/camera-extensions/build.gradle b/camera/camera-extensions/build.gradle
index 0e4ace09..bb99409 100644
--- a/camera/camera-extensions/build.gradle
+++ b/camera/camera-extensions/build.gradle
@@ -76,6 +76,8 @@
}
android {
+ compileSdk 35
+
buildTypes.configureEach {
consumerProguardFiles "proguard-rules.pro"
}
diff --git a/camera/camera-lifecycle/build.gradle b/camera/camera-lifecycle/build.gradle
index c02d39a..a051ed1 100644
--- a/camera/camera-lifecycle/build.gradle
+++ b/camera/camera-lifecycle/build.gradle
@@ -61,6 +61,8 @@
}
android {
+ compileSdk 35
+
lintOptions {
enable 'CameraXQuirksClassDetector'
}
diff --git a/camera/camera-lifecycle/samples/build.gradle b/camera/camera-lifecycle/samples/build.gradle
index 5f5011f..09838ff 100644
--- a/camera/camera-lifecycle/samples/build.gradle
+++ b/camera/camera-lifecycle/samples/build.gradle
@@ -39,6 +39,7 @@
}
android {
+ compileSdk 35
namespace = "androidx.camera.lifecycle.samples"
}
diff --git a/camera/camera-mlkit-vision/build.gradle b/camera/camera-mlkit-vision/build.gradle
index 6ad87b4..25831a7 100644
--- a/camera/camera-mlkit-vision/build.gradle
+++ b/camera/camera-mlkit-vision/build.gradle
@@ -45,6 +45,8 @@
}
android {
+ compileSdk 35
+
lintOptions {
enable 'CameraXQuirksClassDetector'
}
diff --git a/camera/camera-testing/build.gradle b/camera/camera-testing/build.gradle
index 0038f04..a702c14 100644
--- a/camera/camera-testing/build.gradle
+++ b/camera/camera-testing/build.gradle
@@ -79,6 +79,8 @@
}
android {
+ compileSdk 35
+
defaultConfig {
externalNativeBuild {
cmake {
diff --git a/camera/camera-testlib-extensions/build.gradle b/camera/camera-testlib-extensions/build.gradle
index d0e83eeb..a220c59 100644
--- a/camera/camera-testlib-extensions/build.gradle
+++ b/camera/camera-testlib-extensions/build.gradle
@@ -35,6 +35,8 @@
}
android {
+ compileSdk 35
+
lintOptions {
enable 'CameraXQuirksClassDetector'
}
diff --git a/camera/camera-video/api/current.txt b/camera/camera-video/api/current.txt
index 0e6ea1c..0c6fcf2 100644
--- a/camera/camera-video/api/current.txt
+++ b/camera/camera-video/api/current.txt
@@ -162,6 +162,7 @@
method public int getMirrorMode();
method public T getOutput();
method public androidx.camera.core.ResolutionInfo? getResolutionInfo();
+ method public androidx.camera.video.Quality? getSelectedQuality();
method public android.util.Range<java.lang.Integer!> getTargetFrameRate();
method public int getTargetRotation();
method public boolean isVideoStabilizationEnabled();
diff --git a/camera/camera-video/api/restricted_current.txt b/camera/camera-video/api/restricted_current.txt
index 0e6ea1c..0c6fcf2 100644
--- a/camera/camera-video/api/restricted_current.txt
+++ b/camera/camera-video/api/restricted_current.txt
@@ -162,6 +162,7 @@
method public int getMirrorMode();
method public T getOutput();
method public androidx.camera.core.ResolutionInfo? getResolutionInfo();
+ method public androidx.camera.video.Quality? getSelectedQuality();
method public android.util.Range<java.lang.Integer!> getTargetFrameRate();
method public int getTargetRotation();
method public boolean isVideoStabilizationEnabled();
diff --git a/camera/camera-video/build.gradle b/camera/camera-video/build.gradle
index d719316..9cbe32e 100644
--- a/camera/camera-video/build.gradle
+++ b/camera/camera-video/build.gradle
@@ -75,6 +75,8 @@
}
android {
+ compileSdk 35
+
lintOptions {
enable 'CameraXQuirksClassDetector'
}
diff --git a/camera/camera-video/src/main/java/androidx/camera/video/VideoCapture.java b/camera/camera-video/src/main/java/androidx/camera/video/VideoCapture.java
index 43e805a..b947810 100644
--- a/camera/camera-video/src/main/java/androidx/camera/video/VideoCapture.java
+++ b/camera/camera-video/src/main/java/androidx/camera/video/VideoCapture.java
@@ -56,6 +56,7 @@
import static androidx.camera.video.internal.utils.DynamicRangeUtil.videoProfileHdrFormatsToDynamicRangeEncoding;
import static androidx.core.util.Preconditions.checkState;
+import static java.util.Collections.emptyMap;
import static java.util.Collections.singletonList;
import static java.util.Objects.requireNonNull;
@@ -145,6 +146,7 @@
import java.util.Collections;
import java.util.HashSet;
import java.util.Iterator;
+import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.Objects;
@@ -195,6 +197,7 @@
private boolean mHasCompensatingTransformation = false;
private @Nullable SourceStreamRequirementObserver mSourceStreamRequirementObserver;
private SessionConfig.@Nullable CloseableErrorListener mCloseableErrorListener;
+ private Map<Quality, List<Size>> mQualityToCustomSizesMap = emptyMap();
/**
* Create a VideoCapture associated with the given {@link VideoOutput}.
@@ -338,6 +341,44 @@
return getResolutionInfoInternal();
}
+ /**
+ * Returns the selected Quality.
+ *
+ * <p>The selected Quality represents the final quality level chosen for the stream. The
+ * selected Quality will be one of the specified qualities from the {@link QualitySelector}
+ * provided by the associated {@link VideoOutput}. If {@link Quality#HIGHEST} or
+ * {@link Quality#LOWEST} is specified in the selector, it will be resolved to an actual
+ * Quality value. Even if the stream is later cropped (e.g., by using a {@link ViewPort}), this
+ * value represents the original quality level of the stream.
+ *
+ * <p>This method will return the selected Quality only after the use case is bound using
+ * {@link androidx.camera.lifecycle.ProcessCameraProvider#bindToLifecycle}. Otherwise, it
+ * will return null. The selected Quality may change if the use case is unbound and then
+ * rebound.
+ *
+ * @return The selected Quality if the use case is bound, or null otherwise.
+ */
+ public @Nullable Quality getSelectedQuality() {
+ StreamSpec streamSpec = getAttachedStreamSpec();
+ if (streamSpec == null) {
+ return null;
+ }
+ // In the general case, there should be an exact match from configured resolution to
+ // Quality.
+ Size configuredResolution = streamSpec.getOriginalConfiguredResolution();
+ for (Map.Entry<Quality, List<Size>> entry : mQualityToCustomSizesMap.entrySet()) {
+ if (entry.getValue().contains(configuredResolution)) {
+ return entry.getKey(); // Found exact match, no need to check further
+ }
+ }
+ Logger.w(TAG, "Can't find matched Quality for " + configuredResolution);
+
+ // Fallback to find the nearest available quality. This can occur when StreamSharing
+ // is unable to downscale/crop the camera stream according to the UseCase's preferred
+ // resolution and instead returns the original camera stream resolution.
+ return findNearestSizeFor(mQualityToCustomSizesMap, configuredResolution);
+ }
+
@RestrictTo(Scope.LIBRARY_GROUP)
@Override
protected @Nullable ResolutionInfo getResolutionInfoInternal() {
@@ -1456,64 +1497,83 @@
requestedDynamicRange);
QualityRatioToResolutionsTable qualityRatioTable = new QualityRatioToResolutionsTable(
cameraInfo.getSupportedResolutions(getImageFormat()), supportedQualityToSizeMap);
- List<Size> customOrderedResolutions = new ArrayList<>();
+ // Use LinkedHashMap to maintain the order.
+ LinkedHashMap<Quality, List<Size>> orderedQualityToSizesMap = new LinkedHashMap<>();
for (Quality selectedQuality : selectedQualities) {
- customOrderedResolutions.addAll(
+ orderedQualityToSizesMap.put(selectedQuality,
qualityRatioTable.getResolutions(selectedQuality, aspectRatio));
}
- List<Size> filteredCustomOrderedResolutions = filterOutEncoderUnsupportedResolutions(
- (VideoCaptureConfig<T>) builder.getUseCaseConfig(), mediaSpec,
- requestedDynamicRange, videoCapabilities, customOrderedResolutions,
- supportedQualityToSizeMap);
+ LinkedHashMap<Quality, List<Size>> filteredOrderedQualityToSizesMap =
+ filterOutEncoderUnsupportedResolutions(
+ (VideoCaptureConfig<T>) builder.getUseCaseConfig(), mediaSpec,
+ requestedDynamicRange, videoCapabilities, orderedQualityToSizesMap,
+ supportedQualityToSizeMap);
+ List<Size> filteredCustomOrderedResolutions = new ArrayList<>();
+ for (List<Size> resolutions : filteredOrderedQualityToSizesMap.values()) {
+ filteredCustomOrderedResolutions.addAll(resolutions);
+ }
Logger.d(TAG, "Set custom ordered resolutions = " + filteredCustomOrderedResolutions);
builder.getMutableConfig().insertOption(OPTION_CUSTOM_ORDERED_RESOLUTIONS,
filteredCustomOrderedResolutions);
+ mQualityToCustomSizesMap = filteredOrderedQualityToSizesMap;
}
- private static @NonNull List<Size> filterOutEncoderUnsupportedResolutions(
+ private static @NonNull LinkedHashMap<Quality, List<Size>>
+ filterOutEncoderUnsupportedResolutions(
@NonNull VideoCaptureConfig<?> config,
@NonNull MediaSpec mediaSpec,
@NonNull DynamicRange dynamicRange,
@NonNull VideoCapabilities videoCapabilities,
- @NonNull List<Size> resolutions,
+ @NonNull LinkedHashMap<Quality, List<Size>> qualityToSizesOrderedMap,
@NonNull Map<Quality, Size> supportedQualityToSizeMap
) {
- if (resolutions.isEmpty()) {
- return resolutions;
+ if (qualityToSizesOrderedMap.isEmpty()) {
+ return new LinkedHashMap<>();
}
- Iterator<Size> iterator = resolutions.iterator();
- while (iterator.hasNext()) {
- Size resolution = iterator.next();
- // To improve performance, there is no need to check for supported qualities'
- // resolutions because the encoder should support them.
- if (supportedQualityToSizeMap.containsValue(resolution)) {
- continue;
+ LinkedHashMap<Quality, List<Size>> filteredQualityToSizesOrderedMap = new LinkedHashMap<>();
+ for (Map.Entry<Quality, List<Size>> entry : qualityToSizesOrderedMap.entrySet()) {
+ // Copy the size list first and filter out the unsupported resolutions.
+ List<Size> filteredSizeList = new ArrayList<>(entry.getValue());
+ Iterator<Size> sizeIterator = filteredSizeList.iterator();
+ while (sizeIterator.hasNext()) {
+ Size resolution = sizeIterator.next();
+ // To improve performance, there is no need to check for supported qualities'
+ // resolutions because the encoder should support them.
+ if (supportedQualityToSizeMap.containsValue(resolution)) {
+ continue;
+ }
+ // We must find EncoderProfiles for each resolution because the EncoderProfiles
+ // found by resolution may contain different video mine type which leads to
+ // different codec.
+ VideoValidatedEncoderProfilesProxy encoderProfiles =
+ videoCapabilities.findNearestHigherSupportedEncoderProfilesFor(resolution,
+ dynamicRange);
+ if (encoderProfiles == null) {
+ continue;
+ }
+ // If the user set a non-fully specified target DynamicRange, there could be
+ // multiple videoProfiles that matches to the DynamicRange. Find the one with the
+ // largest supported size as a workaround.
+ // If the suggested StreamSpec(i.e. DynamicRange + resolution) is unfortunately over
+ // codec supported size, then rely on surface processing (OpenGL) to resize the
+ // camera stream.
+ VideoEncoderInfo videoEncoderInfo = findLargestSupportedSizeVideoEncoderInfo(
+ config.getVideoEncoderInfoFinder(), encoderProfiles, dynamicRange,
+ mediaSpec, resolution,
+ requireNonNull(config.getTargetFrameRate(Defaults.DEFAULT_FPS_RANGE)));
+ if (videoEncoderInfo != null && !videoEncoderInfo.isSizeSupportedAllowSwapping(
+ resolution.getWidth(), resolution.getHeight())) {
+ sizeIterator.remove();
+ }
}
- // We must find EncoderProfiles for each resolution because the EncoderProfiles found
- // by resolution may contain different video mine type which leads to different codec.
- VideoValidatedEncoderProfilesProxy encoderProfiles =
- videoCapabilities.findNearestHigherSupportedEncoderProfilesFor(resolution,
- dynamicRange);
- if (encoderProfiles == null) {
- continue;
- }
- // If the user set a non-fully specified target DynamicRange, there could be multiple
- // videoProfiles that matches to the DynamicRange. Find the one with the largest
- // supported size as a workaround.
- // If the suggested StreamSpec(i.e. DynamicRange + resolution) is unfortunately over
- // codec supported size, then rely on surface processing (OpenGL) to resize the
- // camera stream.
- VideoEncoderInfo videoEncoderInfo = findLargestSupportedSizeVideoEncoderInfo(
- config.getVideoEncoderInfoFinder(), encoderProfiles, dynamicRange,
- mediaSpec, resolution,
- requireNonNull(config.getTargetFrameRate(Defaults.DEFAULT_FPS_RANGE)));
- if (videoEncoderInfo != null && !videoEncoderInfo.isSizeSupportedAllowSwapping(
- resolution.getWidth(), resolution.getHeight())) {
- iterator.remove();
+
+ // Put the filtered size list only when it is not empty.
+ if (!filteredSizeList.isEmpty()) {
+ filteredQualityToSizesOrderedMap.put(entry.getKey(), filteredSizeList);
}
}
- return resolutions;
+ return filteredQualityToSizesOrderedMap;
}
private static @Nullable VideoEncoderInfo findLargestSupportedSizeVideoEncoderInfo(
@@ -1556,6 +1616,32 @@
}
/**
+ * Finds the Quality with the size closest to the target size based on area.
+ *
+ * @param sizeMap The map of Quality to a list of Size`s.
+ * @param targetSize The target size to compare against.
+ * @return The Quality with the closest size, or `null` if no match is found.
+ */
+ private static @Nullable Quality findNearestSizeFor(
+ @NonNull Map<Quality, List<Size>> sizeMap, @NonNull Size targetSize) {
+ int targetArea = getArea(targetSize);
+ Quality nearestQuality = null;
+ int minAreaDiff = Integer.MAX_VALUE;
+
+ for (Map.Entry<Quality, List<Size>> entry : sizeMap.entrySet()) {
+ for (Size size : entry.getValue()) {
+ int areaDiff = Math.abs(getArea(size) - targetArea);
+ if (areaDiff < minAreaDiff) {
+ minAreaDiff = areaDiff;
+ nearestQuality = entry.getKey();
+ }
+ }
+ }
+
+ return nearestQuality;
+ }
+
+ /**
* Gets the snapshot value of the given {@link Observable}.
*
* <p>Note: Set {@code valueIfMissing} to a non-{@code null} value doesn't mean the method
diff --git a/camera/camera-video/src/test/java/androidx/camera/video/VideoCaptureTest.kt b/camera/camera-video/src/test/java/androidx/camera/video/VideoCaptureTest.kt
index 4641453..f0387ef 100644
--- a/camera/camera-video/src/test/java/androidx/camera/video/VideoCaptureTest.kt
+++ b/camera/camera-video/src/test/java/androidx/camera/video/VideoCaptureTest.kt
@@ -1847,6 +1847,74 @@
)
}
+ @Test
+ fun verifySelectedQuality_matchConfiguredResolution() {
+ testSelectedQualityIsExpected(
+ streamSpecConfiguredResolution = RESOLUTION_720P,
+ qualitySelector = QualitySelector.fromOrderedList(listOf(FHD, HD, SD)),
+ expectedQuality = HD,
+ )
+ }
+
+ @Test
+ fun verifySelectedQuality_setHighestQuality_returnSpecificQuality() {
+ testSelectedQualityIsExpected(
+ streamSpecConfiguredResolution = RESOLUTION_1080P,
+ qualitySelector = QualitySelector.from(HIGHEST),
+ expectedQuality = FHD,
+ )
+ }
+
+ @Test
+ fun verifySelectedQuality_setLowestQuality_returnSpecificQuality() {
+ testSelectedQualityIsExpected(
+ streamSpecConfiguredResolution = RESOLUTION_480P,
+ qualitySelector = QualitySelector.from(LOWEST),
+ expectedQuality = SD,
+ )
+ }
+
+ @Test
+ fun verifySelectedQuality_configuredResolutionNotMatch_returnNearestQuality() {
+ testSelectedQualityIsExpected(
+ streamSpecConfiguredResolution = Size(1920, 1000),
+ qualitySelector = QualitySelector.fromOrderedList(listOf(FHD, HD, SD)),
+ expectedQuality = FHD,
+ )
+ }
+
+ private fun testSelectedQualityIsExpected(
+ streamSpecConfiguredResolution: Size,
+ streamSpecResolution: Size = streamSpecConfiguredResolution,
+ qualitySelector: QualitySelector,
+ profiles: Map<Int, EncoderProfilesProxy> = FULL_QUALITY_PROFILES_MAP,
+ videoCapabilities: VideoCapabilities = FULL_QUALITY_VIDEO_CAPABILITIES,
+ expectedQuality: Quality?
+ ) {
+ // Arrange.
+ setupCamera(profiles = profiles)
+ createCameraUseCaseAdapter()
+ setSuggestedStreamSpec(
+ resolution = streamSpecResolution,
+ originalConfiguredResolution = streamSpecConfiguredResolution
+ )
+ val videoOutput =
+ createVideoOutput(
+ videoCapabilities = videoCapabilities,
+ mediaSpec =
+ MediaSpec.builder()
+ .configureVideo { it.setQualitySelector(qualitySelector) }
+ .build()
+ )
+ val videoCapture = createVideoCapture(videoOutput = videoOutput)
+
+ // Act.
+ addAndAttachUseCases(videoCapture)
+
+ // Assert.
+ assertThat(videoCapture.selectedQuality).isEqualTo(expectedQuality)
+ }
+
private fun testResolutionInfoContainsExpected(
resolution: Size,
sensorRotationDegrees: Int,
@@ -2101,6 +2169,7 @@
private fun setSuggestedStreamSpec(
resolution: Size,
+ originalConfiguredResolution: Size? = null,
expectedFrameRate: Range<Int> = StreamSpec.FRAME_RATE_RANGE_UNSPECIFIED,
dynamicRange: DynamicRange? = null
) {
@@ -2109,6 +2178,9 @@
.apply {
setExpectedFrameRateRange(expectedFrameRate)
dynamicRange?.let { setDynamicRange(dynamicRange) }
+ originalConfiguredResolution?.let {
+ setOriginalConfiguredResolution(originalConfiguredResolution)
+ }
}
.build()
)
diff --git a/camera/camera-view/build.gradle b/camera/camera-view/build.gradle
index e1601f3..1d1f1e5 100644
--- a/camera/camera-view/build.gradle
+++ b/camera/camera-view/build.gradle
@@ -76,6 +76,8 @@
androidTestImplementation("androidx.test.espresso:espresso-core:3.3.0")
}
android {
+ compileSdk 35
+
lintOptions {
enable 'CameraXQuirksClassDetector'
}
diff --git a/camera/integration-tests/camerapipetestapp/build.gradle b/camera/integration-tests/camerapipetestapp/build.gradle
index a615ba4..6c49dbe 100644
--- a/camera/integration-tests/camerapipetestapp/build.gradle
+++ b/camera/integration-tests/camerapipetestapp/build.gradle
@@ -22,6 +22,8 @@
}
android {
+ compileSdk 35
+
defaultConfig {
applicationId = "androidx.camera.integration.camera2.pipe"
}
diff --git a/camera/integration-tests/coretestapp/build.gradle b/camera/integration-tests/coretestapp/build.gradle
index 9b27d74..4b9931e 100644
--- a/camera/integration-tests/coretestapp/build.gradle
+++ b/camera/integration-tests/coretestapp/build.gradle
@@ -21,6 +21,8 @@
}
android {
+ compileSdk 35
+
defaultConfig {
applicationId = "androidx.camera.integration.core"
diff --git a/camera/integration-tests/diagnosetestapp/build.gradle b/camera/integration-tests/diagnosetestapp/build.gradle
index 70a9f1d..2db2390 100644
--- a/camera/integration-tests/diagnosetestapp/build.gradle
+++ b/camera/integration-tests/diagnosetestapp/build.gradle
@@ -21,6 +21,8 @@
}
android {
+ compileSdk 35
+
defaultConfig {
applicationId = "androidx.camera.integration.diagnose"
}
diff --git a/camera/integration-tests/extensionstestapp/build.gradle b/camera/integration-tests/extensionstestapp/build.gradle
index c2c09a4..03e2990 100644
--- a/camera/integration-tests/extensionstestapp/build.gradle
+++ b/camera/integration-tests/extensionstestapp/build.gradle
@@ -31,6 +31,8 @@
}
android {
+ compileSdk 35
+
defaultConfig {
applicationId = "androidx.camera.integration.extensions"
}
diff --git a/camera/integration-tests/extensionstestapp/src/main/java/androidx/camera/integration/extensions/utils/PermissionUtil.kt b/camera/integration-tests/extensionstestapp/src/main/java/androidx/camera/integration/extensions/utils/PermissionUtil.kt
index 1ed34c4..0b1bd0b 100644
--- a/camera/integration-tests/extensionstestapp/src/main/java/androidx/camera/integration/extensions/utils/PermissionUtil.kt
+++ b/camera/integration-tests/extensionstestapp/src/main/java/androidx/camera/integration/extensions/utils/PermissionUtil.kt
@@ -88,7 +88,10 @@
return arrayOfNulls(0)
}
- if (info.requestedPermissions == null || info.requestedPermissions.isEmpty()) {
+ if (
+ info.requestedPermissions == null ||
+ (info.requestedPermissions as Array<out Any>).isEmpty()
+ ) {
return arrayOfNulls(0)
}
@@ -99,7 +102,8 @@
// READ_EXTERNAL_STORAGE will also be included if we specify WRITE_EXTERNAL_STORAGE
// requirement in AndroidManifest.xml. Therefore, also need to skip the permission check
// of READ_EXTERNAL_STORAGE.
- for (permission in info.requestedPermissions) {
+ val requestedPermissions = info.requestedPermissions as Array<out Any>
+ for (permission in requestedPermissions) {
if (
Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU &&
(Manifest.permission.WRITE_EXTERNAL_STORAGE == permission ||
@@ -108,7 +112,7 @@
continue
}
- requiredPermissions.add(permission)
+ requiredPermissions.add(permission.toString())
}
val permissions = requiredPermissions.toTypedArray<String?>()
diff --git a/camera/integration-tests/testingtestapp/build.gradle.kts b/camera/integration-tests/testingtestapp/build.gradle.kts
index e2c430a..3fbaddf 100644
--- a/camera/integration-tests/testingtestapp/build.gradle.kts
+++ b/camera/integration-tests/testingtestapp/build.gradle.kts
@@ -24,6 +24,8 @@
}
android {
+ compileSdk = 35
+
namespace = "androidx.camera.integration.testingtestapp"
defaultConfig {
diff --git a/camera/integration-tests/testingtestapp/src/main/java/androidx/camera/integration/testingtestapp/ui/theme/Theme.kt b/camera/integration-tests/testingtestapp/src/main/java/androidx/camera/integration/testingtestapp/ui/theme/Theme.kt
index 933cedc..44a8f40 100644
--- a/camera/integration-tests/testingtestapp/src/main/java/androidx/camera/integration/testingtestapp/ui/theme/Theme.kt
+++ b/camera/integration-tests/testingtestapp/src/main/java/androidx/camera/integration/testingtestapp/ui/theme/Theme.kt
@@ -50,6 +50,7 @@
*/
)
+@Suppress("DEPRECATION") // setStatusBarColor
@Composable
fun MultimoduleTemplateTheme(
darkTheme: Boolean = isSystemInDarkTheme(),
diff --git a/camera/integration-tests/timingtestapp/build.gradle b/camera/integration-tests/timingtestapp/build.gradle
index 43c8180..896b44b 100644
--- a/camera/integration-tests/timingtestapp/build.gradle
+++ b/camera/integration-tests/timingtestapp/build.gradle
@@ -21,6 +21,8 @@
}
android {
+ compileSdk 35
+
defaultConfig {
applicationId = "androidx.camera.integration.antelope"
versionCode 35
diff --git a/camera/integration-tests/timingtestapp/src/main/java/androidx/camera/integration/antelope/TestUtils.kt b/camera/integration-tests/timingtestapp/src/main/java/androidx/camera/integration/antelope/TestUtils.kt
index 0f01e34..af82a97 100644
--- a/camera/integration-tests/timingtestapp/src/main/java/androidx/camera/integration/antelope/TestUtils.kt
+++ b/camera/integration-tests/timingtestapp/src/main/java/androidx/camera/integration/antelope/TestUtils.kt
@@ -776,7 +776,7 @@
/** Return the version name of the Activity */
@Suppress("DEPRECATION")
-fun getVersionName(activity: MainActivity): String {
+fun getVersionName(activity: MainActivity): String? {
val packageInfo = activity.packageManager.getPackageInfo(activity.packageName, 0)
return packageInfo.versionName
}
diff --git a/camera/viewfinder/viewfinder-core/samples/build.gradle b/camera/viewfinder/viewfinder-core/samples/build.gradle
index 0baad03..4f7cd42 100644
--- a/camera/viewfinder/viewfinder-core/samples/build.gradle
+++ b/camera/viewfinder/viewfinder-core/samples/build.gradle
@@ -38,6 +38,7 @@
}
android {
+ compileSdk 35
namespace = "androidx.camera.viewfinder.core.samples"
}
diff --git a/car/app/app-samples/navigation/automotive/src/main/AndroidManifest.xml b/car/app/app-samples/navigation/automotive/src/main/AndroidManifest.xml
index 6678151..cd78f4d 100644
--- a/car/app/app-samples/navigation/automotive/src/main/AndroidManifest.xml
+++ b/car/app/app-samples/navigation/automotive/src/main/AndroidManifest.xml
@@ -58,7 +58,6 @@
<service
android:name="androidx.car.app.sample.navigation.common.car.NavigationCarAppService"
- android:foregroundServiceType="location"
android:exported="true">
<intent-filter>
diff --git a/car/app/app-samples/navigation/common/src/main/java/androidx/car/app/sample/navigation/common/car/ClusterSession.java b/car/app/app-samples/navigation/common/src/main/java/androidx/car/app/sample/navigation/common/car/ClusterSession.java
new file mode 100644
index 0000000..b6ac766
--- /dev/null
+++ b/car/app/app-samples/navigation/common/src/main/java/androidx/car/app/sample/navigation/common/car/ClusterSession.java
@@ -0,0 +1,110 @@
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.car.app.sample.navigation.common.car;
+
+import android.content.Intent;
+import android.content.res.Configuration;
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.car.app.CarContext;
+import androidx.car.app.CarToast;
+import androidx.car.app.Screen;
+import androidx.car.app.ScreenManager;
+import androidx.car.app.Session;
+import androidx.car.app.model.Action;
+import androidx.car.app.model.CarIcon;
+import androidx.car.app.sample.navigation.common.R;
+import androidx.car.app.sample.navigation.common.model.Instruction;
+import androidx.car.app.sample.navigation.common.nav.NavigationService;
+import androidx.core.graphics.drawable.IconCompat;
+
+import java.util.List;
+
+/** Session class for the Navigation sample app. */
+class ClusterSession extends Session implements NavigationScreen.Listener {
+ static final String TAG = ClusterSession.class.getSimpleName();
+
+ @Nullable
+ NavigationScreen mNavigationScreen;
+
+ @Nullable
+ SurfaceRenderer mNavigationCarSurface;
+
+ // A reference to the navigation service used to get location updates and routing.
+ @Nullable
+ NavigationService mService;
+
+ @NonNull
+ Action mSettingsAction;
+
+ @Override
+ @NonNull
+ public Screen onCreateScreen(@NonNull Intent intent) {
+ Log.i(TAG, "In onCreateScreen()");
+
+ mSettingsAction =
+ new Action.Builder()
+ .setIcon(
+ new CarIcon.Builder(
+ IconCompat.createWithResource(
+ getCarContext(), R.drawable.ic_settings))
+ .build())
+ .setOnClickListener(
+ () -> {
+ getCarContext()
+ .getCarService(ScreenManager.class)
+ .push(new SettingsScreen(getCarContext()));
+ })
+ .build();
+
+ mNavigationCarSurface = new SurfaceRenderer(getCarContext(), getLifecycle());
+ mNavigationScreen =
+ new NavigationScreen(getCarContext(), mSettingsAction, this, mNavigationCarSurface);
+
+ String action = intent.getAction();
+ if (action != null && CarContext.ACTION_NAVIGATE.equals(action)) {
+ CarToast.makeText(
+ getCarContext(),
+ "Navigation intent: " + intent.getDataString(),
+ CarToast.LENGTH_LONG)
+ .show();
+ }
+
+ return mNavigationScreen;
+ }
+
+ @Override
+ public void onCarConfigurationChanged(@NonNull Configuration newConfiguration) {
+ mNavigationCarSurface.onCarConfigurationChanged();
+ }
+
+ @Override
+ public void executeScript(@NonNull List<Instruction> instructions) {
+ if (mService != null) {
+ mService.executeInstructions(instructions);
+ }
+ }
+
+ @Override
+ public void stopNavigation() {
+ if (mService != null) {
+ mService.stopNavigation();
+ }
+ }
+}
diff --git a/car/app/app-samples/navigation/common/src/main/java/androidx/car/app/sample/navigation/common/car/NavigationCarAppService.java b/car/app/app-samples/navigation/common/src/main/java/androidx/car/app/sample/navigation/common/car/NavigationCarAppService.java
index 0b88d64..2951eb8 100644
--- a/car/app/app-samples/navigation/common/src/main/java/androidx/car/app/sample/navigation/common/car/NavigationCarAppService.java
+++ b/car/app/app-samples/navigation/common/src/main/java/androidx/car/app/sample/navigation/common/car/NavigationCarAppService.java
@@ -16,11 +16,9 @@
package androidx.car.app.sample.navigation.common.car;
-import android.app.Notification;
import android.app.NotificationChannel;
import android.app.NotificationManager;
import android.content.pm.ApplicationInfo;
-import android.content.pm.ServiceInfo;
import android.net.Uri;
import android.os.Build;
@@ -28,11 +26,7 @@
import androidx.car.app.CarAppService;
import androidx.car.app.Session;
import androidx.car.app.SessionInfo;
-import androidx.car.app.sample.navigation.common.R;
import androidx.car.app.validation.HostValidator;
-import androidx.core.app.NotificationCompat;
-import androidx.lifecycle.DefaultLifecycleObserver;
-import androidx.lifecycle.LifecycleOwner;
/**
* Entry point for the templated app.
@@ -45,9 +39,6 @@
/** Navigation session channel id. */
public static final String CHANNEL_ID = "NavigationSessionChannel";
- /** The identifier for the notification displayed for the foreground service. */
- private static final int NOTIFICATION_ID = 97654321;
-
/** Create a deep link URL from the given deep link action. */
@NonNull
public static Uri createDeepLinkUri(@NonNull String deepLinkAction) {
@@ -59,36 +50,12 @@
@Override
@NonNull
public Session onCreateSession(@NonNull SessionInfo sessionInfo) {
- createNotificationChannel();
-
- // Turn the car app service into a foreground service in order to make sure we can use all
- // granted "while-in-use" permissions (e.g. location) in the app's process.
- // The "while-in-use" location permission is granted as long as there is a foreground
- // service running in a process in which location access takes place. Here, we set this
- // service, and not NavigationService (which runs only during navigation), as a
- // foreground service because we need location access even when not navigating. If
- // location access is needed only during navigation, we can set NavigationService as a
- // foreground service instead.
- // See https://developer.android.com/reference/com/google/android/libraries/car/app
- // /CarAppService#accessing-location for more details.
- if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
- startForeground(NOTIFICATION_ID, getNotification(),
- ServiceInfo.FOREGROUND_SERVICE_TYPE_LOCATION);
+ if (sessionInfo.getDisplayType() == SessionInfo.DISPLAY_TYPE_CLUSTER) {
+ return new ClusterSession();
} else {
- startForeground(NOTIFICATION_ID, getNotification());
+ createNotificationChannel();
+ return new NavigationSession();
}
-
- NavigationSession session = new NavigationSession(sessionInfo);
- session.getLifecycle()
- .addObserver(
- new DefaultLifecycleObserver() {
- @Override
- public void onDestroy(@NonNull LifecycleOwner owner) {
- stopForeground(true);
- }
- });
-
- return session;
}
@NonNull
@@ -112,19 +79,4 @@
notificationManager.createNotificationChannel(serviceChannel);
}
}
-
- /** Returns the {@link NotificationCompat} used as part of the foreground service. */
- private Notification getNotification() {
- NotificationCompat.Builder builder =
- new NotificationCompat.Builder(this, CHANNEL_ID)
- .setContentTitle("Navigation App")
- .setContentText("App is running")
- .setSmallIcon(R.drawable.ic_launcher);
-
- if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
- builder.setChannelId(CHANNEL_ID);
- builder.setPriority(NotificationManager.IMPORTANCE_HIGH);
- }
- return builder.build();
- }
}
diff --git a/car/app/app-samples/navigation/common/src/main/java/androidx/car/app/sample/navigation/common/car/NavigationSession.java b/car/app/app-samples/navigation/common/src/main/java/androidx/car/app/sample/navigation/common/car/NavigationSession.java
index 7dc4b57..a67d1c7 100644
--- a/car/app/app-samples/navigation/common/src/main/java/androidx/car/app/sample/navigation/common/car/NavigationSession.java
+++ b/car/app/app-samples/navigation/common/src/main/java/androidx/car/app/sample/navigation/common/car/NavigationSession.java
@@ -1,5 +1,5 @@
/*
- * Copyright (C) 2021 The Android Open Source Project
+ * Copyright (C) 2025 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
@@ -37,7 +37,6 @@
import androidx.car.app.Screen;
import androidx.car.app.ScreenManager;
import androidx.car.app.Session;
-import androidx.car.app.SessionInfo;
import androidx.car.app.model.Action;
import androidx.car.app.model.CarIcon;
import androidx.car.app.model.Distance;
@@ -178,11 +177,9 @@
}
};
- NavigationSession(@NonNull SessionInfo sessionInfo) {
- if (sessionInfo.getDisplayType() == SessionInfo.DISPLAY_TYPE_MAIN) {
+ NavigationSession() {
Lifecycle lifecycle = getLifecycle();
lifecycle.addObserver(mLifeCycleObserver);
- }
}
@Override
diff --git a/car/app/app-samples/navigation/mobile/src/main/AndroidManifest.xml b/car/app/app-samples/navigation/mobile/src/main/AndroidManifest.xml
index 9ccbefa..26d1712 100644
--- a/car/app/app-samples/navigation/mobile/src/main/AndroidManifest.xml
+++ b/car/app/app-samples/navigation/mobile/src/main/AndroidManifest.xml
@@ -50,7 +50,6 @@
<service
android:name="androidx.car.app.sample.navigation.common.car.NavigationCarAppService"
- android:foregroundServiceType="location"
android:exported="true">
<intent-filter>
diff --git a/collection/collection-ktx/api/1.5.0-beta02.txt b/collection/collection-ktx/api/1.5.0-beta02.txt
new file mode 100644
index 0000000..e6f50d0
--- /dev/null
+++ b/collection/collection-ktx/api/1.5.0-beta02.txt
@@ -0,0 +1 @@
+// Signature format: 4.0
diff --git a/collection/collection-ktx/api/restricted_1.5.0-beta02.txt b/collection/collection-ktx/api/restricted_1.5.0-beta02.txt
new file mode 100644
index 0000000..e6f50d0
--- /dev/null
+++ b/collection/collection-ktx/api/restricted_1.5.0-beta02.txt
@@ -0,0 +1 @@
+// Signature format: 4.0
diff --git a/collection/collection/api/1.5.0-beta02.txt b/collection/collection/api/1.5.0-beta02.txt
new file mode 100644
index 0000000..1594610
--- /dev/null
+++ b/collection/collection/api/1.5.0-beta02.txt
@@ -0,0 +1,2394 @@
+// Signature format: 4.0
+package androidx.collection {
+
+ public class ArrayMap<K, V> extends androidx.collection.SimpleArrayMap<K!,V!> implements java.util.Map<K!,V!> {
+ ctor public ArrayMap();
+ ctor public ArrayMap(androidx.collection.SimpleArrayMap?);
+ ctor public ArrayMap(int);
+ method public boolean containsAll(java.util.Collection<? extends java.lang.Object!>);
+ method public boolean containsKey(Object?);
+ method public boolean containsValue(Object?);
+ method public java.util.Set<java.util.Map.Entry<K!,V!>!> entrySet();
+ method public V! get(Object?);
+ method public java.util.Set<K!> keySet();
+ method public void putAll(java.util.Map<? extends K!,? extends V!>);
+ method public V! remove(Object?);
+ method public boolean removeAll(java.util.Collection<? extends java.lang.Object!>);
+ method public boolean retainAll(java.util.Collection<? extends java.lang.Object!>);
+ method public java.util.Collection<V!> values();
+ }
+
+ public final class ArrayMapKt {
+ method public static inline <K, V> androidx.collection.ArrayMap<K,V> arrayMapOf();
+ method public static <K, V> androidx.collection.ArrayMap<K,V> arrayMapOf(kotlin.Pair<? extends K,? extends V>... pairs);
+ }
+
+ public final class ArraySet<E> implements java.util.Collection<E> kotlin.jvm.internal.markers.KMutableCollection kotlin.jvm.internal.markers.KMutableSet java.util.Set<E> {
+ ctor public ArraySet();
+ ctor public ArraySet(androidx.collection.ArraySet<? extends E>? set);
+ ctor public ArraySet(E[]? array);
+ ctor public ArraySet(optional int capacity);
+ ctor public ArraySet(java.util.Collection<? extends E>? set);
+ method public boolean add(E element);
+ method public void addAll(androidx.collection.ArraySet<? extends E> array);
+ method public boolean addAll(java.util.Collection<? extends E> elements);
+ method public void clear();
+ method public operator boolean contains(E element);
+ method public boolean containsAll(java.util.Collection<? extends E> elements);
+ method public void ensureCapacity(int minimumCapacity);
+ method public int getSize();
+ method public int indexOf(Object? key);
+ method public boolean isEmpty();
+ method public java.util.Iterator<E> iterator();
+ method public boolean remove(E element);
+ method public boolean removeAll(androidx.collection.ArraySet<? extends E> array);
+ method public boolean removeAll(java.util.Collection<? extends E> elements);
+ method public E removeAt(int index);
+ method public boolean retainAll(java.util.Collection<? extends E> elements);
+ method public Object?[] toArray();
+ method public <T> T[] toArray(T[] array);
+ method public E valueAt(int index);
+ property public int size;
+ }
+
+ public final class ArraySetKt {
+ method public static inline <T> androidx.collection.ArraySet<T> arraySetOf();
+ method public static <T> androidx.collection.ArraySet<T> arraySetOf(T... values);
+ }
+
+ public final class CircularArray<E> {
+ ctor public CircularArray();
+ ctor public CircularArray(optional int minCapacity);
+ method public void addFirst(E element);
+ method public void addLast(E element);
+ method public void clear();
+ method public operator E get(int index);
+ method public E getFirst();
+ method public E getLast();
+ method public boolean isEmpty();
+ method public E popFirst();
+ method public E popLast();
+ method public void removeFromEnd(int count);
+ method public void removeFromStart(int count);
+ method public int size();
+ property public final E first;
+ property public final E last;
+ }
+
+ public final class CircularIntArray {
+ ctor public CircularIntArray();
+ ctor public CircularIntArray(optional int minCapacity);
+ method public void addFirst(int element);
+ method public void addLast(int element);
+ method public void clear();
+ method public operator int get(int index);
+ method public int getFirst();
+ method public int getLast();
+ method public boolean isEmpty();
+ method public int popFirst();
+ method public int popLast();
+ method public void removeFromEnd(int count);
+ method public void removeFromStart(int count);
+ method public int size();
+ property public final int first;
+ property public final int last;
+ }
+
+ public abstract sealed class DoubleList {
+ method public final inline boolean any();
+ method public final inline boolean any(kotlin.jvm.functions.Function1<? super java.lang.Double,java.lang.Boolean> predicate);
+ method public final int binarySearch(int element);
+ method public final int binarySearch(int element, optional int fromIndex);
+ method public final int binarySearch(int element, optional int fromIndex, optional int toIndex);
+ method public final operator boolean contains(double element);
+ method public final boolean containsAll(androidx.collection.DoubleList elements);
+ method public final inline int count();
+ method public final inline int count(kotlin.jvm.functions.Function1<? super java.lang.Double,java.lang.Boolean> predicate);
+ method public final double elementAt(@IntRange(from=0L) int index);
+ method public final inline double elementAtOrElse(@IntRange(from=0L) int index, kotlin.jvm.functions.Function1<? super java.lang.Integer,java.lang.Double> defaultValue);
+ method public final double first();
+ method public final inline double first(kotlin.jvm.functions.Function1<? super java.lang.Double,java.lang.Boolean> predicate);
+ method public final inline <R> R fold(R initial, kotlin.jvm.functions.Function2<? super R,? super java.lang.Double,? extends R> operation);
+ method public final inline <R> R foldIndexed(R initial, kotlin.jvm.functions.Function3<? super java.lang.Integer,? super R,? super java.lang.Double,? extends R> operation);
+ method public final inline <R> R foldRight(R initial, kotlin.jvm.functions.Function2<? super java.lang.Double,? super R,? extends R> operation);
+ method public final inline <R> R foldRightIndexed(R initial, kotlin.jvm.functions.Function3<? super java.lang.Integer,? super java.lang.Double,? super R,? extends R> operation);
+ method public final inline void forEach(kotlin.jvm.functions.Function1<? super java.lang.Double,kotlin.Unit> block);
+ method public final inline void forEachIndexed(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Double,kotlin.Unit> block);
+ method public final inline void forEachReversed(kotlin.jvm.functions.Function1<? super java.lang.Double,kotlin.Unit> block);
+ method public final inline void forEachReversedIndexed(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Double,kotlin.Unit> block);
+ method public final operator double get(@IntRange(from=0L) int index);
+ method public final inline kotlin.ranges.IntRange getIndices();
+ method @IntRange(from=-1L) public final inline int getLastIndex();
+ method @IntRange(from=0L) public final inline int getSize();
+ method public final int indexOf(double element);
+ method public final inline int indexOfFirst(kotlin.jvm.functions.Function1<? super java.lang.Double,java.lang.Boolean> predicate);
+ method public final inline int indexOfLast(kotlin.jvm.functions.Function1<? super java.lang.Double,java.lang.Boolean> predicate);
+ method public final inline boolean isEmpty();
+ method public final inline boolean isNotEmpty();
+ method public final String joinToString();
+ method public final String joinToString(optional CharSequence separator);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function1<? super java.lang.Double,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function1<? super java.lang.Double,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function1<? super java.lang.Double,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function1<? super java.lang.Double,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function1<? super java.lang.Double,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(kotlin.jvm.functions.Function1<? super java.lang.Double,? extends java.lang.CharSequence> transform);
+ method public final double last();
+ method public final inline double last(kotlin.jvm.functions.Function1<? super java.lang.Double,java.lang.Boolean> predicate);
+ method public final int lastIndexOf(double element);
+ method public final inline boolean none();
+ method public final inline boolean reversedAny(kotlin.jvm.functions.Function1<? super java.lang.Double,java.lang.Boolean> predicate);
+ property public final inline kotlin.ranges.IntRange indices;
+ property @IntRange(from=-1L) public final inline int lastIndex;
+ property @IntRange(from=0L) public final inline int size;
+ }
+
+ public final class DoubleListKt {
+ method public static inline androidx.collection.DoubleList buildDoubleList(int initialCapacity, kotlin.jvm.functions.Function1<? super androidx.collection.MutableDoubleList,kotlin.Unit> builderAction);
+ method public static inline androidx.collection.DoubleList buildDoubleList(kotlin.jvm.functions.Function1<? super androidx.collection.MutableDoubleList,kotlin.Unit> builderAction);
+ method public static androidx.collection.DoubleList doubleListOf();
+ method public static androidx.collection.DoubleList doubleListOf(double element1);
+ method public static androidx.collection.DoubleList doubleListOf(double element1, double element2);
+ method public static androidx.collection.DoubleList doubleListOf(double element1, double element2, double element3);
+ method public static androidx.collection.DoubleList doubleListOf(double... elements);
+ method public static androidx.collection.DoubleList emptyDoubleList();
+ method public static inline androidx.collection.MutableDoubleList mutableDoubleListOf();
+ method public static androidx.collection.MutableDoubleList mutableDoubleListOf(double element1);
+ method public static androidx.collection.MutableDoubleList mutableDoubleListOf(double element1, double element2);
+ method public static androidx.collection.MutableDoubleList mutableDoubleListOf(double element1, double element2, double element3);
+ method public static inline androidx.collection.MutableDoubleList mutableDoubleListOf(double... elements);
+ }
+
+ public abstract sealed class FloatFloatMap {
+ method public final inline boolean all(kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Float,java.lang.Boolean> predicate);
+ method public final boolean any();
+ method public final inline boolean any(kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Float,java.lang.Boolean> predicate);
+ method public final inline operator boolean contains(float key);
+ method public final boolean containsKey(float key);
+ method public final boolean containsValue(float value);
+ method public final int count();
+ method public final inline int count(kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Float,java.lang.Boolean> predicate);
+ method public final inline void forEach(kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Float,kotlin.Unit> block);
+ method public final inline void forEachKey(kotlin.jvm.functions.Function1<? super java.lang.Float,kotlin.Unit> block);
+ method public final inline void forEachValue(kotlin.jvm.functions.Function1<? super java.lang.Float,kotlin.Unit> block);
+ method public final operator float get(float key);
+ method public final int getCapacity();
+ method public final float getOrDefault(float key, float defaultValue);
+ method public final inline float getOrElse(float key, kotlin.jvm.functions.Function0<java.lang.Float> defaultValue);
+ method public final int getSize();
+ method public final boolean isEmpty();
+ method public final boolean isNotEmpty();
+ method public final String joinToString();
+ method public final String joinToString(optional CharSequence separator);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final boolean none();
+ property public final int capacity;
+ property public final int size;
+ }
+
+ public final class FloatFloatMapKt {
+ method public static inline androidx.collection.FloatFloatMap buildFloatFloatMap(int initialCapacity, kotlin.jvm.functions.Function1<? super androidx.collection.MutableFloatFloatMap,kotlin.Unit> builderAction);
+ method public static inline androidx.collection.FloatFloatMap buildFloatFloatMap(kotlin.jvm.functions.Function1<? super androidx.collection.MutableFloatFloatMap,kotlin.Unit> builderAction);
+ method public static androidx.collection.FloatFloatMap emptyFloatFloatMap();
+ method public static androidx.collection.FloatFloatMap floatFloatMapOf();
+ method public static androidx.collection.FloatFloatMap floatFloatMapOf(float key1, float value1);
+ method public static androidx.collection.FloatFloatMap floatFloatMapOf(float key1, float value1, float key2, float value2);
+ method public static androidx.collection.FloatFloatMap floatFloatMapOf(float key1, float value1, float key2, float value2, float key3, float value3);
+ method public static androidx.collection.FloatFloatMap floatFloatMapOf(float key1, float value1, float key2, float value2, float key3, float value3, float key4, float value4);
+ method public static androidx.collection.FloatFloatMap floatFloatMapOf(float key1, float value1, float key2, float value2, float key3, float value3, float key4, float value4, float key5, float value5);
+ method public static androidx.collection.MutableFloatFloatMap mutableFloatFloatMapOf();
+ method public static androidx.collection.MutableFloatFloatMap mutableFloatFloatMapOf(float key1, float value1);
+ method public static androidx.collection.MutableFloatFloatMap mutableFloatFloatMapOf(float key1, float value1, float key2, float value2);
+ method public static androidx.collection.MutableFloatFloatMap mutableFloatFloatMapOf(float key1, float value1, float key2, float value2, float key3, float value3);
+ method public static androidx.collection.MutableFloatFloatMap mutableFloatFloatMapOf(float key1, float value1, float key2, float value2, float key3, float value3, float key4, float value4);
+ method public static androidx.collection.MutableFloatFloatMap mutableFloatFloatMapOf(float key1, float value1, float key2, float value2, float key3, float value3, float key4, float value4, float key5, float value5);
+ }
+
+ @kotlin.jvm.JvmInline public final value class FloatFloatPair {
+ ctor public FloatFloatPair(float first, float second);
+ method public inline operator float component1();
+ method public inline operator float component2();
+ property public final inline float first;
+ property public final long packedValue;
+ property public final inline float second;
+ field public final long packedValue;
+ }
+
+ public abstract sealed class FloatIntMap {
+ method public final inline boolean all(kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Integer,java.lang.Boolean> predicate);
+ method public final boolean any();
+ method public final inline boolean any(kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Integer,java.lang.Boolean> predicate);
+ method public final inline operator boolean contains(float key);
+ method public final boolean containsKey(float key);
+ method public final boolean containsValue(int value);
+ method public final int count();
+ method public final inline int count(kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Integer,java.lang.Boolean> predicate);
+ method public final inline void forEach(kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Integer,kotlin.Unit> block);
+ method public final inline void forEachKey(kotlin.jvm.functions.Function1<? super java.lang.Float,kotlin.Unit> block);
+ method public final inline void forEachValue(kotlin.jvm.functions.Function1<? super java.lang.Integer,kotlin.Unit> block);
+ method public final operator int get(float key);
+ method public final int getCapacity();
+ method public final int getOrDefault(float key, int defaultValue);
+ method public final inline int getOrElse(float key, kotlin.jvm.functions.Function0<java.lang.Integer> defaultValue);
+ method public final int getSize();
+ method public final boolean isEmpty();
+ method public final boolean isNotEmpty();
+ method public final String joinToString();
+ method public final String joinToString(optional CharSequence separator);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final boolean none();
+ property public final int capacity;
+ property public final int size;
+ }
+
+ public final class FloatIntMapKt {
+ method public static inline androidx.collection.FloatIntMap buildFloatIntMap(int initialCapacity, kotlin.jvm.functions.Function1<? super androidx.collection.MutableFloatIntMap,kotlin.Unit> builderAction);
+ method public static inline androidx.collection.FloatIntMap buildFloatIntMap(kotlin.jvm.functions.Function1<? super androidx.collection.MutableFloatIntMap,kotlin.Unit> builderAction);
+ method public static androidx.collection.FloatIntMap emptyFloatIntMap();
+ method public static androidx.collection.FloatIntMap floatIntMapOf();
+ method public static androidx.collection.FloatIntMap floatIntMapOf(float key1, int value1);
+ method public static androidx.collection.FloatIntMap floatIntMapOf(float key1, int value1, float key2, int value2);
+ method public static androidx.collection.FloatIntMap floatIntMapOf(float key1, int value1, float key2, int value2, float key3, int value3);
+ method public static androidx.collection.FloatIntMap floatIntMapOf(float key1, int value1, float key2, int value2, float key3, int value3, float key4, int value4);
+ method public static androidx.collection.FloatIntMap floatIntMapOf(float key1, int value1, float key2, int value2, float key3, int value3, float key4, int value4, float key5, int value5);
+ method public static androidx.collection.MutableFloatIntMap mutableFloatIntMapOf();
+ method public static androidx.collection.MutableFloatIntMap mutableFloatIntMapOf(float key1, int value1);
+ method public static androidx.collection.MutableFloatIntMap mutableFloatIntMapOf(float key1, int value1, float key2, int value2);
+ method public static androidx.collection.MutableFloatIntMap mutableFloatIntMapOf(float key1, int value1, float key2, int value2, float key3, int value3);
+ method public static androidx.collection.MutableFloatIntMap mutableFloatIntMapOf(float key1, int value1, float key2, int value2, float key3, int value3, float key4, int value4);
+ method public static androidx.collection.MutableFloatIntMap mutableFloatIntMapOf(float key1, int value1, float key2, int value2, float key3, int value3, float key4, int value4, float key5, int value5);
+ }
+
+ public abstract sealed class FloatList {
+ method public final inline boolean any();
+ method public final inline boolean any(kotlin.jvm.functions.Function1<? super java.lang.Float,java.lang.Boolean> predicate);
+ method public final int binarySearch(int element);
+ method public final int binarySearch(int element, optional int fromIndex);
+ method public final int binarySearch(int element, optional int fromIndex, optional int toIndex);
+ method public final operator boolean contains(float element);
+ method public final boolean containsAll(androidx.collection.FloatList elements);
+ method public final inline int count();
+ method public final inline int count(kotlin.jvm.functions.Function1<? super java.lang.Float,java.lang.Boolean> predicate);
+ method public final float elementAt(@IntRange(from=0L) int index);
+ method public final inline float elementAtOrElse(@IntRange(from=0L) int index, kotlin.jvm.functions.Function1<? super java.lang.Integer,java.lang.Float> defaultValue);
+ method public final float first();
+ method public final inline float first(kotlin.jvm.functions.Function1<? super java.lang.Float,java.lang.Boolean> predicate);
+ method public final inline <R> R fold(R initial, kotlin.jvm.functions.Function2<? super R,? super java.lang.Float,? extends R> operation);
+ method public final inline <R> R foldIndexed(R initial, kotlin.jvm.functions.Function3<? super java.lang.Integer,? super R,? super java.lang.Float,? extends R> operation);
+ method public final inline <R> R foldRight(R initial, kotlin.jvm.functions.Function2<? super java.lang.Float,? super R,? extends R> operation);
+ method public final inline <R> R foldRightIndexed(R initial, kotlin.jvm.functions.Function3<? super java.lang.Integer,? super java.lang.Float,? super R,? extends R> operation);
+ method public final inline void forEach(kotlin.jvm.functions.Function1<? super java.lang.Float,kotlin.Unit> block);
+ method public final inline void forEachIndexed(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Float,kotlin.Unit> block);
+ method public final inline void forEachReversed(kotlin.jvm.functions.Function1<? super java.lang.Float,kotlin.Unit> block);
+ method public final inline void forEachReversedIndexed(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Float,kotlin.Unit> block);
+ method public final operator float get(@IntRange(from=0L) int index);
+ method public final inline kotlin.ranges.IntRange getIndices();
+ method @IntRange(from=-1L) public final inline int getLastIndex();
+ method @IntRange(from=0L) public final inline int getSize();
+ method public final int indexOf(float element);
+ method public final inline int indexOfFirst(kotlin.jvm.functions.Function1<? super java.lang.Float,java.lang.Boolean> predicate);
+ method public final inline int indexOfLast(kotlin.jvm.functions.Function1<? super java.lang.Float,java.lang.Boolean> predicate);
+ method public final inline boolean isEmpty();
+ method public final inline boolean isNotEmpty();
+ method public final String joinToString();
+ method public final String joinToString(optional CharSequence separator);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function1<? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function1<? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function1<? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function1<? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function1<? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(kotlin.jvm.functions.Function1<? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final float last();
+ method public final inline float last(kotlin.jvm.functions.Function1<? super java.lang.Float,java.lang.Boolean> predicate);
+ method public final int lastIndexOf(float element);
+ method public final inline boolean none();
+ method public final inline boolean reversedAny(kotlin.jvm.functions.Function1<? super java.lang.Float,java.lang.Boolean> predicate);
+ property public final inline kotlin.ranges.IntRange indices;
+ property @IntRange(from=-1L) public final inline int lastIndex;
+ property @IntRange(from=0L) public final inline int size;
+ }
+
+ public final class FloatListKt {
+ method public static inline androidx.collection.FloatList buildFloatList(int initialCapacity, kotlin.jvm.functions.Function1<? super androidx.collection.MutableFloatList,kotlin.Unit> builderAction);
+ method public static inline androidx.collection.FloatList buildFloatList(kotlin.jvm.functions.Function1<? super androidx.collection.MutableFloatList,kotlin.Unit> builderAction);
+ method public static androidx.collection.FloatList emptyFloatList();
+ method public static androidx.collection.FloatList floatListOf();
+ method public static androidx.collection.FloatList floatListOf(float element1);
+ method public static androidx.collection.FloatList floatListOf(float element1, float element2);
+ method public static androidx.collection.FloatList floatListOf(float element1, float element2, float element3);
+ method public static androidx.collection.FloatList floatListOf(float... elements);
+ method public static inline androidx.collection.MutableFloatList mutableFloatListOf();
+ method public static androidx.collection.MutableFloatList mutableFloatListOf(float element1);
+ method public static androidx.collection.MutableFloatList mutableFloatListOf(float element1, float element2);
+ method public static androidx.collection.MutableFloatList mutableFloatListOf(float element1, float element2, float element3);
+ method public static inline androidx.collection.MutableFloatList mutableFloatListOf(float... elements);
+ }
+
+ public abstract sealed class FloatLongMap {
+ method public final inline boolean all(kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Long,java.lang.Boolean> predicate);
+ method public final boolean any();
+ method public final inline boolean any(kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Long,java.lang.Boolean> predicate);
+ method public final inline operator boolean contains(float key);
+ method public final boolean containsKey(float key);
+ method public final boolean containsValue(long value);
+ method public final int count();
+ method public final inline int count(kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Long,java.lang.Boolean> predicate);
+ method public final inline void forEach(kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Long,kotlin.Unit> block);
+ method public final inline void forEachKey(kotlin.jvm.functions.Function1<? super java.lang.Float,kotlin.Unit> block);
+ method public final inline void forEachValue(kotlin.jvm.functions.Function1<? super java.lang.Long,kotlin.Unit> block);
+ method public final operator long get(float key);
+ method public final int getCapacity();
+ method public final long getOrDefault(float key, long defaultValue);
+ method public final inline long getOrElse(float key, kotlin.jvm.functions.Function0<java.lang.Long> defaultValue);
+ method public final int getSize();
+ method public final boolean isEmpty();
+ method public final boolean isNotEmpty();
+ method public final String joinToString();
+ method public final String joinToString(optional CharSequence separator);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final boolean none();
+ property public final int capacity;
+ property public final int size;
+ }
+
+ public final class FloatLongMapKt {
+ method public static inline androidx.collection.FloatLongMap buildFloatLongMap(int initialCapacity, kotlin.jvm.functions.Function1<? super androidx.collection.MutableFloatLongMap,kotlin.Unit> builderAction);
+ method public static inline androidx.collection.FloatLongMap buildFloatLongMap(kotlin.jvm.functions.Function1<? super androidx.collection.MutableFloatLongMap,kotlin.Unit> builderAction);
+ method public static androidx.collection.FloatLongMap emptyFloatLongMap();
+ method public static androidx.collection.FloatLongMap floatLongMapOf();
+ method public static androidx.collection.FloatLongMap floatLongMapOf(float key1, long value1);
+ method public static androidx.collection.FloatLongMap floatLongMapOf(float key1, long value1, float key2, long value2);
+ method public static androidx.collection.FloatLongMap floatLongMapOf(float key1, long value1, float key2, long value2, float key3, long value3);
+ method public static androidx.collection.FloatLongMap floatLongMapOf(float key1, long value1, float key2, long value2, float key3, long value3, float key4, long value4);
+ method public static androidx.collection.FloatLongMap floatLongMapOf(float key1, long value1, float key2, long value2, float key3, long value3, float key4, long value4, float key5, long value5);
+ method public static androidx.collection.MutableFloatLongMap mutableFloatLongMapOf();
+ method public static androidx.collection.MutableFloatLongMap mutableFloatLongMapOf(float key1, long value1);
+ method public static androidx.collection.MutableFloatLongMap mutableFloatLongMapOf(float key1, long value1, float key2, long value2);
+ method public static androidx.collection.MutableFloatLongMap mutableFloatLongMapOf(float key1, long value1, float key2, long value2, float key3, long value3);
+ method public static androidx.collection.MutableFloatLongMap mutableFloatLongMapOf(float key1, long value1, float key2, long value2, float key3, long value3, float key4, long value4);
+ method public static androidx.collection.MutableFloatLongMap mutableFloatLongMapOf(float key1, long value1, float key2, long value2, float key3, long value3, float key4, long value4, float key5, long value5);
+ }
+
+ public abstract sealed class FloatObjectMap<V> {
+ method public final inline boolean all(kotlin.jvm.functions.Function2<? super java.lang.Float,? super V,java.lang.Boolean> predicate);
+ method public final boolean any();
+ method public final inline boolean any(kotlin.jvm.functions.Function2<? super java.lang.Float,? super V,java.lang.Boolean> predicate);
+ method public final inline operator boolean contains(float key);
+ method public final boolean containsKey(float key);
+ method public final boolean containsValue(V value);
+ method public final int count();
+ method public final inline int count(kotlin.jvm.functions.Function2<? super java.lang.Float,? super V,java.lang.Boolean> predicate);
+ method public final inline void forEach(kotlin.jvm.functions.Function2<? super java.lang.Float,? super V,kotlin.Unit> block);
+ method public final inline void forEachKey(kotlin.jvm.functions.Function1<? super java.lang.Float,kotlin.Unit> block);
+ method public final inline void forEachValue(kotlin.jvm.functions.Function1<? super V,kotlin.Unit> block);
+ method public final operator V? get(float key);
+ method public final int getCapacity();
+ method public final V getOrDefault(float key, V defaultValue);
+ method public final inline V getOrElse(float key, kotlin.jvm.functions.Function0<? extends V> defaultValue);
+ method public final int getSize();
+ method public final boolean isEmpty();
+ method public final boolean isNotEmpty();
+ method public final String joinToString();
+ method public final String joinToString(optional CharSequence separator);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2<? super java.lang.Float,? super V,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2<? super java.lang.Float,? super V,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2<? super java.lang.Float,? super V,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2<? super java.lang.Float,? super V,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2<? super java.lang.Float,? super V,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(kotlin.jvm.functions.Function2<? super java.lang.Float,? super V,? extends java.lang.CharSequence> transform);
+ method public final boolean none();
+ property public final int capacity;
+ property public final int size;
+ }
+
+ public final class FloatObjectMapKt {
+ method public static inline <V> androidx.collection.FloatObjectMap<V> buildFloatObjectMap(int initialCapacity, kotlin.jvm.functions.Function1<? super androidx.collection.MutableFloatObjectMap<V>,kotlin.Unit> builderAction);
+ method public static inline <V> androidx.collection.FloatObjectMap<V> buildFloatObjectMap(kotlin.jvm.functions.Function1<? super androidx.collection.MutableFloatObjectMap<V>,kotlin.Unit> builderAction);
+ method public static <V> androidx.collection.FloatObjectMap<V> emptyFloatObjectMap();
+ method public static <V> androidx.collection.FloatObjectMap<V> floatObjectMapOf();
+ method public static <V> androidx.collection.FloatObjectMap<V> floatObjectMapOf(float key1, V value1);
+ method public static <V> androidx.collection.FloatObjectMap<V> floatObjectMapOf(float key1, V value1, float key2, V value2);
+ method public static <V> androidx.collection.FloatObjectMap<V> floatObjectMapOf(float key1, V value1, float key2, V value2, float key3, V value3);
+ method public static <V> androidx.collection.FloatObjectMap<V> floatObjectMapOf(float key1, V value1, float key2, V value2, float key3, V value3, float key4, V value4);
+ method public static <V> androidx.collection.FloatObjectMap<V> floatObjectMapOf(float key1, V value1, float key2, V value2, float key3, V value3, float key4, V value4, float key5, V value5);
+ method public static <V> androidx.collection.MutableFloatObjectMap<V> mutableFloatObjectMapOf();
+ method public static <V> androidx.collection.MutableFloatObjectMap<V> mutableFloatObjectMapOf(float key1, V value1);
+ method public static <V> androidx.collection.MutableFloatObjectMap<V> mutableFloatObjectMapOf(float key1, V value1, float key2, V value2);
+ method public static <V> androidx.collection.MutableFloatObjectMap<V> mutableFloatObjectMapOf(float key1, V value1, float key2, V value2, float key3, V value3);
+ method public static <V> androidx.collection.MutableFloatObjectMap<V> mutableFloatObjectMapOf(float key1, V value1, float key2, V value2, float key3, V value3, float key4, V value4);
+ method public static <V> androidx.collection.MutableFloatObjectMap<V> mutableFloatObjectMapOf(float key1, V value1, float key2, V value2, float key3, V value3, float key4, V value4, float key5, V value5);
+ }
+
+ public abstract sealed class FloatSet {
+ method public final inline boolean all(kotlin.jvm.functions.Function1<? super java.lang.Float,java.lang.Boolean> predicate);
+ method public final boolean any();
+ method public final inline boolean any(kotlin.jvm.functions.Function1<? super java.lang.Float,java.lang.Boolean> predicate);
+ method public final operator boolean contains(float element);
+ method @IntRange(from=0L) public final int count();
+ method @IntRange(from=0L) public final inline int count(kotlin.jvm.functions.Function1<? super java.lang.Float,java.lang.Boolean> predicate);
+ method public final inline float first();
+ method public final inline float first(kotlin.jvm.functions.Function1<? super java.lang.Float,java.lang.Boolean> predicate);
+ method public final inline void forEach(kotlin.jvm.functions.Function1<? super java.lang.Float,kotlin.Unit> block);
+ method @IntRange(from=0L) public final int getCapacity();
+ method @IntRange(from=0L) public final int getSize();
+ method public final boolean isEmpty();
+ method public final boolean isNotEmpty();
+ method public final String joinToString();
+ method public final String joinToString(optional CharSequence separator);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function1<? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function1<? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function1<? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function1<? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function1<? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(kotlin.jvm.functions.Function1<? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final boolean none();
+ property @IntRange(from=0L) public final int capacity;
+ property @IntRange(from=0L) public final int size;
+ }
+
+ public final class FloatSetKt {
+ method public static inline androidx.collection.FloatSet buildFloatSet(int initialCapacity, kotlin.jvm.functions.Function1<? super androidx.collection.MutableFloatSet,kotlin.Unit> builderAction);
+ method public static inline androidx.collection.FloatSet buildFloatSet(kotlin.jvm.functions.Function1<? super androidx.collection.MutableFloatSet,kotlin.Unit> builderAction);
+ method public static androidx.collection.FloatSet emptyFloatSet();
+ method public static androidx.collection.FloatSet floatSetOf();
+ method public static androidx.collection.FloatSet floatSetOf(float element1);
+ method public static androidx.collection.FloatSet floatSetOf(float element1, float element2);
+ method public static androidx.collection.FloatSet floatSetOf(float element1, float element2, float element3);
+ method public static androidx.collection.FloatSet floatSetOf(float... elements);
+ method public static androidx.collection.MutableFloatSet mutableFloatSetOf();
+ method public static androidx.collection.MutableFloatSet mutableFloatSetOf(float element1);
+ method public static androidx.collection.MutableFloatSet mutableFloatSetOf(float element1, float element2);
+ method public static androidx.collection.MutableFloatSet mutableFloatSetOf(float element1, float element2, float element3);
+ method public static androidx.collection.MutableFloatSet mutableFloatSetOf(float... elements);
+ }
+
+ public abstract sealed class IntFloatMap {
+ method public final inline boolean all(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Float,java.lang.Boolean> predicate);
+ method public final boolean any();
+ method public final inline boolean any(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Float,java.lang.Boolean> predicate);
+ method public final inline operator boolean contains(int key);
+ method public final boolean containsKey(int key);
+ method public final boolean containsValue(float value);
+ method public final int count();
+ method public final inline int count(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Float,java.lang.Boolean> predicate);
+ method public final inline void forEach(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Float,kotlin.Unit> block);
+ method public final inline void forEachKey(kotlin.jvm.functions.Function1<? super java.lang.Integer,kotlin.Unit> block);
+ method public final inline void forEachValue(kotlin.jvm.functions.Function1<? super java.lang.Float,kotlin.Unit> block);
+ method public final operator float get(int key);
+ method public final int getCapacity();
+ method public final float getOrDefault(int key, float defaultValue);
+ method public final inline float getOrElse(int key, kotlin.jvm.functions.Function0<java.lang.Float> defaultValue);
+ method public final int getSize();
+ method public final boolean isEmpty();
+ method public final boolean isNotEmpty();
+ method public final String joinToString();
+ method public final String joinToString(optional CharSequence separator);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final boolean none();
+ property public final int capacity;
+ property public final int size;
+ }
+
+ public final class IntFloatMapKt {
+ method public static inline androidx.collection.IntFloatMap buildIntFloatMap(int initialCapacity, kotlin.jvm.functions.Function1<? super androidx.collection.MutableIntFloatMap,kotlin.Unit> builderAction);
+ method public static inline androidx.collection.IntFloatMap buildIntFloatMap(kotlin.jvm.functions.Function1<? super androidx.collection.MutableIntFloatMap,kotlin.Unit> builderAction);
+ method public static androidx.collection.IntFloatMap emptyIntFloatMap();
+ method public static androidx.collection.IntFloatMap intFloatMapOf();
+ method public static androidx.collection.IntFloatMap intFloatMapOf(int key1, float value1);
+ method public static androidx.collection.IntFloatMap intFloatMapOf(int key1, float value1, int key2, float value2);
+ method public static androidx.collection.IntFloatMap intFloatMapOf(int key1, float value1, int key2, float value2, int key3, float value3);
+ method public static androidx.collection.IntFloatMap intFloatMapOf(int key1, float value1, int key2, float value2, int key3, float value3, int key4, float value4);
+ method public static androidx.collection.IntFloatMap intFloatMapOf(int key1, float value1, int key2, float value2, int key3, float value3, int key4, float value4, int key5, float value5);
+ method public static androidx.collection.MutableIntFloatMap mutableIntFloatMapOf();
+ method public static androidx.collection.MutableIntFloatMap mutableIntFloatMapOf(int key1, float value1);
+ method public static androidx.collection.MutableIntFloatMap mutableIntFloatMapOf(int key1, float value1, int key2, float value2);
+ method public static androidx.collection.MutableIntFloatMap mutableIntFloatMapOf(int key1, float value1, int key2, float value2, int key3, float value3);
+ method public static androidx.collection.MutableIntFloatMap mutableIntFloatMapOf(int key1, float value1, int key2, float value2, int key3, float value3, int key4, float value4);
+ method public static androidx.collection.MutableIntFloatMap mutableIntFloatMapOf(int key1, float value1, int key2, float value2, int key3, float value3, int key4, float value4, int key5, float value5);
+ }
+
+ public abstract sealed class IntIntMap {
+ method public final inline boolean all(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Integer,java.lang.Boolean> predicate);
+ method public final boolean any();
+ method public final inline boolean any(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Integer,java.lang.Boolean> predicate);
+ method public final inline operator boolean contains(int key);
+ method public final boolean containsKey(int key);
+ method public final boolean containsValue(int value);
+ method public final int count();
+ method public final inline int count(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Integer,java.lang.Boolean> predicate);
+ method public final inline void forEach(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Integer,kotlin.Unit> block);
+ method public final inline void forEachKey(kotlin.jvm.functions.Function1<? super java.lang.Integer,kotlin.Unit> block);
+ method public final inline void forEachValue(kotlin.jvm.functions.Function1<? super java.lang.Integer,kotlin.Unit> block);
+ method public final operator int get(int key);
+ method public final int getCapacity();
+ method public final int getOrDefault(int key, int defaultValue);
+ method public final inline int getOrElse(int key, kotlin.jvm.functions.Function0<java.lang.Integer> defaultValue);
+ method public final int getSize();
+ method public final boolean isEmpty();
+ method public final boolean isNotEmpty();
+ method public final String joinToString();
+ method public final String joinToString(optional CharSequence separator);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final boolean none();
+ property public final int capacity;
+ property public final int size;
+ }
+
+ public final class IntIntMapKt {
+ method public static inline androidx.collection.IntIntMap buildIntIntMap(int initialCapacity, kotlin.jvm.functions.Function1<? super androidx.collection.MutableIntIntMap,kotlin.Unit> builderAction);
+ method public static inline androidx.collection.IntIntMap buildIntIntMap(kotlin.jvm.functions.Function1<? super androidx.collection.MutableIntIntMap,kotlin.Unit> builderAction);
+ method public static androidx.collection.IntIntMap emptyIntIntMap();
+ method public static androidx.collection.IntIntMap intIntMapOf();
+ method public static androidx.collection.IntIntMap intIntMapOf(int key1, int value1);
+ method public static androidx.collection.IntIntMap intIntMapOf(int key1, int value1, int key2, int value2);
+ method public static androidx.collection.IntIntMap intIntMapOf(int key1, int value1, int key2, int value2, int key3, int value3);
+ method public static androidx.collection.IntIntMap intIntMapOf(int key1, int value1, int key2, int value2, int key3, int value3, int key4, int value4);
+ method public static androidx.collection.IntIntMap intIntMapOf(int key1, int value1, int key2, int value2, int key3, int value3, int key4, int value4, int key5, int value5);
+ method public static androidx.collection.MutableIntIntMap mutableIntIntMapOf();
+ method public static androidx.collection.MutableIntIntMap mutableIntIntMapOf(int key1, int value1);
+ method public static androidx.collection.MutableIntIntMap mutableIntIntMapOf(int key1, int value1, int key2, int value2);
+ method public static androidx.collection.MutableIntIntMap mutableIntIntMapOf(int key1, int value1, int key2, int value2, int key3, int value3);
+ method public static androidx.collection.MutableIntIntMap mutableIntIntMapOf(int key1, int value1, int key2, int value2, int key3, int value3, int key4, int value4);
+ method public static androidx.collection.MutableIntIntMap mutableIntIntMapOf(int key1, int value1, int key2, int value2, int key3, int value3, int key4, int value4, int key5, int value5);
+ }
+
+ @kotlin.jvm.JvmInline public final value class IntIntPair {
+ ctor public IntIntPair(int first, int second);
+ method public inline operator int component1();
+ method public inline operator int component2();
+ property public final int first;
+ property public final long packedValue;
+ property public final int second;
+ field public final long packedValue;
+ }
+
+ public abstract sealed class IntList {
+ method public final inline boolean any();
+ method public final inline boolean any(kotlin.jvm.functions.Function1<? super java.lang.Integer,java.lang.Boolean> predicate);
+ method public final int binarySearch(int element);
+ method public final int binarySearch(int element, optional int fromIndex);
+ method public final int binarySearch(int element, optional int fromIndex, optional int toIndex);
+ method public final operator boolean contains(int element);
+ method public final boolean containsAll(androidx.collection.IntList elements);
+ method public final inline int count();
+ method public final inline int count(kotlin.jvm.functions.Function1<? super java.lang.Integer,java.lang.Boolean> predicate);
+ method public final int elementAt(@IntRange(from=0L) int index);
+ method public final inline int elementAtOrElse(@IntRange(from=0L) int index, kotlin.jvm.functions.Function1<? super java.lang.Integer,java.lang.Integer> defaultValue);
+ method public final int first();
+ method public final inline int first(kotlin.jvm.functions.Function1<? super java.lang.Integer,java.lang.Boolean> predicate);
+ method public final inline <R> R fold(R initial, kotlin.jvm.functions.Function2<? super R,? super java.lang.Integer,? extends R> operation);
+ method public final inline <R> R foldIndexed(R initial, kotlin.jvm.functions.Function3<? super java.lang.Integer,? super R,? super java.lang.Integer,? extends R> operation);
+ method public final inline <R> R foldRight(R initial, kotlin.jvm.functions.Function2<? super java.lang.Integer,? super R,? extends R> operation);
+ method public final inline <R> R foldRightIndexed(R initial, kotlin.jvm.functions.Function3<? super java.lang.Integer,? super java.lang.Integer,? super R,? extends R> operation);
+ method public final inline void forEach(kotlin.jvm.functions.Function1<? super java.lang.Integer,kotlin.Unit> block);
+ method public final inline void forEachIndexed(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Integer,kotlin.Unit> block);
+ method public final inline void forEachReversed(kotlin.jvm.functions.Function1<? super java.lang.Integer,kotlin.Unit> block);
+ method public final inline void forEachReversedIndexed(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Integer,kotlin.Unit> block);
+ method public final operator int get(@IntRange(from=0L) int index);
+ method public final inline kotlin.ranges.IntRange getIndices();
+ method @IntRange(from=-1L) public final inline int getLastIndex();
+ method @IntRange(from=0L) public final inline int getSize();
+ method public final int indexOf(int element);
+ method public final inline int indexOfFirst(kotlin.jvm.functions.Function1<? super java.lang.Integer,java.lang.Boolean> predicate);
+ method public final inline int indexOfLast(kotlin.jvm.functions.Function1<? super java.lang.Integer,java.lang.Boolean> predicate);
+ method public final inline boolean isEmpty();
+ method public final inline boolean isNotEmpty();
+ method public final String joinToString();
+ method public final String joinToString(optional CharSequence separator);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function1<? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function1<? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function1<? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function1<? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function1<? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(kotlin.jvm.functions.Function1<? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final int last();
+ method public final inline int last(kotlin.jvm.functions.Function1<? super java.lang.Integer,java.lang.Boolean> predicate);
+ method public final int lastIndexOf(int element);
+ method public final inline boolean none();
+ method public final inline boolean reversedAny(kotlin.jvm.functions.Function1<? super java.lang.Integer,java.lang.Boolean> predicate);
+ property public final inline kotlin.ranges.IntRange indices;
+ property @IntRange(from=-1L) public final inline int lastIndex;
+ property @IntRange(from=0L) public final inline int size;
+ }
+
+ public final class IntListKt {
+ method public static inline androidx.collection.IntList buildIntList(int initialCapacity, kotlin.jvm.functions.Function1<? super androidx.collection.MutableIntList,kotlin.Unit> builderAction);
+ method public static inline androidx.collection.IntList buildIntList(kotlin.jvm.functions.Function1<? super androidx.collection.MutableIntList,kotlin.Unit> builderAction);
+ method public static androidx.collection.IntList emptyIntList();
+ method public static androidx.collection.IntList intListOf();
+ method public static androidx.collection.IntList intListOf(int element1);
+ method public static androidx.collection.IntList intListOf(int element1, int element2);
+ method public static androidx.collection.IntList intListOf(int element1, int element2, int element3);
+ method public static androidx.collection.IntList intListOf(int... elements);
+ method public static inline androidx.collection.MutableIntList mutableIntListOf();
+ method public static androidx.collection.MutableIntList mutableIntListOf(int element1);
+ method public static androidx.collection.MutableIntList mutableIntListOf(int element1, int element2);
+ method public static androidx.collection.MutableIntList mutableIntListOf(int element1, int element2, int element3);
+ method public static inline androidx.collection.MutableIntList mutableIntListOf(int... elements);
+ }
+
+ public abstract sealed class IntLongMap {
+ method public final inline boolean all(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Long,java.lang.Boolean> predicate);
+ method public final boolean any();
+ method public final inline boolean any(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Long,java.lang.Boolean> predicate);
+ method public final inline operator boolean contains(int key);
+ method public final boolean containsKey(int key);
+ method public final boolean containsValue(long value);
+ method public final int count();
+ method public final inline int count(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Long,java.lang.Boolean> predicate);
+ method public final inline void forEach(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Long,kotlin.Unit> block);
+ method public final inline void forEachKey(kotlin.jvm.functions.Function1<? super java.lang.Integer,kotlin.Unit> block);
+ method public final inline void forEachValue(kotlin.jvm.functions.Function1<? super java.lang.Long,kotlin.Unit> block);
+ method public final operator long get(int key);
+ method public final int getCapacity();
+ method public final long getOrDefault(int key, long defaultValue);
+ method public final inline long getOrElse(int key, kotlin.jvm.functions.Function0<java.lang.Long> defaultValue);
+ method public final int getSize();
+ method public final boolean isEmpty();
+ method public final boolean isNotEmpty();
+ method public final String joinToString();
+ method public final String joinToString(optional CharSequence separator);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final boolean none();
+ property public final int capacity;
+ property public final int size;
+ }
+
+ public final class IntLongMapKt {
+ method public static inline androidx.collection.IntLongMap buildIntLongMap(int initialCapacity, kotlin.jvm.functions.Function1<? super androidx.collection.MutableIntLongMap,kotlin.Unit> builderAction);
+ method public static inline androidx.collection.IntLongMap buildIntLongMap(kotlin.jvm.functions.Function1<? super androidx.collection.MutableIntLongMap,kotlin.Unit> builderAction);
+ method public static androidx.collection.IntLongMap emptyIntLongMap();
+ method public static androidx.collection.IntLongMap intLongMapOf();
+ method public static androidx.collection.IntLongMap intLongMapOf(int key1, long value1);
+ method public static androidx.collection.IntLongMap intLongMapOf(int key1, long value1, int key2, long value2);
+ method public static androidx.collection.IntLongMap intLongMapOf(int key1, long value1, int key2, long value2, int key3, long value3);
+ method public static androidx.collection.IntLongMap intLongMapOf(int key1, long value1, int key2, long value2, int key3, long value3, int key4, long value4);
+ method public static androidx.collection.IntLongMap intLongMapOf(int key1, long value1, int key2, long value2, int key3, long value3, int key4, long value4, int key5, long value5);
+ method public static androidx.collection.MutableIntLongMap mutableIntLongMapOf();
+ method public static androidx.collection.MutableIntLongMap mutableIntLongMapOf(int key1, long value1);
+ method public static androidx.collection.MutableIntLongMap mutableIntLongMapOf(int key1, long value1, int key2, long value2);
+ method public static androidx.collection.MutableIntLongMap mutableIntLongMapOf(int key1, long value1, int key2, long value2, int key3, long value3);
+ method public static androidx.collection.MutableIntLongMap mutableIntLongMapOf(int key1, long value1, int key2, long value2, int key3, long value3, int key4, long value4);
+ method public static androidx.collection.MutableIntLongMap mutableIntLongMapOf(int key1, long value1, int key2, long value2, int key3, long value3, int key4, long value4, int key5, long value5);
+ }
+
+ public abstract sealed class IntObjectMap<V> {
+ method public final inline boolean all(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super V,java.lang.Boolean> predicate);
+ method public final boolean any();
+ method public final inline boolean any(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super V,java.lang.Boolean> predicate);
+ method public final inline operator boolean contains(int key);
+ method public final boolean containsKey(int key);
+ method public final boolean containsValue(V value);
+ method public final int count();
+ method public final inline int count(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super V,java.lang.Boolean> predicate);
+ method public final inline void forEach(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super V,kotlin.Unit> block);
+ method public final inline void forEachKey(kotlin.jvm.functions.Function1<? super java.lang.Integer,kotlin.Unit> block);
+ method public final inline void forEachValue(kotlin.jvm.functions.Function1<? super V,kotlin.Unit> block);
+ method public final operator V? get(int key);
+ method public final int getCapacity();
+ method public final V getOrDefault(int key, V defaultValue);
+ method public final inline V getOrElse(int key, kotlin.jvm.functions.Function0<? extends V> defaultValue);
+ method public final int getSize();
+ method public final boolean isEmpty();
+ method public final boolean isNotEmpty();
+ method public final String joinToString();
+ method public final String joinToString(optional CharSequence separator);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2<? super java.lang.Integer,? super V,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2<? super java.lang.Integer,? super V,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2<? super java.lang.Integer,? super V,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2<? super java.lang.Integer,? super V,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2<? super java.lang.Integer,? super V,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super V,? extends java.lang.CharSequence> transform);
+ method public final boolean none();
+ property public final int capacity;
+ property public final int size;
+ }
+
+ public final class IntObjectMapKt {
+ method public static inline <V> androidx.collection.IntObjectMap<V> buildIntObjectMap(int initialCapacity, kotlin.jvm.functions.Function1<? super androidx.collection.MutableIntObjectMap<V>,kotlin.Unit> builderAction);
+ method public static inline <V> androidx.collection.IntObjectMap<V> buildIntObjectMap(kotlin.jvm.functions.Function1<? super androidx.collection.MutableIntObjectMap<V>,kotlin.Unit> builderAction);
+ method public static <V> androidx.collection.IntObjectMap<V> emptyIntObjectMap();
+ method public static <V> androidx.collection.IntObjectMap<V> intObjectMapOf();
+ method public static <V> androidx.collection.IntObjectMap<V> intObjectMapOf(int key1, V value1);
+ method public static <V> androidx.collection.IntObjectMap<V> intObjectMapOf(int key1, V value1, int key2, V value2);
+ method public static <V> androidx.collection.IntObjectMap<V> intObjectMapOf(int key1, V value1, int key2, V value2, int key3, V value3);
+ method public static <V> androidx.collection.IntObjectMap<V> intObjectMapOf(int key1, V value1, int key2, V value2, int key3, V value3, int key4, V value4);
+ method public static <V> androidx.collection.IntObjectMap<V> intObjectMapOf(int key1, V value1, int key2, V value2, int key3, V value3, int key4, V value4, int key5, V value5);
+ method public static <V> androidx.collection.MutableIntObjectMap<V> mutableIntObjectMapOf();
+ method public static <V> androidx.collection.MutableIntObjectMap<V> mutableIntObjectMapOf(int key1, V value1);
+ method public static <V> androidx.collection.MutableIntObjectMap<V> mutableIntObjectMapOf(int key1, V value1, int key2, V value2);
+ method public static <V> androidx.collection.MutableIntObjectMap<V> mutableIntObjectMapOf(int key1, V value1, int key2, V value2, int key3, V value3);
+ method public static <V> androidx.collection.MutableIntObjectMap<V> mutableIntObjectMapOf(int key1, V value1, int key2, V value2, int key3, V value3, int key4, V value4);
+ method public static <V> androidx.collection.MutableIntObjectMap<V> mutableIntObjectMapOf(int key1, V value1, int key2, V value2, int key3, V value3, int key4, V value4, int key5, V value5);
+ }
+
+ public abstract sealed class IntSet {
+ method public final inline boolean all(kotlin.jvm.functions.Function1<? super java.lang.Integer,java.lang.Boolean> predicate);
+ method public final boolean any();
+ method public final inline boolean any(kotlin.jvm.functions.Function1<? super java.lang.Integer,java.lang.Boolean> predicate);
+ method public final operator boolean contains(int element);
+ method @IntRange(from=0L) public final int count();
+ method @IntRange(from=0L) public final inline int count(kotlin.jvm.functions.Function1<? super java.lang.Integer,java.lang.Boolean> predicate);
+ method public final inline int first();
+ method public final inline int first(kotlin.jvm.functions.Function1<? super java.lang.Integer,java.lang.Boolean> predicate);
+ method public final inline void forEach(kotlin.jvm.functions.Function1<? super java.lang.Integer,kotlin.Unit> block);
+ method @IntRange(from=0L) public final int getCapacity();
+ method @IntRange(from=0L) public final int getSize();
+ method public final boolean isEmpty();
+ method public final boolean isNotEmpty();
+ method public final String joinToString();
+ method public final String joinToString(optional CharSequence separator);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function1<? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function1<? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function1<? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function1<? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function1<? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(kotlin.jvm.functions.Function1<? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final boolean none();
+ property @IntRange(from=0L) public final int capacity;
+ property @IntRange(from=0L) public final int size;
+ }
+
+ public final class IntSetKt {
+ method public static inline androidx.collection.IntSet buildIntSet(int initialCapacity, kotlin.jvm.functions.Function1<? super androidx.collection.MutableIntSet,kotlin.Unit> builderAction);
+ method public static inline androidx.collection.IntSet buildIntSet(kotlin.jvm.functions.Function1<? super androidx.collection.MutableIntSet,kotlin.Unit> builderAction);
+ method public static androidx.collection.IntSet emptyIntSet();
+ method public static androidx.collection.IntSet intSetOf();
+ method public static androidx.collection.IntSet intSetOf(int element1);
+ method public static androidx.collection.IntSet intSetOf(int element1, int element2);
+ method public static androidx.collection.IntSet intSetOf(int element1, int element2, int element3);
+ method public static androidx.collection.IntSet intSetOf(int... elements);
+ method public static androidx.collection.MutableIntSet mutableIntSetOf();
+ method public static androidx.collection.MutableIntSet mutableIntSetOf(int element1);
+ method public static androidx.collection.MutableIntSet mutableIntSetOf(int element1, int element2);
+ method public static androidx.collection.MutableIntSet mutableIntSetOf(int element1, int element2, int element3);
+ method public static androidx.collection.MutableIntSet mutableIntSetOf(int... elements);
+ }
+
+ public abstract sealed class LongFloatMap {
+ method public final inline boolean all(kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Float,java.lang.Boolean> predicate);
+ method public final boolean any();
+ method public final inline boolean any(kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Float,java.lang.Boolean> predicate);
+ method public final inline operator boolean contains(long key);
+ method public final boolean containsKey(long key);
+ method public final boolean containsValue(float value);
+ method public final int count();
+ method public final inline int count(kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Float,java.lang.Boolean> predicate);
+ method public final inline void forEach(kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Float,kotlin.Unit> block);
+ method public final inline void forEachKey(kotlin.jvm.functions.Function1<? super java.lang.Long,kotlin.Unit> block);
+ method public final inline void forEachValue(kotlin.jvm.functions.Function1<? super java.lang.Float,kotlin.Unit> block);
+ method public final operator float get(long key);
+ method public final int getCapacity();
+ method public final float getOrDefault(long key, float defaultValue);
+ method public final inline float getOrElse(long key, kotlin.jvm.functions.Function0<java.lang.Float> defaultValue);
+ method public final int getSize();
+ method public final boolean isEmpty();
+ method public final boolean isNotEmpty();
+ method public final String joinToString();
+ method public final String joinToString(optional CharSequence separator);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final boolean none();
+ property public final int capacity;
+ property public final int size;
+ }
+
+ public final class LongFloatMapKt {
+ method public static inline androidx.collection.LongFloatMap buildLongFloatMap(int initialCapacity, kotlin.jvm.functions.Function1<? super androidx.collection.MutableLongFloatMap,kotlin.Unit> builderAction);
+ method public static inline androidx.collection.LongFloatMap buildLongFloatMap(kotlin.jvm.functions.Function1<? super androidx.collection.MutableLongFloatMap,kotlin.Unit> builderAction);
+ method public static androidx.collection.LongFloatMap emptyLongFloatMap();
+ method public static androidx.collection.LongFloatMap longFloatMapOf();
+ method public static androidx.collection.LongFloatMap longFloatMapOf(long key1, float value1);
+ method public static androidx.collection.LongFloatMap longFloatMapOf(long key1, float value1, long key2, float value2);
+ method public static androidx.collection.LongFloatMap longFloatMapOf(long key1, float value1, long key2, float value2, long key3, float value3);
+ method public static androidx.collection.LongFloatMap longFloatMapOf(long key1, float value1, long key2, float value2, long key3, float value3, long key4, float value4);
+ method public static androidx.collection.LongFloatMap longFloatMapOf(long key1, float value1, long key2, float value2, long key3, float value3, long key4, float value4, long key5, float value5);
+ method public static androidx.collection.MutableLongFloatMap mutableLongFloatMapOf();
+ method public static androidx.collection.MutableLongFloatMap mutableLongFloatMapOf(long key1, float value1);
+ method public static androidx.collection.MutableLongFloatMap mutableLongFloatMapOf(long key1, float value1, long key2, float value2);
+ method public static androidx.collection.MutableLongFloatMap mutableLongFloatMapOf(long key1, float value1, long key2, float value2, long key3, float value3);
+ method public static androidx.collection.MutableLongFloatMap mutableLongFloatMapOf(long key1, float value1, long key2, float value2, long key3, float value3, long key4, float value4);
+ method public static androidx.collection.MutableLongFloatMap mutableLongFloatMapOf(long key1, float value1, long key2, float value2, long key3, float value3, long key4, float value4, long key5, float value5);
+ }
+
+ public abstract sealed class LongIntMap {
+ method public final inline boolean all(kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Integer,java.lang.Boolean> predicate);
+ method public final boolean any();
+ method public final inline boolean any(kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Integer,java.lang.Boolean> predicate);
+ method public final inline operator boolean contains(long key);
+ method public final boolean containsKey(long key);
+ method public final boolean containsValue(int value);
+ method public final int count();
+ method public final inline int count(kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Integer,java.lang.Boolean> predicate);
+ method public final inline void forEach(kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Integer,kotlin.Unit> block);
+ method public final inline void forEachKey(kotlin.jvm.functions.Function1<? super java.lang.Long,kotlin.Unit> block);
+ method public final inline void forEachValue(kotlin.jvm.functions.Function1<? super java.lang.Integer,kotlin.Unit> block);
+ method public final operator int get(long key);
+ method public final int getCapacity();
+ method public final int getOrDefault(long key, int defaultValue);
+ method public final inline int getOrElse(long key, kotlin.jvm.functions.Function0<java.lang.Integer> defaultValue);
+ method public final int getSize();
+ method public final boolean isEmpty();
+ method public final boolean isNotEmpty();
+ method public final String joinToString();
+ method public final String joinToString(optional CharSequence separator);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final boolean none();
+ property public final int capacity;
+ property public final int size;
+ }
+
+ public final class LongIntMapKt {
+ method public static inline androidx.collection.LongIntMap buildLongIntMap(int initialCapacity, kotlin.jvm.functions.Function1<? super androidx.collection.MutableLongIntMap,kotlin.Unit> builderAction);
+ method public static inline androidx.collection.LongIntMap buildLongIntMap(kotlin.jvm.functions.Function1<? super androidx.collection.MutableLongIntMap,kotlin.Unit> builderAction);
+ method public static androidx.collection.LongIntMap emptyLongIntMap();
+ method public static androidx.collection.LongIntMap longIntMapOf();
+ method public static androidx.collection.LongIntMap longIntMapOf(long key1, int value1);
+ method public static androidx.collection.LongIntMap longIntMapOf(long key1, int value1, long key2, int value2);
+ method public static androidx.collection.LongIntMap longIntMapOf(long key1, int value1, long key2, int value2, long key3, int value3);
+ method public static androidx.collection.LongIntMap longIntMapOf(long key1, int value1, long key2, int value2, long key3, int value3, long key4, int value4);
+ method public static androidx.collection.LongIntMap longIntMapOf(long key1, int value1, long key2, int value2, long key3, int value3, long key4, int value4, long key5, int value5);
+ method public static androidx.collection.MutableLongIntMap mutableLongIntMapOf();
+ method public static androidx.collection.MutableLongIntMap mutableLongIntMapOf(long key1, int value1);
+ method public static androidx.collection.MutableLongIntMap mutableLongIntMapOf(long key1, int value1, long key2, int value2);
+ method public static androidx.collection.MutableLongIntMap mutableLongIntMapOf(long key1, int value1, long key2, int value2, long key3, int value3);
+ method public static androidx.collection.MutableLongIntMap mutableLongIntMapOf(long key1, int value1, long key2, int value2, long key3, int value3, long key4, int value4);
+ method public static androidx.collection.MutableLongIntMap mutableLongIntMapOf(long key1, int value1, long key2, int value2, long key3, int value3, long key4, int value4, long key5, int value5);
+ }
+
+ public abstract sealed class LongList {
+ method public final inline boolean any();
+ method public final inline boolean any(kotlin.jvm.functions.Function1<? super java.lang.Long,java.lang.Boolean> predicate);
+ method public final int binarySearch(int element);
+ method public final int binarySearch(int element, optional int fromIndex);
+ method public final int binarySearch(int element, optional int fromIndex, optional int toIndex);
+ method public final operator boolean contains(long element);
+ method public final boolean containsAll(androidx.collection.LongList elements);
+ method public final inline int count();
+ method public final inline int count(kotlin.jvm.functions.Function1<? super java.lang.Long,java.lang.Boolean> predicate);
+ method public final long elementAt(@IntRange(from=0L) int index);
+ method public final inline long elementAtOrElse(@IntRange(from=0L) int index, kotlin.jvm.functions.Function1<? super java.lang.Integer,java.lang.Long> defaultValue);
+ method public final long first();
+ method public final inline long first(kotlin.jvm.functions.Function1<? super java.lang.Long,java.lang.Boolean> predicate);
+ method public final inline <R> R fold(R initial, kotlin.jvm.functions.Function2<? super R,? super java.lang.Long,? extends R> operation);
+ method public final inline <R> R foldIndexed(R initial, kotlin.jvm.functions.Function3<? super java.lang.Integer,? super R,? super java.lang.Long,? extends R> operation);
+ method public final inline <R> R foldRight(R initial, kotlin.jvm.functions.Function2<? super java.lang.Long,? super R,? extends R> operation);
+ method public final inline <R> R foldRightIndexed(R initial, kotlin.jvm.functions.Function3<? super java.lang.Integer,? super java.lang.Long,? super R,? extends R> operation);
+ method public final inline void forEach(kotlin.jvm.functions.Function1<? super java.lang.Long,kotlin.Unit> block);
+ method public final inline void forEachIndexed(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Long,kotlin.Unit> block);
+ method public final inline void forEachReversed(kotlin.jvm.functions.Function1<? super java.lang.Long,kotlin.Unit> block);
+ method public final inline void forEachReversedIndexed(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Long,kotlin.Unit> block);
+ method public final operator long get(@IntRange(from=0L) int index);
+ method public final inline kotlin.ranges.IntRange getIndices();
+ method @IntRange(from=-1L) public final inline int getLastIndex();
+ method @IntRange(from=0L) public final inline int getSize();
+ method public final int indexOf(long element);
+ method public final inline int indexOfFirst(kotlin.jvm.functions.Function1<? super java.lang.Long,java.lang.Boolean> predicate);
+ method public final inline int indexOfLast(kotlin.jvm.functions.Function1<? super java.lang.Long,java.lang.Boolean> predicate);
+ method public final inline boolean isEmpty();
+ method public final inline boolean isNotEmpty();
+ method public final String joinToString();
+ method public final String joinToString(optional CharSequence separator);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function1<? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function1<? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function1<? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function1<? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function1<? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(kotlin.jvm.functions.Function1<? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final long last();
+ method public final inline long last(kotlin.jvm.functions.Function1<? super java.lang.Long,java.lang.Boolean> predicate);
+ method public final int lastIndexOf(long element);
+ method public final inline boolean none();
+ method public final inline boolean reversedAny(kotlin.jvm.functions.Function1<? super java.lang.Long,java.lang.Boolean> predicate);
+ property public final inline kotlin.ranges.IntRange indices;
+ property @IntRange(from=-1L) public final inline int lastIndex;
+ property @IntRange(from=0L) public final inline int size;
+ }
+
+ public final class LongListKt {
+ method public static inline androidx.collection.LongList buildLongList(int initialCapacity, kotlin.jvm.functions.Function1<? super androidx.collection.MutableLongList,kotlin.Unit> builderAction);
+ method public static inline androidx.collection.LongList buildLongList(kotlin.jvm.functions.Function1<? super androidx.collection.MutableLongList,kotlin.Unit> builderAction);
+ method public static androidx.collection.LongList emptyLongList();
+ method public static androidx.collection.LongList longListOf();
+ method public static androidx.collection.LongList longListOf(long element1);
+ method public static androidx.collection.LongList longListOf(long element1, long element2);
+ method public static androidx.collection.LongList longListOf(long element1, long element2, long element3);
+ method public static androidx.collection.LongList longListOf(long... elements);
+ method public static inline androidx.collection.MutableLongList mutableLongListOf();
+ method public static androidx.collection.MutableLongList mutableLongListOf(long element1);
+ method public static androidx.collection.MutableLongList mutableLongListOf(long element1, long element2);
+ method public static androidx.collection.MutableLongList mutableLongListOf(long element1, long element2, long element3);
+ method public static inline androidx.collection.MutableLongList mutableLongListOf(long... elements);
+ }
+
+ public abstract sealed class LongLongMap {
+ method public final inline boolean all(kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Long,java.lang.Boolean> predicate);
+ method public final boolean any();
+ method public final inline boolean any(kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Long,java.lang.Boolean> predicate);
+ method public final inline operator boolean contains(long key);
+ method public final boolean containsKey(long key);
+ method public final boolean containsValue(long value);
+ method public final int count();
+ method public final inline int count(kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Long,java.lang.Boolean> predicate);
+ method public final inline void forEach(kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Long,kotlin.Unit> block);
+ method public final inline void forEachKey(kotlin.jvm.functions.Function1<? super java.lang.Long,kotlin.Unit> block);
+ method public final inline void forEachValue(kotlin.jvm.functions.Function1<? super java.lang.Long,kotlin.Unit> block);
+ method public final operator long get(long key);
+ method public final int getCapacity();
+ method public final long getOrDefault(long key, long defaultValue);
+ method public final inline long getOrElse(long key, kotlin.jvm.functions.Function0<java.lang.Long> defaultValue);
+ method public final int getSize();
+ method public final boolean isEmpty();
+ method public final boolean isNotEmpty();
+ method public final String joinToString();
+ method public final String joinToString(optional CharSequence separator);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final boolean none();
+ property public final int capacity;
+ property public final int size;
+ }
+
+ public final class LongLongMapKt {
+ method public static inline androidx.collection.LongLongMap buildLongLongMap(int initialCapacity, kotlin.jvm.functions.Function1<? super androidx.collection.MutableLongLongMap,kotlin.Unit> builderAction);
+ method public static inline androidx.collection.LongLongMap buildLongLongMap(kotlin.jvm.functions.Function1<? super androidx.collection.MutableLongLongMap,kotlin.Unit> builderAction);
+ method public static androidx.collection.LongLongMap emptyLongLongMap();
+ method public static androidx.collection.LongLongMap longLongMapOf();
+ method public static androidx.collection.LongLongMap longLongMapOf(long key1, long value1);
+ method public static androidx.collection.LongLongMap longLongMapOf(long key1, long value1, long key2, long value2);
+ method public static androidx.collection.LongLongMap longLongMapOf(long key1, long value1, long key2, long value2, long key3, long value3);
+ method public static androidx.collection.LongLongMap longLongMapOf(long key1, long value1, long key2, long value2, long key3, long value3, long key4, long value4);
+ method public static androidx.collection.LongLongMap longLongMapOf(long key1, long value1, long key2, long value2, long key3, long value3, long key4, long value4, long key5, long value5);
+ method public static androidx.collection.MutableLongLongMap mutableLongLongMapOf();
+ method public static androidx.collection.MutableLongLongMap mutableLongLongMapOf(long key1, long value1);
+ method public static androidx.collection.MutableLongLongMap mutableLongLongMapOf(long key1, long value1, long key2, long value2);
+ method public static androidx.collection.MutableLongLongMap mutableLongLongMapOf(long key1, long value1, long key2, long value2, long key3, long value3);
+ method public static androidx.collection.MutableLongLongMap mutableLongLongMapOf(long key1, long value1, long key2, long value2, long key3, long value3, long key4, long value4);
+ method public static androidx.collection.MutableLongLongMap mutableLongLongMapOf(long key1, long value1, long key2, long value2, long key3, long value3, long key4, long value4, long key5, long value5);
+ }
+
+ public final class LongLongPair {
+ ctor public LongLongPair(long first, long second);
+ method public inline operator long component1();
+ method public inline operator long component2();
+ method public long getFirst();
+ method public long getSecond();
+ property public final long first;
+ property public final long second;
+ }
+
+ public abstract sealed class LongObjectMap<V> {
+ method public final inline boolean all(kotlin.jvm.functions.Function2<? super java.lang.Long,? super V,java.lang.Boolean> predicate);
+ method public final boolean any();
+ method public final inline boolean any(kotlin.jvm.functions.Function2<? super java.lang.Long,? super V,java.lang.Boolean> predicate);
+ method public final inline operator boolean contains(long key);
+ method public final boolean containsKey(long key);
+ method public final boolean containsValue(V value);
+ method public final int count();
+ method public final inline int count(kotlin.jvm.functions.Function2<? super java.lang.Long,? super V,java.lang.Boolean> predicate);
+ method public final inline void forEach(kotlin.jvm.functions.Function2<? super java.lang.Long,? super V,kotlin.Unit> block);
+ method public final inline void forEachKey(kotlin.jvm.functions.Function1<? super java.lang.Long,kotlin.Unit> block);
+ method public final inline void forEachValue(kotlin.jvm.functions.Function1<? super V,kotlin.Unit> block);
+ method public final operator V? get(long key);
+ method public final int getCapacity();
+ method public final V getOrDefault(long key, V defaultValue);
+ method public final inline V getOrElse(long key, kotlin.jvm.functions.Function0<? extends V> defaultValue);
+ method public final int getSize();
+ method public final boolean isEmpty();
+ method public final boolean isNotEmpty();
+ method public final String joinToString();
+ method public final String joinToString(optional CharSequence separator);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2<? super java.lang.Long,? super V,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2<? super java.lang.Long,? super V,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2<? super java.lang.Long,? super V,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2<? super java.lang.Long,? super V,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2<? super java.lang.Long,? super V,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(kotlin.jvm.functions.Function2<? super java.lang.Long,? super V,? extends java.lang.CharSequence> transform);
+ method public final boolean none();
+ property public final int capacity;
+ property public final int size;
+ }
+
+ public final class LongObjectMapKt {
+ method public static inline <V> androidx.collection.LongObjectMap<V> buildLongObjectMap(int initialCapacity, kotlin.jvm.functions.Function1<? super androidx.collection.MutableLongObjectMap<V>,kotlin.Unit> builderAction);
+ method public static inline <V> androidx.collection.LongObjectMap<V> buildLongObjectMap(kotlin.jvm.functions.Function1<? super androidx.collection.MutableLongObjectMap<V>,kotlin.Unit> builderAction);
+ method public static <V> androidx.collection.LongObjectMap<V> emptyLongObjectMap();
+ method public static <V> androidx.collection.LongObjectMap<V> longObjectMapOf();
+ method public static <V> androidx.collection.LongObjectMap<V> longObjectMapOf(long key1, V value1);
+ method public static <V> androidx.collection.LongObjectMap<V> longObjectMapOf(long key1, V value1, long key2, V value2);
+ method public static <V> androidx.collection.LongObjectMap<V> longObjectMapOf(long key1, V value1, long key2, V value2, long key3, V value3);
+ method public static <V> androidx.collection.LongObjectMap<V> longObjectMapOf(long key1, V value1, long key2, V value2, long key3, V value3, long key4, V value4);
+ method public static <V> androidx.collection.LongObjectMap<V> longObjectMapOf(long key1, V value1, long key2, V value2, long key3, V value3, long key4, V value4, long key5, V value5);
+ method public static <V> androidx.collection.MutableLongObjectMap<V> mutableLongObjectMapOf();
+ method public static <V> androidx.collection.MutableLongObjectMap<V> mutableLongObjectMapOf(long key1, V value1);
+ method public static <V> androidx.collection.MutableLongObjectMap<V> mutableLongObjectMapOf(long key1, V value1, long key2, V value2);
+ method public static <V> androidx.collection.MutableLongObjectMap<V> mutableLongObjectMapOf(long key1, V value1, long key2, V value2, long key3, V value3);
+ method public static <V> androidx.collection.MutableLongObjectMap<V> mutableLongObjectMapOf(long key1, V value1, long key2, V value2, long key3, V value3, long key4, V value4);
+ method public static <V> androidx.collection.MutableLongObjectMap<V> mutableLongObjectMapOf(long key1, V value1, long key2, V value2, long key3, V value3, long key4, V value4, long key5, V value5);
+ }
+
+ public abstract sealed class LongSet {
+ method public final inline boolean all(kotlin.jvm.functions.Function1<? super java.lang.Long,java.lang.Boolean> predicate);
+ method public final boolean any();
+ method public final inline boolean any(kotlin.jvm.functions.Function1<? super java.lang.Long,java.lang.Boolean> predicate);
+ method public final operator boolean contains(long element);
+ method @IntRange(from=0L) public final int count();
+ method @IntRange(from=0L) public final inline int count(kotlin.jvm.functions.Function1<? super java.lang.Long,java.lang.Boolean> predicate);
+ method public final inline long first();
+ method public final inline long first(kotlin.jvm.functions.Function1<? super java.lang.Long,java.lang.Boolean> predicate);
+ method public final inline void forEach(kotlin.jvm.functions.Function1<? super java.lang.Long,kotlin.Unit> block);
+ method @IntRange(from=0L) public final int getCapacity();
+ method @IntRange(from=0L) public final int getSize();
+ method public final boolean isEmpty();
+ method public final boolean isNotEmpty();
+ method public final String joinToString();
+ method public final String joinToString(optional CharSequence separator);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function1<? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function1<? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function1<? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function1<? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function1<? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(kotlin.jvm.functions.Function1<? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final boolean none();
+ property @IntRange(from=0L) public final int capacity;
+ property @IntRange(from=0L) public final int size;
+ }
+
+ public final class LongSetKt {
+ method public static inline androidx.collection.LongSet buildLongSet(int initialCapacity, kotlin.jvm.functions.Function1<? super androidx.collection.MutableLongSet,kotlin.Unit> builderAction);
+ method public static inline androidx.collection.LongSet buildLongSet(kotlin.jvm.functions.Function1<? super androidx.collection.MutableLongSet,kotlin.Unit> builderAction);
+ method public static androidx.collection.LongSet emptyLongSet();
+ method public static androidx.collection.LongSet longSetOf();
+ method public static androidx.collection.LongSet longSetOf(long element1);
+ method public static androidx.collection.LongSet longSetOf(long element1, long element2);
+ method public static androidx.collection.LongSet longSetOf(long element1, long element2, long element3);
+ method public static androidx.collection.LongSet longSetOf(long... elements);
+ method public static androidx.collection.MutableLongSet mutableLongSetOf();
+ method public static androidx.collection.MutableLongSet mutableLongSetOf(long element1);
+ method public static androidx.collection.MutableLongSet mutableLongSetOf(long element1, long element2);
+ method public static androidx.collection.MutableLongSet mutableLongSetOf(long element1, long element2, long element3);
+ method public static androidx.collection.MutableLongSet mutableLongSetOf(long... elements);
+ }
+
+ public class LongSparseArray<E> implements java.lang.Cloneable {
+ ctor public LongSparseArray();
+ ctor public LongSparseArray(optional int initialCapacity);
+ method public void append(long key, E value);
+ method public void clear();
+ method public androidx.collection.LongSparseArray<E> clone();
+ method public boolean containsKey(long key);
+ method public boolean containsValue(E value);
+ method @Deprecated public void delete(long key);
+ method public operator E? get(long key);
+ method public E get(long key, E defaultValue);
+ method public int indexOfKey(long key);
+ method public int indexOfValue(E value);
+ method public boolean isEmpty();
+ method public long keyAt(int index);
+ method public void put(long key, E value);
+ method public void putAll(androidx.collection.LongSparseArray<? extends E> other);
+ method public E? putIfAbsent(long key, E value);
+ method public void remove(long key);
+ method public boolean remove(long key, E value);
+ method public void removeAt(int index);
+ method public E? replace(long key, E value);
+ method public boolean replace(long key, E oldValue, E newValue);
+ method public void setValueAt(int index, E value);
+ method public int size();
+ method public E valueAt(int index);
+ }
+
+ public final class LongSparseArrayKt {
+ method public static inline operator <T> boolean contains(androidx.collection.LongSparseArray<T>, long key);
+ method public static inline <T> void forEach(androidx.collection.LongSparseArray<T>, kotlin.jvm.functions.Function2<? super java.lang.Long,? super T,kotlin.Unit> action);
+ method public static inline <T> T getOrDefault(androidx.collection.LongSparseArray<T>, long key, T defaultValue);
+ method public static inline <T> T getOrElse(androidx.collection.LongSparseArray<T>, long key, kotlin.jvm.functions.Function0<? extends T> defaultValue);
+ method public static inline <T> int getSize(androidx.collection.LongSparseArray<T>);
+ method public static inline <T> boolean isNotEmpty(androidx.collection.LongSparseArray<T>);
+ method public static <T> kotlin.collections.LongIterator keyIterator(androidx.collection.LongSparseArray<T>);
+ method public static operator <T> androidx.collection.LongSparseArray<T> plus(androidx.collection.LongSparseArray<T>, androidx.collection.LongSparseArray<T> other);
+ method @Deprecated public static <T> boolean remove(androidx.collection.LongSparseArray<T>, long key, T value);
+ method public static inline operator <T> void set(androidx.collection.LongSparseArray<T>, long key, T value);
+ method public static <T> java.util.Iterator<T> valueIterator(androidx.collection.LongSparseArray<T>);
+ }
+
+ public class LruCache<K, V> {
+ ctor public LruCache(@IntRange(from=1L, to=androidx.collection.LruCacheKt.MAX_SIZE) int maxSize);
+ method protected V? create(K key);
+ method public final int createCount();
+ method protected void entryRemoved(boolean evicted, K key, V oldValue, V? newValue);
+ method public final void evictAll();
+ method public final int evictionCount();
+ method public final operator V? get(K key);
+ method public final int hitCount();
+ method public final int maxSize();
+ method public final int missCount();
+ method public final V? put(K key, V value);
+ method public final int putCount();
+ method public final V? remove(K key);
+ method public void resize(@IntRange(from=1L, to=androidx.collection.LruCacheKt.MAX_SIZE) int maxSize);
+ method public final int size();
+ method protected int sizeOf(K key, V value);
+ method public final java.util.Map<K,V> snapshot();
+ method public void trimToSize(int maxSize);
+ }
+
+ public final class LruCacheKt {
+ method public static inline <K, V> androidx.collection.LruCache<K,V> lruCache(int maxSize, optional kotlin.jvm.functions.Function2<? super K,? super V,java.lang.Integer> sizeOf, optional kotlin.jvm.functions.Function1<? super K,? extends V?> create, optional kotlin.jvm.functions.Function4<? super java.lang.Boolean,? super K,? super V,? super V?,kotlin.Unit> onEntryRemoved);
+ }
+
+ public final class MutableDoubleList extends androidx.collection.DoubleList {
+ ctor public MutableDoubleList();
+ ctor public MutableDoubleList(optional int initialCapacity);
+ method public boolean add(double element);
+ method public void add(@IntRange(from=0L) int index, double element);
+ method public inline boolean addAll(androidx.collection.DoubleList elements);
+ method public inline boolean addAll(double[] elements);
+ method public boolean addAll(@IntRange(from=0L) int index, androidx.collection.DoubleList elements);
+ method public boolean addAll(@IntRange(from=0L) int index, double[] elements);
+ method public void clear();
+ method public void ensureCapacity(int capacity);
+ method public inline int getCapacity();
+ method public operator void minusAssign(androidx.collection.DoubleList elements);
+ method public inline operator void minusAssign(double element);
+ method public operator void minusAssign(double[] elements);
+ method public inline operator void plusAssign(androidx.collection.DoubleList elements);
+ method public inline operator void plusAssign(double element);
+ method public inline operator void plusAssign(double[] elements);
+ method public boolean remove(double element);
+ method public boolean removeAll(androidx.collection.DoubleList elements);
+ method public boolean removeAll(double[] elements);
+ method public double removeAt(@IntRange(from=0L) int index);
+ method public void removeRange(@IntRange(from=0L) int start, @IntRange(from=0L) int end);
+ method public boolean retainAll(androidx.collection.DoubleList elements);
+ method public boolean retainAll(double[] elements);
+ method public operator double set(@IntRange(from=0L) int index, double element);
+ method public void sort();
+ method public void sortDescending();
+ method public void trim(optional int minCapacity);
+ property public final inline int capacity;
+ }
+
+ public final class MutableFloatFloatMap extends androidx.collection.FloatFloatMap {
+ ctor public MutableFloatFloatMap();
+ ctor public MutableFloatFloatMap(optional int initialCapacity);
+ method public void clear();
+ method public inline float getOrPut(float key, kotlin.jvm.functions.Function0<java.lang.Float> defaultValue);
+ method public inline operator void minusAssign(androidx.collection.FloatList keys);
+ method public inline operator void minusAssign(androidx.collection.FloatSet keys);
+ method public inline operator void minusAssign(float key);
+ method public inline operator void minusAssign(float[] keys);
+ method public inline operator void plusAssign(androidx.collection.FloatFloatMap from);
+ method public void put(float key, float value);
+ method public float put(float key, float value, float default);
+ method public void putAll(androidx.collection.FloatFloatMap from);
+ method public void remove(float key);
+ method public boolean remove(float key, float value);
+ method public inline void removeIf(kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Float,java.lang.Boolean> predicate);
+ method public operator void set(float key, float value);
+ method public int trim();
+ }
+
+ public final class MutableFloatIntMap extends androidx.collection.FloatIntMap {
+ ctor public MutableFloatIntMap();
+ ctor public MutableFloatIntMap(optional int initialCapacity);
+ method public void clear();
+ method public inline int getOrPut(float key, kotlin.jvm.functions.Function0<java.lang.Integer> defaultValue);
+ method public inline operator void minusAssign(androidx.collection.FloatList keys);
+ method public inline operator void minusAssign(androidx.collection.FloatSet keys);
+ method public inline operator void minusAssign(float key);
+ method public inline operator void minusAssign(float[] keys);
+ method public inline operator void plusAssign(androidx.collection.FloatIntMap from);
+ method public void put(float key, int value);
+ method public int put(float key, int value, int default);
+ method public void putAll(androidx.collection.FloatIntMap from);
+ method public void remove(float key);
+ method public boolean remove(float key, int value);
+ method public inline void removeIf(kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Integer,java.lang.Boolean> predicate);
+ method public operator void set(float key, int value);
+ method public int trim();
+ }
+
+ public final class MutableFloatList extends androidx.collection.FloatList {
+ ctor public MutableFloatList();
+ ctor public MutableFloatList(optional int initialCapacity);
+ method public boolean add(float element);
+ method public void add(@IntRange(from=0L) int index, float element);
+ method public inline boolean addAll(androidx.collection.FloatList elements);
+ method public inline boolean addAll(float[] elements);
+ method public boolean addAll(@IntRange(from=0L) int index, androidx.collection.FloatList elements);
+ method public boolean addAll(@IntRange(from=0L) int index, float[] elements);
+ method public void clear();
+ method public void ensureCapacity(int capacity);
+ method public inline int getCapacity();
+ method public operator void minusAssign(androidx.collection.FloatList elements);
+ method public inline operator void minusAssign(float element);
+ method public operator void minusAssign(float[] elements);
+ method public inline operator void plusAssign(androidx.collection.FloatList elements);
+ method public inline operator void plusAssign(float element);
+ method public inline operator void plusAssign(float[] elements);
+ method public boolean remove(float element);
+ method public boolean removeAll(androidx.collection.FloatList elements);
+ method public boolean removeAll(float[] elements);
+ method public float removeAt(@IntRange(from=0L) int index);
+ method public void removeRange(@IntRange(from=0L) int start, @IntRange(from=0L) int end);
+ method public boolean retainAll(androidx.collection.FloatList elements);
+ method public boolean retainAll(float[] elements);
+ method public operator float set(@IntRange(from=0L) int index, float element);
+ method public void sort();
+ method public void sortDescending();
+ method public void trim(optional int minCapacity);
+ property public final inline int capacity;
+ }
+
+ public final class MutableFloatLongMap extends androidx.collection.FloatLongMap {
+ ctor public MutableFloatLongMap();
+ ctor public MutableFloatLongMap(optional int initialCapacity);
+ method public void clear();
+ method public inline long getOrPut(float key, kotlin.jvm.functions.Function0<java.lang.Long> defaultValue);
+ method public inline operator void minusAssign(androidx.collection.FloatList keys);
+ method public inline operator void minusAssign(androidx.collection.FloatSet keys);
+ method public inline operator void minusAssign(float key);
+ method public inline operator void minusAssign(float[] keys);
+ method public inline operator void plusAssign(androidx.collection.FloatLongMap from);
+ method public void put(float key, long value);
+ method public long put(float key, long value, long default);
+ method public void putAll(androidx.collection.FloatLongMap from);
+ method public void remove(float key);
+ method public boolean remove(float key, long value);
+ method public inline void removeIf(kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Long,java.lang.Boolean> predicate);
+ method public operator void set(float key, long value);
+ method public int trim();
+ }
+
+ public final class MutableFloatObjectMap<V> extends androidx.collection.FloatObjectMap<V> {
+ ctor public MutableFloatObjectMap();
+ ctor public MutableFloatObjectMap(optional int initialCapacity);
+ method public void clear();
+ method public inline V getOrPut(float key, kotlin.jvm.functions.Function0<? extends V> defaultValue);
+ method public inline operator void minusAssign(androidx.collection.FloatList keys);
+ method public inline operator void minusAssign(androidx.collection.FloatSet keys);
+ method public inline operator void minusAssign(float key);
+ method public inline operator void minusAssign(float[] keys);
+ method public inline operator void plusAssign(androidx.collection.FloatObjectMap<V> from);
+ method public V? put(float key, V value);
+ method public void putAll(androidx.collection.FloatObjectMap<V> from);
+ method public V? remove(float key);
+ method public boolean remove(float key, V value);
+ method public inline void removeIf(kotlin.jvm.functions.Function2<? super java.lang.Float,? super V,java.lang.Boolean> predicate);
+ method public operator void set(float key, V value);
+ method public int trim();
+ }
+
+ public final class MutableFloatSet extends androidx.collection.FloatSet {
+ ctor public MutableFloatSet();
+ ctor public MutableFloatSet(optional int initialCapacity);
+ method public boolean add(float element);
+ method public boolean addAll(androidx.collection.FloatSet elements);
+ method public boolean addAll(float[] elements);
+ method public void clear();
+ method public operator void minusAssign(androidx.collection.FloatSet elements);
+ method public operator void minusAssign(float element);
+ method public operator void minusAssign(float[] elements);
+ method public operator void plusAssign(androidx.collection.FloatSet elements);
+ method public operator void plusAssign(float element);
+ method public operator void plusAssign(float[] elements);
+ method public boolean remove(float element);
+ method public boolean removeAll(androidx.collection.FloatSet elements);
+ method public boolean removeAll(float[] elements);
+ method @IntRange(from=0L) public int trim();
+ }
+
+ public final class MutableIntFloatMap extends androidx.collection.IntFloatMap {
+ ctor public MutableIntFloatMap();
+ ctor public MutableIntFloatMap(optional int initialCapacity);
+ method public void clear();
+ method public inline float getOrPut(int key, kotlin.jvm.functions.Function0<java.lang.Float> defaultValue);
+ method public inline operator void minusAssign(androidx.collection.IntList keys);
+ method public inline operator void minusAssign(androidx.collection.IntSet keys);
+ method public inline operator void minusAssign(int key);
+ method public inline operator void minusAssign(int[] keys);
+ method public inline operator void plusAssign(androidx.collection.IntFloatMap from);
+ method public void put(int key, float value);
+ method public float put(int key, float value, float default);
+ method public void putAll(androidx.collection.IntFloatMap from);
+ method public void remove(int key);
+ method public boolean remove(int key, float value);
+ method public inline void removeIf(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Float,java.lang.Boolean> predicate);
+ method public operator void set(int key, float value);
+ method public int trim();
+ }
+
+ public final class MutableIntIntMap extends androidx.collection.IntIntMap {
+ ctor public MutableIntIntMap();
+ ctor public MutableIntIntMap(optional int initialCapacity);
+ method public void clear();
+ method public inline int getOrPut(int key, kotlin.jvm.functions.Function0<java.lang.Integer> defaultValue);
+ method public inline operator void minusAssign(androidx.collection.IntList keys);
+ method public inline operator void minusAssign(androidx.collection.IntSet keys);
+ method public inline operator void minusAssign(int key);
+ method public inline operator void minusAssign(int[] keys);
+ method public inline operator void plusAssign(androidx.collection.IntIntMap from);
+ method public void put(int key, int value);
+ method public int put(int key, int value, int default);
+ method public void putAll(androidx.collection.IntIntMap from);
+ method public void remove(int key);
+ method public boolean remove(int key, int value);
+ method public inline void removeIf(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Integer,java.lang.Boolean> predicate);
+ method public operator void set(int key, int value);
+ method public int trim();
+ }
+
+ public final class MutableIntList extends androidx.collection.IntList {
+ ctor public MutableIntList();
+ ctor public MutableIntList(optional int initialCapacity);
+ method public boolean add(int element);
+ method public void add(@IntRange(from=0L) int index, int element);
+ method public inline boolean addAll(androidx.collection.IntList elements);
+ method public boolean addAll(@IntRange(from=0L) int index, androidx.collection.IntList elements);
+ method public boolean addAll(@IntRange(from=0L) int index, int[] elements);
+ method public inline boolean addAll(int[] elements);
+ method public void clear();
+ method public void ensureCapacity(int capacity);
+ method public inline int getCapacity();
+ method public operator void minusAssign(androidx.collection.IntList elements);
+ method public inline operator void minusAssign(int element);
+ method public operator void minusAssign(int[] elements);
+ method public inline operator void plusAssign(androidx.collection.IntList elements);
+ method public inline operator void plusAssign(int element);
+ method public inline operator void plusAssign(int[] elements);
+ method public boolean remove(int element);
+ method public boolean removeAll(androidx.collection.IntList elements);
+ method public boolean removeAll(int[] elements);
+ method public int removeAt(@IntRange(from=0L) int index);
+ method public void removeRange(@IntRange(from=0L) int start, @IntRange(from=0L) int end);
+ method public boolean retainAll(androidx.collection.IntList elements);
+ method public boolean retainAll(int[] elements);
+ method public operator int set(@IntRange(from=0L) int index, int element);
+ method public void sort();
+ method public void sortDescending();
+ method public void trim(optional int minCapacity);
+ property public final inline int capacity;
+ }
+
+ public final class MutableIntLongMap extends androidx.collection.IntLongMap {
+ ctor public MutableIntLongMap();
+ ctor public MutableIntLongMap(optional int initialCapacity);
+ method public void clear();
+ method public inline long getOrPut(int key, kotlin.jvm.functions.Function0<java.lang.Long> defaultValue);
+ method public inline operator void minusAssign(androidx.collection.IntList keys);
+ method public inline operator void minusAssign(androidx.collection.IntSet keys);
+ method public inline operator void minusAssign(int key);
+ method public inline operator void minusAssign(int[] keys);
+ method public inline operator void plusAssign(androidx.collection.IntLongMap from);
+ method public void put(int key, long value);
+ method public long put(int key, long value, long default);
+ method public void putAll(androidx.collection.IntLongMap from);
+ method public void remove(int key);
+ method public boolean remove(int key, long value);
+ method public inline void removeIf(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Long,java.lang.Boolean> predicate);
+ method public operator void set(int key, long value);
+ method public int trim();
+ }
+
+ public final class MutableIntObjectMap<V> extends androidx.collection.IntObjectMap<V> {
+ ctor public MutableIntObjectMap();
+ ctor public MutableIntObjectMap(optional int initialCapacity);
+ method public void clear();
+ method public inline V getOrPut(int key, kotlin.jvm.functions.Function0<? extends V> defaultValue);
+ method public inline operator void minusAssign(androidx.collection.IntList keys);
+ method public inline operator void minusAssign(androidx.collection.IntSet keys);
+ method public inline operator void minusAssign(int key);
+ method public inline operator void minusAssign(int[] keys);
+ method public inline operator void plusAssign(androidx.collection.IntObjectMap<V> from);
+ method public V? put(int key, V value);
+ method public void putAll(androidx.collection.IntObjectMap<V> from);
+ method public V? remove(int key);
+ method public boolean remove(int key, V value);
+ method public inline void removeIf(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super V,java.lang.Boolean> predicate);
+ method public operator void set(int key, V value);
+ method public int trim();
+ }
+
+ public final class MutableIntSet extends androidx.collection.IntSet {
+ ctor public MutableIntSet();
+ ctor public MutableIntSet(optional int initialCapacity);
+ method public boolean add(int element);
+ method public boolean addAll(androidx.collection.IntSet elements);
+ method public boolean addAll(int[] elements);
+ method public void clear();
+ method public operator void minusAssign(androidx.collection.IntSet elements);
+ method public operator void minusAssign(int element);
+ method public operator void minusAssign(int[] elements);
+ method public operator void plusAssign(androidx.collection.IntSet elements);
+ method public operator void plusAssign(int element);
+ method public operator void plusAssign(int[] elements);
+ method public boolean remove(int element);
+ method public boolean removeAll(androidx.collection.IntSet elements);
+ method public boolean removeAll(int[] elements);
+ method @IntRange(from=0L) public int trim();
+ }
+
+ public final class MutableLongFloatMap extends androidx.collection.LongFloatMap {
+ ctor public MutableLongFloatMap();
+ ctor public MutableLongFloatMap(optional int initialCapacity);
+ method public void clear();
+ method public inline float getOrPut(long key, kotlin.jvm.functions.Function0<java.lang.Float> defaultValue);
+ method public inline operator void minusAssign(androidx.collection.LongList keys);
+ method public inline operator void minusAssign(androidx.collection.LongSet keys);
+ method public inline operator void minusAssign(long key);
+ method public inline operator void minusAssign(long[] keys);
+ method public inline operator void plusAssign(androidx.collection.LongFloatMap from);
+ method public void put(long key, float value);
+ method public float put(long key, float value, float default);
+ method public void putAll(androidx.collection.LongFloatMap from);
+ method public void remove(long key);
+ method public boolean remove(long key, float value);
+ method public inline void removeIf(kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Float,java.lang.Boolean> predicate);
+ method public operator void set(long key, float value);
+ method public int trim();
+ }
+
+ public final class MutableLongIntMap extends androidx.collection.LongIntMap {
+ ctor public MutableLongIntMap();
+ ctor public MutableLongIntMap(optional int initialCapacity);
+ method public void clear();
+ method public inline int getOrPut(long key, kotlin.jvm.functions.Function0<java.lang.Integer> defaultValue);
+ method public inline operator void minusAssign(androidx.collection.LongList keys);
+ method public inline operator void minusAssign(androidx.collection.LongSet keys);
+ method public inline operator void minusAssign(long key);
+ method public inline operator void minusAssign(long[] keys);
+ method public inline operator void plusAssign(androidx.collection.LongIntMap from);
+ method public void put(long key, int value);
+ method public int put(long key, int value, int default);
+ method public void putAll(androidx.collection.LongIntMap from);
+ method public void remove(long key);
+ method public boolean remove(long key, int value);
+ method public inline void removeIf(kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Integer,java.lang.Boolean> predicate);
+ method public operator void set(long key, int value);
+ method public int trim();
+ }
+
+ public final class MutableLongList extends androidx.collection.LongList {
+ ctor public MutableLongList();
+ ctor public MutableLongList(optional int initialCapacity);
+ method public void add(@IntRange(from=0L) int index, long element);
+ method public boolean add(long element);
+ method public inline boolean addAll(androidx.collection.LongList elements);
+ method public boolean addAll(@IntRange(from=0L) int index, androidx.collection.LongList elements);
+ method public boolean addAll(@IntRange(from=0L) int index, long[] elements);
+ method public inline boolean addAll(long[] elements);
+ method public void clear();
+ method public void ensureCapacity(int capacity);
+ method public inline int getCapacity();
+ method public operator void minusAssign(androidx.collection.LongList elements);
+ method public inline operator void minusAssign(long element);
+ method public operator void minusAssign(long[] elements);
+ method public inline operator void plusAssign(androidx.collection.LongList elements);
+ method public inline operator void plusAssign(long element);
+ method public inline operator void plusAssign(long[] elements);
+ method public boolean remove(long element);
+ method public boolean removeAll(androidx.collection.LongList elements);
+ method public boolean removeAll(long[] elements);
+ method public long removeAt(@IntRange(from=0L) int index);
+ method public void removeRange(@IntRange(from=0L) int start, @IntRange(from=0L) int end);
+ method public boolean retainAll(androidx.collection.LongList elements);
+ method public boolean retainAll(long[] elements);
+ method public operator long set(@IntRange(from=0L) int index, long element);
+ method public void sort();
+ method public void sortDescending();
+ method public void trim(optional int minCapacity);
+ property public final inline int capacity;
+ }
+
+ public final class MutableLongLongMap extends androidx.collection.LongLongMap {
+ ctor public MutableLongLongMap();
+ ctor public MutableLongLongMap(optional int initialCapacity);
+ method public void clear();
+ method public inline long getOrPut(long key, kotlin.jvm.functions.Function0<java.lang.Long> defaultValue);
+ method public inline operator void minusAssign(androidx.collection.LongList keys);
+ method public inline operator void minusAssign(androidx.collection.LongSet keys);
+ method public inline operator void minusAssign(long key);
+ method public inline operator void minusAssign(long[] keys);
+ method public inline operator void plusAssign(androidx.collection.LongLongMap from);
+ method public void put(long key, long value);
+ method public long put(long key, long value, long default);
+ method public void putAll(androidx.collection.LongLongMap from);
+ method public void remove(long key);
+ method public boolean remove(long key, long value);
+ method public inline void removeIf(kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Long,java.lang.Boolean> predicate);
+ method public operator void set(long key, long value);
+ method public int trim();
+ }
+
+ public final class MutableLongObjectMap<V> extends androidx.collection.LongObjectMap<V> {
+ ctor public MutableLongObjectMap();
+ ctor public MutableLongObjectMap(optional int initialCapacity);
+ method public void clear();
+ method public inline V getOrPut(long key, kotlin.jvm.functions.Function0<? extends V> defaultValue);
+ method public inline operator void minusAssign(androidx.collection.LongList keys);
+ method public inline operator void minusAssign(androidx.collection.LongSet keys);
+ method public inline operator void minusAssign(long key);
+ method public inline operator void minusAssign(long[] keys);
+ method public inline operator void plusAssign(androidx.collection.LongObjectMap<V> from);
+ method public V? put(long key, V value);
+ method public void putAll(androidx.collection.LongObjectMap<V> from);
+ method public V? remove(long key);
+ method public boolean remove(long key, V value);
+ method public inline void removeIf(kotlin.jvm.functions.Function2<? super java.lang.Long,? super V,java.lang.Boolean> predicate);
+ method public operator void set(long key, V value);
+ method public int trim();
+ }
+
+ public final class MutableLongSet extends androidx.collection.LongSet {
+ ctor public MutableLongSet();
+ ctor public MutableLongSet(optional int initialCapacity);
+ method public boolean add(long element);
+ method public boolean addAll(androidx.collection.LongSet elements);
+ method public boolean addAll(long[] elements);
+ method public void clear();
+ method public operator void minusAssign(androidx.collection.LongSet elements);
+ method public operator void minusAssign(long element);
+ method public operator void minusAssign(long[] elements);
+ method public operator void plusAssign(androidx.collection.LongSet elements);
+ method public operator void plusAssign(long element);
+ method public operator void plusAssign(long[] elements);
+ method public boolean remove(long element);
+ method public boolean removeAll(androidx.collection.LongSet elements);
+ method public boolean removeAll(long[] elements);
+ method @IntRange(from=0L) public int trim();
+ }
+
+ public final class MutableObjectFloatMap<K> extends androidx.collection.ObjectFloatMap<K> {
+ ctor public MutableObjectFloatMap();
+ ctor public MutableObjectFloatMap(optional int initialCapacity);
+ method public void clear();
+ method public inline float getOrPut(K key, kotlin.jvm.functions.Function0<java.lang.Float> defaultValue);
+ method public inline operator void minusAssign(androidx.collection.ScatterSet<K> keys);
+ method public inline operator void minusAssign(Iterable<? extends K> keys);
+ method public inline operator void minusAssign(K key);
+ method public inline operator void minusAssign(K[] keys);
+ method public inline operator void minusAssign(kotlin.sequences.Sequence<? extends K> keys);
+ method public inline operator void plusAssign(androidx.collection.ObjectFloatMap<K> from);
+ method public void put(K key, float value);
+ method public float put(K key, float value, float default);
+ method public void putAll(androidx.collection.ObjectFloatMap<K> from);
+ method public void remove(K key);
+ method public boolean remove(K key, float value);
+ method public inline void removeIf(kotlin.jvm.functions.Function2<? super K,? super java.lang.Float,java.lang.Boolean> predicate);
+ method public operator void set(K key, float value);
+ method public int trim();
+ }
+
+ public final class MutableObjectIntMap<K> extends androidx.collection.ObjectIntMap<K> {
+ ctor public MutableObjectIntMap();
+ ctor public MutableObjectIntMap(optional int initialCapacity);
+ method public void clear();
+ method public inline int getOrPut(K key, kotlin.jvm.functions.Function0<java.lang.Integer> defaultValue);
+ method public inline operator void minusAssign(androidx.collection.ScatterSet<K> keys);
+ method public inline operator void minusAssign(Iterable<? extends K> keys);
+ method public inline operator void minusAssign(K key);
+ method public inline operator void minusAssign(K[] keys);
+ method public inline operator void minusAssign(kotlin.sequences.Sequence<? extends K> keys);
+ method public inline operator void plusAssign(androidx.collection.ObjectIntMap<K> from);
+ method public void put(K key, int value);
+ method public int put(K key, int value, int default);
+ method public void putAll(androidx.collection.ObjectIntMap<K> from);
+ method public void remove(K key);
+ method public boolean remove(K key, int value);
+ method public inline void removeIf(kotlin.jvm.functions.Function2<? super K,? super java.lang.Integer,java.lang.Boolean> predicate);
+ method public operator void set(K key, int value);
+ method public int trim();
+ }
+
+ public final class MutableObjectList<E> extends androidx.collection.ObjectList<E> {
+ ctor public MutableObjectList();
+ ctor public MutableObjectList(optional int initialCapacity);
+ method public boolean add(E element);
+ method public void add(@IntRange(from=0L) int index, E element);
+ method public boolean addAll(androidx.collection.ObjectList<E> elements);
+ method public boolean addAll(androidx.collection.ScatterSet<E> elements);
+ method public boolean addAll(E[] elements);
+ method public boolean addAll(@IntRange(from=0L) int index, androidx.collection.ObjectList<E> elements);
+ method public boolean addAll(@IntRange(from=0L) int index, E[] elements);
+ method public boolean addAll(@IntRange(from=0L) int index, java.util.Collection<? extends E> elements);
+ method public boolean addAll(Iterable<? extends E> elements);
+ method public boolean addAll(java.util.List<? extends E> elements);
+ method public boolean addAll(kotlin.sequences.Sequence<? extends E> elements);
+ method public java.util.List<E> asList();
+ method public java.util.List<E> asMutableList();
+ method public void clear();
+ method public inline void ensureCapacity(int capacity);
+ method public inline int getCapacity();
+ method public operator void minusAssign(androidx.collection.ObjectList<E> elements);
+ method public operator void minusAssign(androidx.collection.ScatterSet<E> elements);
+ method public inline operator void minusAssign(E element);
+ method public operator void minusAssign(E[] elements);
+ method public operator void minusAssign(Iterable<? extends E> elements);
+ method public operator void minusAssign(java.util.List<? extends E> elements);
+ method public operator void minusAssign(kotlin.sequences.Sequence<? extends E> elements);
+ method public operator void plusAssign(androidx.collection.ObjectList<E> elements);
+ method public operator void plusAssign(androidx.collection.ScatterSet<E> elements);
+ method public inline operator void plusAssign(E element);
+ method public operator void plusAssign(E[] elements);
+ method public operator void plusAssign(Iterable<? extends E> elements);
+ method public operator void plusAssign(java.util.List<? extends E> elements);
+ method public operator void plusAssign(kotlin.sequences.Sequence<? extends E> elements);
+ method public boolean remove(E element);
+ method public boolean removeAll(androidx.collection.ObjectList<E> elements);
+ method public boolean removeAll(androidx.collection.ScatterSet<E> elements);
+ method public boolean removeAll(E[] elements);
+ method public boolean removeAll(Iterable<? extends E> elements);
+ method public boolean removeAll(java.util.List<? extends E> elements);
+ method public boolean removeAll(kotlin.sequences.Sequence<? extends E> elements);
+ method public E removeAt(@IntRange(from=0L) int index);
+ method public inline void removeIf(kotlin.jvm.functions.Function1<? super E,java.lang.Boolean> predicate);
+ method public void removeRange(@IntRange(from=0L) int start, @IntRange(from=0L) int end);
+ method public boolean retainAll(androidx.collection.ObjectList<E> elements);
+ method public boolean retainAll(E[] elements);
+ method public boolean retainAll(Iterable<? extends E> elements);
+ method public boolean retainAll(java.util.Collection<? extends E> elements);
+ method public boolean retainAll(kotlin.sequences.Sequence<? extends E> elements);
+ method public operator E set(@IntRange(from=0L) int index, E element);
+ method public void trim(optional int minCapacity);
+ property public final inline int capacity;
+ }
+
+ public final class MutableObjectLongMap<K> extends androidx.collection.ObjectLongMap<K> {
+ ctor public MutableObjectLongMap();
+ ctor public MutableObjectLongMap(optional int initialCapacity);
+ method public void clear();
+ method public inline long getOrPut(K key, kotlin.jvm.functions.Function0<java.lang.Long> defaultValue);
+ method public inline operator void minusAssign(androidx.collection.ScatterSet<K> keys);
+ method public inline operator void minusAssign(Iterable<? extends K> keys);
+ method public inline operator void minusAssign(K key);
+ method public inline operator void minusAssign(K[] keys);
+ method public inline operator void minusAssign(kotlin.sequences.Sequence<? extends K> keys);
+ method public inline operator void plusAssign(androidx.collection.ObjectLongMap<K> from);
+ method public void put(K key, long value);
+ method public long put(K key, long value, long default);
+ method public void putAll(androidx.collection.ObjectLongMap<K> from);
+ method public void remove(K key);
+ method public boolean remove(K key, long value);
+ method public inline void removeIf(kotlin.jvm.functions.Function2<? super K,? super java.lang.Long,java.lang.Boolean> predicate);
+ method public operator void set(K key, long value);
+ method public int trim();
+ }
+
+ public final class MutableOrderedScatterSet<E> extends androidx.collection.OrderedScatterSet<E> {
+ ctor public MutableOrderedScatterSet();
+ ctor public MutableOrderedScatterSet(optional int initialCapacity);
+ method public boolean add(E element);
+ method public boolean addAll(androidx.collection.ObjectList<E> elements);
+ method public boolean addAll(androidx.collection.OrderedScatterSet<E> elements);
+ method public boolean addAll(androidx.collection.ScatterSet<E> elements);
+ method public boolean addAll(E[] elements);
+ method public boolean addAll(Iterable<? extends E> elements);
+ method public boolean addAll(kotlin.sequences.Sequence<? extends E> elements);
+ method public java.util.Set<E> asMutableSet();
+ method public void clear();
+ method public operator void minusAssign(androidx.collection.ObjectList<E> elements);
+ method public operator void minusAssign(androidx.collection.OrderedScatterSet<E> elements);
+ method public operator void minusAssign(androidx.collection.ScatterSet<E> elements);
+ method public operator void minusAssign(E element);
+ method public operator void minusAssign(E[] elements);
+ method public operator void minusAssign(Iterable<? extends E> elements);
+ method public operator void minusAssign(kotlin.sequences.Sequence<? extends E> elements);
+ method public operator void plusAssign(androidx.collection.ObjectList<E> elements);
+ method public operator void plusAssign(androidx.collection.OrderedScatterSet<E> elements);
+ method public operator void plusAssign(androidx.collection.ScatterSet<E> elements);
+ method public operator void plusAssign(E element);
+ method public operator void plusAssign(E[] elements);
+ method public operator void plusAssign(Iterable<? extends E> elements);
+ method public operator void plusAssign(kotlin.sequences.Sequence<? extends E> elements);
+ method public boolean remove(E element);
+ method public boolean removeAll(androidx.collection.ObjectList<E> elements);
+ method public boolean removeAll(androidx.collection.OrderedScatterSet<E> elements);
+ method public boolean removeAll(androidx.collection.ScatterSet<E> elements);
+ method public boolean removeAll(E[] elements);
+ method public boolean removeAll(Iterable<? extends E> elements);
+ method public boolean removeAll(kotlin.sequences.Sequence<? extends E> elements);
+ method public inline void removeIf(kotlin.jvm.functions.Function1<? super E,java.lang.Boolean> predicate);
+ method public boolean retainAll(androidx.collection.OrderedScatterSet<E> elements);
+ method public boolean retainAll(androidx.collection.ScatterSet<E> elements);
+ method public boolean retainAll(java.util.Collection<? extends E> elements);
+ method public inline boolean retainAll(kotlin.jvm.functions.Function1<? super E,java.lang.Boolean> predicate);
+ method @IntRange(from=0L) public int trim();
+ method public void trimToSize(int maxSize);
+ }
+
+ public final class MutableScatterMap<K, V> extends androidx.collection.ScatterMap<K,V> {
+ ctor public MutableScatterMap();
+ ctor public MutableScatterMap(optional int initialCapacity);
+ method public java.util.Map<K,V> asMutableMap();
+ method public void clear();
+ method public inline V compute(K key, kotlin.jvm.functions.Function2<? super K,? super V?,? extends V> computeBlock);
+ method public inline V getOrPut(K key, kotlin.jvm.functions.Function0<? extends V> defaultValue);
+ method public inline operator void minusAssign(androidx.collection.ObjectList<K> keys);
+ method public inline operator void minusAssign(androidx.collection.ScatterSet<K> keys);
+ method public inline operator void minusAssign(Iterable<? extends K> keys);
+ method public inline operator void minusAssign(K key);
+ method public inline operator void minusAssign(K[] keys);
+ method public inline operator void minusAssign(kotlin.sequences.Sequence<? extends K> keys);
+ method public inline operator void plusAssign(androidx.collection.ScatterMap<K,V> from);
+ method public inline operator void plusAssign(Iterable<? extends kotlin.Pair<? extends K,? extends V>> pairs);
+ method public inline operator void plusAssign(java.util.Map<K,? extends V> from);
+ method public inline operator void plusAssign(kotlin.Pair<? extends K,? extends V> pair);
+ method public inline operator void plusAssign(kotlin.Pair<? extends K,? extends V>[] pairs);
+ method public inline operator void plusAssign(kotlin.sequences.Sequence<? extends kotlin.Pair<? extends K,? extends V>> pairs);
+ method public V? put(K key, V value);
+ method public void putAll(androidx.collection.ScatterMap<K,V> from);
+ method public void putAll(Iterable<? extends kotlin.Pair<? extends K,? extends V>> pairs);
+ method public void putAll(java.util.Map<K,? extends V> from);
+ method public void putAll(kotlin.Pair<? extends K,? extends V>[] pairs);
+ method public void putAll(kotlin.sequences.Sequence<? extends kotlin.Pair<? extends K,? extends V>> pairs);
+ method public V? remove(K key);
+ method public boolean remove(K key, V value);
+ method public inline void removeIf(kotlin.jvm.functions.Function2<? super K,? super V,java.lang.Boolean> predicate);
+ method public operator void set(K key, V value);
+ method public int trim();
+ }
+
+ public final class MutableScatterSet<E> extends androidx.collection.ScatterSet<E> {
+ ctor public MutableScatterSet();
+ ctor public MutableScatterSet(optional int initialCapacity);
+ method public boolean add(E element);
+ method public boolean addAll(androidx.collection.ObjectList<E> elements);
+ method public boolean addAll(androidx.collection.OrderedScatterSet<E> elements);
+ method public boolean addAll(androidx.collection.ScatterSet<E> elements);
+ method public boolean addAll(E[] elements);
+ method public boolean addAll(Iterable<? extends E> elements);
+ method public boolean addAll(kotlin.sequences.Sequence<? extends E> elements);
+ method public java.util.Set<E> asMutableSet();
+ method public void clear();
+ method public operator void minusAssign(androidx.collection.ObjectList<E> elements);
+ method public operator void minusAssign(androidx.collection.OrderedScatterSet<E> elements);
+ method public operator void minusAssign(androidx.collection.ScatterSet<E> elements);
+ method public operator void minusAssign(E element);
+ method public operator void minusAssign(E[] elements);
+ method public operator void minusAssign(Iterable<? extends E> elements);
+ method public operator void minusAssign(kotlin.sequences.Sequence<? extends E> elements);
+ method public operator void plusAssign(androidx.collection.ObjectList<E> elements);
+ method public operator void plusAssign(androidx.collection.OrderedScatterSet<E> elements);
+ method public operator void plusAssign(androidx.collection.ScatterSet<E> elements);
+ method public operator void plusAssign(E element);
+ method public operator void plusAssign(E[] elements);
+ method public operator void plusAssign(Iterable<? extends E> elements);
+ method public operator void plusAssign(kotlin.sequences.Sequence<? extends E> elements);
+ method public boolean remove(E element);
+ method public boolean removeAll(androidx.collection.ObjectList<E> elements);
+ method public boolean removeAll(androidx.collection.OrderedScatterSet<E> elements);
+ method public boolean removeAll(androidx.collection.ScatterSet<E> elements);
+ method public boolean removeAll(E[] elements);
+ method public boolean removeAll(Iterable<? extends E> elements);
+ method public boolean removeAll(kotlin.sequences.Sequence<? extends E> elements);
+ method public inline void removeIf(kotlin.jvm.functions.Function1<? super E,java.lang.Boolean> predicate);
+ method public boolean retainAll(androidx.collection.OrderedScatterSet<E> elements);
+ method public boolean retainAll(androidx.collection.ScatterSet<E> elements);
+ method public boolean retainAll(java.util.Collection<? extends E> elements);
+ method public boolean retainAll(kotlin.jvm.functions.Function1<? super E,java.lang.Boolean> predicate);
+ method @IntRange(from=0L) public int trim();
+ }
+
+ public abstract sealed class ObjectFloatMap<K> {
+ method public final inline boolean all(kotlin.jvm.functions.Function2<? super K,? super java.lang.Float,java.lang.Boolean> predicate);
+ method public final boolean any();
+ method public final inline boolean any(kotlin.jvm.functions.Function2<? super K,? super java.lang.Float,java.lang.Boolean> predicate);
+ method public final inline operator boolean contains(K key);
+ method public final boolean containsKey(K key);
+ method public final boolean containsValue(float value);
+ method public final int count();
+ method public final inline int count(kotlin.jvm.functions.Function2<? super K,? super java.lang.Float,java.lang.Boolean> predicate);
+ method public final inline void forEach(kotlin.jvm.functions.Function2<? super K,? super java.lang.Float,kotlin.Unit> block);
+ method public final inline void forEachKey(kotlin.jvm.functions.Function1<? super K,kotlin.Unit> block);
+ method public final inline void forEachValue(kotlin.jvm.functions.Function1<? super java.lang.Float,kotlin.Unit> block);
+ method public final operator float get(K key);
+ method public final int getCapacity();
+ method public final float getOrDefault(K key, float defaultValue);
+ method public final inline float getOrElse(K key, kotlin.jvm.functions.Function0<java.lang.Float> defaultValue);
+ method public final int getSize();
+ method public final boolean isEmpty();
+ method public final boolean isNotEmpty();
+ method public final String joinToString();
+ method public final String joinToString(optional CharSequence separator);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2<? super K,? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2<? super K,? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2<? super K,? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2<? super K,? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2<? super K,? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(kotlin.jvm.functions.Function2<? super K,? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final boolean none();
+ property public final int capacity;
+ property public final int size;
+ }
+
+ public final class ObjectFloatMapKt {
+ method public static inline <K> androidx.collection.ObjectFloatMap<K> buildObjectFloatMap(int initialCapacity, kotlin.jvm.functions.Function1<? super androidx.collection.MutableObjectFloatMap<K>,kotlin.Unit> builderAction);
+ method public static inline <K> androidx.collection.ObjectFloatMap<K> buildObjectFloatMap(kotlin.jvm.functions.Function1<? super androidx.collection.MutableObjectFloatMap<K>,kotlin.Unit> builderAction);
+ method public static <K> androidx.collection.ObjectFloatMap<K> emptyObjectFloatMap();
+ method public static <K> androidx.collection.MutableObjectFloatMap<K> mutableObjectFloatMapOf();
+ method public static <K> androidx.collection.MutableObjectFloatMap<K> mutableObjectFloatMapOf(K key1, float value1);
+ method public static <K> androidx.collection.MutableObjectFloatMap<K> mutableObjectFloatMapOf(K key1, float value1, K key2, float value2);
+ method public static <K> androidx.collection.MutableObjectFloatMap<K> mutableObjectFloatMapOf(K key1, float value1, K key2, float value2, K key3, float value3);
+ method public static <K> androidx.collection.MutableObjectFloatMap<K> mutableObjectFloatMapOf(K key1, float value1, K key2, float value2, K key3, float value3, K key4, float value4);
+ method public static <K> androidx.collection.MutableObjectFloatMap<K> mutableObjectFloatMapOf(K key1, float value1, K key2, float value2, K key3, float value3, K key4, float value4, K key5, float value5);
+ method public static <K> androidx.collection.ObjectFloatMap<K> objectFloatMap();
+ method public static <K> androidx.collection.ObjectFloatMap<K> objectFloatMapOf(K key1, float value1);
+ method public static <K> androidx.collection.ObjectFloatMap<K> objectFloatMapOf(K key1, float value1, K key2, float value2);
+ method public static <K> androidx.collection.ObjectFloatMap<K> objectFloatMapOf(K key1, float value1, K key2, float value2, K key3, float value3);
+ method public static <K> androidx.collection.ObjectFloatMap<K> objectFloatMapOf(K key1, float value1, K key2, float value2, K key3, float value3, K key4, float value4);
+ method public static <K> androidx.collection.ObjectFloatMap<K> objectFloatMapOf(K key1, float value1, K key2, float value2, K key3, float value3, K key4, float value4, K key5, float value5);
+ }
+
+ public abstract sealed class ObjectIntMap<K> {
+ method public final inline boolean all(kotlin.jvm.functions.Function2<? super K,? super java.lang.Integer,java.lang.Boolean> predicate);
+ method public final boolean any();
+ method public final inline boolean any(kotlin.jvm.functions.Function2<? super K,? super java.lang.Integer,java.lang.Boolean> predicate);
+ method public final inline operator boolean contains(K key);
+ method public final boolean containsKey(K key);
+ method public final boolean containsValue(int value);
+ method public final int count();
+ method public final inline int count(kotlin.jvm.functions.Function2<? super K,? super java.lang.Integer,java.lang.Boolean> predicate);
+ method public final inline void forEach(kotlin.jvm.functions.Function2<? super K,? super java.lang.Integer,kotlin.Unit> block);
+ method public final inline void forEachKey(kotlin.jvm.functions.Function1<? super K,kotlin.Unit> block);
+ method public final inline void forEachValue(kotlin.jvm.functions.Function1<? super java.lang.Integer,kotlin.Unit> block);
+ method public final operator int get(K key);
+ method public final int getCapacity();
+ method public final int getOrDefault(K key, int defaultValue);
+ method public final inline int getOrElse(K key, kotlin.jvm.functions.Function0<java.lang.Integer> defaultValue);
+ method public final int getSize();
+ method public final boolean isEmpty();
+ method public final boolean isNotEmpty();
+ method public final String joinToString();
+ method public final String joinToString(optional CharSequence separator);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2<? super K,? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2<? super K,? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2<? super K,? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2<? super K,? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2<? super K,? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(kotlin.jvm.functions.Function2<? super K,? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final boolean none();
+ property public final int capacity;
+ property public final int size;
+ }
+
+ public final class ObjectIntMapKt {
+ method public static inline <K> androidx.collection.ObjectIntMap<K> buildObjectIntMap(int initialCapacity, kotlin.jvm.functions.Function1<? super androidx.collection.MutableObjectIntMap<K>,kotlin.Unit> builderAction);
+ method public static inline <K> androidx.collection.ObjectIntMap<K> buildObjectIntMap(kotlin.jvm.functions.Function1<? super androidx.collection.MutableObjectIntMap<K>,kotlin.Unit> builderAction);
+ method public static <K> androidx.collection.ObjectIntMap<K> emptyObjectIntMap();
+ method public static <K> androidx.collection.MutableObjectIntMap<K> mutableObjectIntMapOf();
+ method public static <K> androidx.collection.MutableObjectIntMap<K> mutableObjectIntMapOf(K key1, int value1);
+ method public static <K> androidx.collection.MutableObjectIntMap<K> mutableObjectIntMapOf(K key1, int value1, K key2, int value2);
+ method public static <K> androidx.collection.MutableObjectIntMap<K> mutableObjectIntMapOf(K key1, int value1, K key2, int value2, K key3, int value3);
+ method public static <K> androidx.collection.MutableObjectIntMap<K> mutableObjectIntMapOf(K key1, int value1, K key2, int value2, K key3, int value3, K key4, int value4);
+ method public static <K> androidx.collection.MutableObjectIntMap<K> mutableObjectIntMapOf(K key1, int value1, K key2, int value2, K key3, int value3, K key4, int value4, K key5, int value5);
+ method public static <K> androidx.collection.ObjectIntMap<K> objectIntMap();
+ method public static <K> androidx.collection.ObjectIntMap<K> objectIntMapOf(K key1, int value1);
+ method public static <K> androidx.collection.ObjectIntMap<K> objectIntMapOf(K key1, int value1, K key2, int value2);
+ method public static <K> androidx.collection.ObjectIntMap<K> objectIntMapOf(K key1, int value1, K key2, int value2, K key3, int value3);
+ method public static <K> androidx.collection.ObjectIntMap<K> objectIntMapOf(K key1, int value1, K key2, int value2, K key3, int value3, K key4, int value4);
+ method public static <K> androidx.collection.ObjectIntMap<K> objectIntMapOf(K key1, int value1, K key2, int value2, K key3, int value3, K key4, int value4, K key5, int value5);
+ }
+
+ public abstract sealed class ObjectList<E> {
+ method public final boolean any();
+ method public final inline boolean any(kotlin.jvm.functions.Function1<? super E,java.lang.Boolean> predicate);
+ method public abstract java.util.List<E> asList();
+ method public final operator boolean contains(E element);
+ method public final boolean containsAll(androidx.collection.ObjectList<E> elements);
+ method public final boolean containsAll(E[] elements);
+ method public final boolean containsAll(Iterable<? extends E> elements);
+ method public final boolean containsAll(java.util.List<? extends E> elements);
+ method public final int count();
+ method public final inline int count(kotlin.jvm.functions.Function1<? super E,java.lang.Boolean> predicate);
+ method public final E elementAt(@IntRange(from=0L) int index);
+ method public final inline E elementAtOrElse(@IntRange(from=0L) int index, kotlin.jvm.functions.Function1<? super java.lang.Integer,? extends E> defaultValue);
+ method public final E first();
+ method public final inline E first(kotlin.jvm.functions.Function1<? super E,java.lang.Boolean> predicate);
+ method public final inline E? firstOrNull();
+ method public final inline E? firstOrNull(kotlin.jvm.functions.Function1<? super E,java.lang.Boolean> predicate);
+ method public final inline <R> R fold(R initial, kotlin.jvm.functions.Function2<? super R,? super E,? extends R> operation);
+ method public final inline <R> R foldIndexed(R initial, kotlin.jvm.functions.Function3<? super java.lang.Integer,? super R,? super E,? extends R> operation);
+ method public final inline <R> R foldRight(R initial, kotlin.jvm.functions.Function2<? super E,? super R,? extends R> operation);
+ method public final inline <R> R foldRightIndexed(R initial, kotlin.jvm.functions.Function3<? super java.lang.Integer,? super E,? super R,? extends R> operation);
+ method public final inline void forEach(kotlin.jvm.functions.Function1<? super E,kotlin.Unit> block);
+ method public final inline void forEachIndexed(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super E,kotlin.Unit> block);
+ method public final inline void forEachReversed(kotlin.jvm.functions.Function1<? super E,kotlin.Unit> block);
+ method public final inline void forEachReversedIndexed(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super E,kotlin.Unit> block);
+ method public final operator E get(@IntRange(from=0L) int index);
+ method public final inline kotlin.ranges.IntRange getIndices();
+ method @IntRange(from=-1L) public final inline int getLastIndex();
+ method @IntRange(from=0L) public final int getSize();
+ method public final int indexOf(E element);
+ method public final inline int indexOfFirst(kotlin.jvm.functions.Function1<? super E,java.lang.Boolean> predicate);
+ method public final inline int indexOfLast(kotlin.jvm.functions.Function1<? super E,java.lang.Boolean> predicate);
+ method public final boolean isEmpty();
+ method public final boolean isNotEmpty();
+ method public final String joinToString();
+ method public final String joinToString(optional CharSequence separator);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, optional kotlin.jvm.functions.Function1<? super E,? extends java.lang.CharSequence>? transform);
+ method public final E last();
+ method public final inline E last(kotlin.jvm.functions.Function1<? super E,java.lang.Boolean> predicate);
+ method public final int lastIndexOf(E element);
+ method public final inline E? lastOrNull();
+ method public final inline E? lastOrNull(kotlin.jvm.functions.Function1<? super E,java.lang.Boolean> predicate);
+ method public final boolean none();
+ method public final inline boolean reversedAny(kotlin.jvm.functions.Function1<? super E,java.lang.Boolean> predicate);
+ property public final inline kotlin.ranges.IntRange indices;
+ property @IntRange(from=-1L) public final inline int lastIndex;
+ property @IntRange(from=0L) public final int size;
+ }
+
+ public final class ObjectListKt {
+ method public static <E> androidx.collection.ObjectList<E> emptyObjectList();
+ method public static inline <E> androidx.collection.MutableObjectList<E> mutableObjectListOf();
+ method public static <E> androidx.collection.MutableObjectList<E> mutableObjectListOf(E element1);
+ method public static <E> androidx.collection.MutableObjectList<E> mutableObjectListOf(E element1, E element2);
+ method public static <E> androidx.collection.MutableObjectList<E> mutableObjectListOf(E element1, E element2, E element3);
+ method public static inline <E> androidx.collection.MutableObjectList<E> mutableObjectListOf(E... elements);
+ method public static <E> androidx.collection.ObjectList<E> objectListOf();
+ method public static <E> androidx.collection.ObjectList<E> objectListOf(E element1);
+ method public static <E> androidx.collection.ObjectList<E> objectListOf(E element1, E element2);
+ method public static <E> androidx.collection.ObjectList<E> objectListOf(E element1, E element2, E element3);
+ method public static <E> androidx.collection.ObjectList<E> objectListOf(E... elements);
+ }
+
+ public abstract sealed class ObjectLongMap<K> {
+ method public final inline boolean all(kotlin.jvm.functions.Function2<? super K,? super java.lang.Long,java.lang.Boolean> predicate);
+ method public final boolean any();
+ method public final inline boolean any(kotlin.jvm.functions.Function2<? super K,? super java.lang.Long,java.lang.Boolean> predicate);
+ method public final inline operator boolean contains(K key);
+ method public final boolean containsKey(K key);
+ method public final boolean containsValue(long value);
+ method public final int count();
+ method public final inline int count(kotlin.jvm.functions.Function2<? super K,? super java.lang.Long,java.lang.Boolean> predicate);
+ method public final inline void forEach(kotlin.jvm.functions.Function2<? super K,? super java.lang.Long,kotlin.Unit> block);
+ method public final inline void forEachKey(kotlin.jvm.functions.Function1<? super K,kotlin.Unit> block);
+ method public final inline void forEachValue(kotlin.jvm.functions.Function1<? super java.lang.Long,kotlin.Unit> block);
+ method public final operator long get(K key);
+ method public final int getCapacity();
+ method public final long getOrDefault(K key, long defaultValue);
+ method public final inline long getOrElse(K key, kotlin.jvm.functions.Function0<java.lang.Long> defaultValue);
+ method public final int getSize();
+ method public final boolean isEmpty();
+ method public final boolean isNotEmpty();
+ method public final String joinToString();
+ method public final String joinToString(optional CharSequence separator);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2<? super K,? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2<? super K,? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2<? super K,? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2<? super K,? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2<? super K,? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(kotlin.jvm.functions.Function2<? super K,? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final boolean none();
+ property public final int capacity;
+ property public final int size;
+ }
+
+ public final class ObjectLongMapKt {
+ method public static inline <K> androidx.collection.ObjectLongMap<K> buildObjectLongMap(int initialCapacity, kotlin.jvm.functions.Function1<? super androidx.collection.MutableObjectLongMap<K>,kotlin.Unit> builderAction);
+ method public static inline <K> androidx.collection.ObjectLongMap<K> buildObjectLongMap(kotlin.jvm.functions.Function1<? super androidx.collection.MutableObjectLongMap<K>,kotlin.Unit> builderAction);
+ method public static <K> androidx.collection.ObjectLongMap<K> emptyObjectLongMap();
+ method public static <K> androidx.collection.MutableObjectLongMap<K> mutableObjectLongMapOf();
+ method public static <K> androidx.collection.MutableObjectLongMap<K> mutableObjectLongMapOf(K key1, long value1);
+ method public static <K> androidx.collection.MutableObjectLongMap<K> mutableObjectLongMapOf(K key1, long value1, K key2, long value2);
+ method public static <K> androidx.collection.MutableObjectLongMap<K> mutableObjectLongMapOf(K key1, long value1, K key2, long value2, K key3, long value3);
+ method public static <K> androidx.collection.MutableObjectLongMap<K> mutableObjectLongMapOf(K key1, long value1, K key2, long value2, K key3, long value3, K key4, long value4);
+ method public static <K> androidx.collection.MutableObjectLongMap<K> mutableObjectLongMapOf(K key1, long value1, K key2, long value2, K key3, long value3, K key4, long value4, K key5, long value5);
+ method public static <K> androidx.collection.ObjectLongMap<K> objectLongMap();
+ method public static <K> androidx.collection.ObjectLongMap<K> objectLongMapOf(K key1, long value1);
+ method public static <K> androidx.collection.ObjectLongMap<K> objectLongMapOf(K key1, long value1, K key2, long value2);
+ method public static <K> androidx.collection.ObjectLongMap<K> objectLongMapOf(K key1, long value1, K key2, long value2, K key3, long value3);
+ method public static <K> androidx.collection.ObjectLongMap<K> objectLongMapOf(K key1, long value1, K key2, long value2, K key3, long value3, K key4, long value4);
+ method public static <K> androidx.collection.ObjectLongMap<K> objectLongMapOf(K key1, long value1, K key2, long value2, K key3, long value3, K key4, long value4, K key5, long value5);
+ }
+
+ public abstract sealed class OrderedScatterSet<E> {
+ method public final inline boolean all(kotlin.jvm.functions.Function1<? super E,java.lang.Boolean> predicate);
+ method public final boolean any();
+ method public final inline boolean any(kotlin.jvm.functions.Function1<? super E,java.lang.Boolean> predicate);
+ method public final java.util.Set<E> asSet();
+ method public final operator boolean contains(E element);
+ method @IntRange(from=0L) public final int count();
+ method @IntRange(from=0L) public final inline int count(kotlin.jvm.functions.Function1<? super E,java.lang.Boolean> predicate);
+ method public final E first();
+ method public final inline E first(kotlin.jvm.functions.Function1<? super E,java.lang.Boolean> predicate);
+ method public final inline E? firstOrNull(kotlin.jvm.functions.Function1<? super E,java.lang.Boolean> predicate);
+ method public final inline void forEach(kotlin.jvm.functions.Function1<? super E,kotlin.Unit> block);
+ method public final inline void forEachReverse(kotlin.jvm.functions.Function1<? super E,kotlin.Unit> block);
+ method @IntRange(from=0L) public final int getCapacity();
+ method @IntRange(from=0L) public final int getSize();
+ method public final boolean isEmpty();
+ method public final boolean isNotEmpty();
+ method public final String joinToString();
+ method public final String joinToString(optional CharSequence separator);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, optional kotlin.jvm.functions.Function1<? super E,? extends java.lang.CharSequence>? transform);
+ method public final E last();
+ method public final inline E last(kotlin.jvm.functions.Function1<? super E,java.lang.Boolean> predicate);
+ method public final inline E? lastOrNull(kotlin.jvm.functions.Function1<? super E,java.lang.Boolean> predicate);
+ method public final boolean none();
+ method public final inline java.util.List<E> toList();
+ property @IntRange(from=0L) public final int capacity;
+ property @IntRange(from=0L) public final int size;
+ }
+
+ public final class OrderedScatterSetKt {
+ method public static <E> androidx.collection.OrderedScatterSet<E> emptyOrderedScatterSet();
+ method public static <E> androidx.collection.MutableOrderedScatterSet<E> mutableOrderedScatterSetOf();
+ method public static <E> androidx.collection.MutableOrderedScatterSet<E> mutableOrderedScatterSetOf(E element1);
+ method public static <E> androidx.collection.MutableOrderedScatterSet<E> mutableOrderedScatterSetOf(E element1, E element2);
+ method public static <E> androidx.collection.MutableOrderedScatterSet<E> mutableOrderedScatterSetOf(E element1, E element2, E element3);
+ method public static <E> androidx.collection.MutableOrderedScatterSet<E> mutableOrderedScatterSetOf(E... elements);
+ method public static <E> androidx.collection.OrderedScatterSet<E> orderedScatterSetOf();
+ method public static <E> androidx.collection.OrderedScatterSet<E> orderedScatterSetOf(E element1);
+ method public static <E> androidx.collection.OrderedScatterSet<E> orderedScatterSetOf(E element1, E element2);
+ method public static <E> androidx.collection.OrderedScatterSet<E> orderedScatterSetOf(E element1, E element2, E element3);
+ method public static <E> androidx.collection.OrderedScatterSet<E> orderedScatterSetOf(E... elements);
+ }
+
+ public abstract sealed class ScatterMap<K, V> {
+ method public final inline boolean all(kotlin.jvm.functions.Function2<? super K,? super V,java.lang.Boolean> predicate);
+ method public final boolean any();
+ method public final inline boolean any(kotlin.jvm.functions.Function2<? super K,? super V,java.lang.Boolean> predicate);
+ method public final java.util.Map<K,V> asMap();
+ method public final operator boolean contains(K key);
+ method public final boolean containsKey(K key);
+ method public final boolean containsValue(V value);
+ method public final int count();
+ method public final inline int count(kotlin.jvm.functions.Function2<? super K,? super V,java.lang.Boolean> predicate);
+ method public final inline void forEach(kotlin.jvm.functions.Function2<? super K,? super V,kotlin.Unit> block);
+ method public final inline void forEachKey(kotlin.jvm.functions.Function1<? super K,kotlin.Unit> block);
+ method public final inline void forEachValue(kotlin.jvm.functions.Function1<? super V,kotlin.Unit> block);
+ method public final operator V? get(K key);
+ method public final int getCapacity();
+ method public final V getOrDefault(K key, V defaultValue);
+ method public final inline V getOrElse(K key, kotlin.jvm.functions.Function0<? extends V> defaultValue);
+ method public final int getSize();
+ method public final boolean isEmpty();
+ method public final boolean isNotEmpty();
+ method public final String joinToString();
+ method public final String joinToString(optional CharSequence separator);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, optional kotlin.jvm.functions.Function2<? super K,? super V,? extends java.lang.CharSequence>? transform);
+ method public final boolean none();
+ property public final int capacity;
+ property public final int size;
+ }
+
+ public final class ScatterMapKt {
+ method public static <K, V> androidx.collection.ScatterMap<K,V> emptyScatterMap();
+ method public static <K, V> androidx.collection.MutableScatterMap<K,V> mutableScatterMapOf();
+ method public static <K, V> androidx.collection.MutableScatterMap<K,V> mutableScatterMapOf(kotlin.Pair<? extends K,? extends V>... pairs);
+ }
+
+ public abstract sealed class ScatterSet<E> {
+ method public final inline boolean all(kotlin.jvm.functions.Function1<? super E,java.lang.Boolean> predicate);
+ method public final boolean any();
+ method public final inline boolean any(kotlin.jvm.functions.Function1<? super E,java.lang.Boolean> predicate);
+ method public final java.util.Set<E> asSet();
+ method public final operator boolean contains(E element);
+ method @IntRange(from=0L) public final int count();
+ method @IntRange(from=0L) public final inline int count(kotlin.jvm.functions.Function1<? super E,java.lang.Boolean> predicate);
+ method public final E first();
+ method public final inline E first(kotlin.jvm.functions.Function1<? super E,java.lang.Boolean> predicate);
+ method public final inline E? firstOrNull(kotlin.jvm.functions.Function1<? super E,java.lang.Boolean> predicate);
+ method public final inline void forEach(kotlin.jvm.functions.Function1<? super E,kotlin.Unit> block);
+ method @IntRange(from=0L) public final int getCapacity();
+ method @IntRange(from=0L) public final int getSize();
+ method public final boolean isEmpty();
+ method public final boolean isNotEmpty();
+ method public final String joinToString();
+ method public final String joinToString(optional CharSequence separator);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, optional kotlin.jvm.functions.Function1<? super E,? extends java.lang.CharSequence>? transform);
+ method public final boolean none();
+ property @IntRange(from=0L) public final int capacity;
+ property @IntRange(from=0L) public final int size;
+ }
+
+ public final class ScatterSetKt {
+ method public static <E> androidx.collection.ScatterSet<E> emptyScatterSet();
+ method public static <E> androidx.collection.MutableScatterSet<E> mutableScatterSetOf();
+ method public static <E> androidx.collection.MutableScatterSet<E> mutableScatterSetOf(E element1);
+ method public static <E> androidx.collection.MutableScatterSet<E> mutableScatterSetOf(E element1, E element2);
+ method public static <E> androidx.collection.MutableScatterSet<E> mutableScatterSetOf(E element1, E element2, E element3);
+ method public static <E> androidx.collection.MutableScatterSet<E> mutableScatterSetOf(E... elements);
+ method public static <E> androidx.collection.ScatterSet<E> scatterSetOf();
+ method public static <E> androidx.collection.ScatterSet<E> scatterSetOf(E element1);
+ method public static <E> androidx.collection.ScatterSet<E> scatterSetOf(E element1, E element2);
+ method public static <E> androidx.collection.ScatterSet<E> scatterSetOf(E element1, E element2, E element3);
+ method public static <E> androidx.collection.ScatterSet<E> scatterSetOf(E... elements);
+ }
+
+ public final class SieveCache<K, V> {
+ ctor public SieveCache(@IntRange(from=1L, to=androidx.collection.SieveCacheKt.MaxSize) int maxSize, optional @IntRange(from=0L, to=androidx.collection.SieveCacheKt.MaxSize) int initialCapacity, optional kotlin.jvm.functions.Function2<? super K,? super V,java.lang.Integer> sizeOf, optional kotlin.jvm.functions.Function1<? super K,? extends V?> createValueFromKey, optional kotlin.jvm.functions.Function4<? super K,? super V,? super V?,? super java.lang.Boolean,kotlin.Unit> onEntryRemoved);
+ method public inline boolean all(kotlin.jvm.functions.Function2<? super K,? super V,java.lang.Boolean> predicate);
+ method public boolean any();
+ method public inline boolean any(kotlin.jvm.functions.Function2<? super K,? super V,java.lang.Boolean> predicate);
+ method public operator boolean contains(K key);
+ method public boolean containsKey(K key);
+ method public boolean containsValue(V value);
+ method public int count();
+ method public inline int count(kotlin.jvm.functions.Function2<? super K,? super V,java.lang.Boolean> predicate);
+ method public void evictAll();
+ method public inline void forEach(kotlin.jvm.functions.Function2<? super K,? super V,kotlin.Unit> block);
+ method public inline void forEachKey(kotlin.jvm.functions.Function1<? super K,kotlin.Unit> block);
+ method public inline void forEachValue(kotlin.jvm.functions.Function1<? super V,kotlin.Unit> block);
+ method public operator V? get(K key);
+ method public int getCapacity();
+ method public int getCount();
+ method public int getMaxSize();
+ method public int getSize();
+ method public boolean isEmpty();
+ method public boolean isNotEmpty();
+ method public inline operator void minusAssign(androidx.collection.ObjectList<K> keys);
+ method public inline operator void minusAssign(androidx.collection.ScatterSet<K> keys);
+ method public inline operator void minusAssign(Iterable<? extends K> keys);
+ method public inline operator void minusAssign(K key);
+ method public inline operator void minusAssign(K[] keys);
+ method public inline operator void minusAssign(kotlin.sequences.Sequence<? extends K> keys);
+ method public boolean none();
+ method public inline operator void plusAssign(androidx.collection.ScatterMap<K,V> from);
+ method public inline operator void plusAssign(androidx.collection.SieveCache<K,V> from);
+ method public inline operator void plusAssign(Iterable<? extends kotlin.Pair<? extends K,? extends V>> pairs);
+ method public inline operator void plusAssign(java.util.Map<K,? extends V> from);
+ method public inline operator void plusAssign(kotlin.Pair<? extends K,? extends V> pair);
+ method public inline operator void plusAssign(kotlin.Pair<? extends K,? extends V>[] pairs);
+ method public inline operator void plusAssign(kotlin.sequences.Sequence<? extends kotlin.Pair<? extends K,? extends V>> pairs);
+ method public V? put(K key, V value);
+ method public void putAll(androidx.collection.ScatterMap<K,V> from);
+ method public void putAll(androidx.collection.SieveCache<K,V> from);
+ method public void putAll(Iterable<? extends kotlin.Pair<? extends K,? extends V>> pairs);
+ method public void putAll(java.util.Map<K,? extends V> from);
+ method public void putAll(kotlin.Pair<? extends K,? extends V>[] pairs);
+ method public void putAll(kotlin.sequences.Sequence<? extends kotlin.Pair<? extends K,? extends V>> pairs);
+ method public V? remove(K key);
+ method public boolean remove(K key, V value);
+ method public void removeIf(kotlin.jvm.functions.Function2<? super K,? super V,java.lang.Boolean> predicate);
+ method public void resize(@IntRange(from=1L, to=androidx.collection.SieveCacheKt.MaxSize) int maxSize);
+ method public inline operator void set(K key, V value);
+ method public void trimToSize(int maxSize);
+ property public final int capacity;
+ property public final int count;
+ property public final int maxSize;
+ property public final int size;
+ }
+
+ public class SimpleArrayMap<K, V> {
+ ctor public SimpleArrayMap();
+ ctor public SimpleArrayMap(androidx.collection.SimpleArrayMap<? extends K,? extends V>? map);
+ ctor public SimpleArrayMap(optional int capacity);
+ method public void clear();
+ method public boolean containsKey(K key);
+ method public boolean containsValue(V value);
+ method public void ensureCapacity(int minimumCapacity);
+ method public operator V? get(K key);
+ method public V getOrDefault(Object? key, V defaultValue);
+ method public int indexOfKey(K key);
+ method public boolean isEmpty();
+ method public K keyAt(int index);
+ method public V? put(K key, V value);
+ method public void putAll(androidx.collection.SimpleArrayMap<? extends K,? extends V> map);
+ method public V? putIfAbsent(K key, V value);
+ method public V? remove(K key);
+ method public boolean remove(K key, V value);
+ method public V removeAt(int index);
+ method public V? replace(K key, V value);
+ method public boolean replace(K key, V oldValue, V newValue);
+ method public V setValueAt(int index, V value);
+ method public int size();
+ method public V valueAt(int index);
+ }
+
+ public class SparseArrayCompat<E> implements java.lang.Cloneable {
+ ctor public SparseArrayCompat();
+ ctor public SparseArrayCompat(optional int initialCapacity);
+ method public void append(int key, E value);
+ method public void clear();
+ method public androidx.collection.SparseArrayCompat<E> clone();
+ method public boolean containsKey(int key);
+ method public boolean containsValue(E value);
+ method @Deprecated public void delete(int key);
+ method public operator E? get(int key);
+ method public E get(int key, E defaultValue);
+ method public final boolean getIsEmpty();
+ method public int indexOfKey(int key);
+ method public int indexOfValue(E value);
+ method public boolean isEmpty();
+ method public int keyAt(int index);
+ method public void put(int key, E value);
+ method public void putAll(androidx.collection.SparseArrayCompat<? extends E> other);
+ method public E? putIfAbsent(int key, E value);
+ method public void remove(int key);
+ method public boolean remove(int key, Object? value);
+ method public void removeAt(int index);
+ method public void removeAtRange(int index, int size);
+ method public E? replace(int key, E value);
+ method public boolean replace(int key, E oldValue, E newValue);
+ method public void setValueAt(int index, E value);
+ method public int size();
+ method public E valueAt(int index);
+ property public final boolean isEmpty;
+ }
+
+ public final class SparseArrayKt {
+ method public static inline operator <T> boolean contains(androidx.collection.SparseArrayCompat<T>, int key);
+ method public static inline <T> void forEach(androidx.collection.SparseArrayCompat<T>, kotlin.jvm.functions.Function2<? super java.lang.Integer,? super T,kotlin.Unit> action);
+ method public static inline <T> T getOrDefault(androidx.collection.SparseArrayCompat<T>, int key, T defaultValue);
+ method public static inline <T> T getOrElse(androidx.collection.SparseArrayCompat<T>, int key, kotlin.jvm.functions.Function0<? extends T> defaultValue);
+ method public static inline <T> int getSize(androidx.collection.SparseArrayCompat<T>);
+ method public static inline <T> boolean isNotEmpty(androidx.collection.SparseArrayCompat<T>);
+ method public static <T> kotlin.collections.IntIterator keyIterator(androidx.collection.SparseArrayCompat<T>);
+ method public static operator <T> androidx.collection.SparseArrayCompat<T> plus(androidx.collection.SparseArrayCompat<T>, androidx.collection.SparseArrayCompat<T> other);
+ method @Deprecated public static <T> boolean remove(androidx.collection.SparseArrayCompat<T>, int key, T value);
+ method public static inline operator <T> void set(androidx.collection.SparseArrayCompat<T>, int key, T value);
+ method public static <T> java.util.Iterator<T> valueIterator(androidx.collection.SparseArrayCompat<T>);
+ }
+
+}
+
diff --git a/collection/collection/api/restricted_1.5.0-beta02.txt b/collection/collection/api/restricted_1.5.0-beta02.txt
new file mode 100644
index 0000000..385c7f5
--- /dev/null
+++ b/collection/collection/api/restricted_1.5.0-beta02.txt
@@ -0,0 +1,2627 @@
+// Signature format: 4.0
+package androidx.collection {
+
+ public class ArrayMap<K, V> extends androidx.collection.SimpleArrayMap<K!,V!> implements java.util.Map<K!,V!> {
+ ctor public ArrayMap();
+ ctor public ArrayMap(androidx.collection.SimpleArrayMap?);
+ ctor public ArrayMap(int);
+ method public boolean containsAll(java.util.Collection<? extends java.lang.Object!>);
+ method public boolean containsKey(Object?);
+ method public boolean containsValue(Object?);
+ method public java.util.Set<java.util.Map.Entry<K!,V!>!> entrySet();
+ method public V! get(Object?);
+ method public java.util.Set<K!> keySet();
+ method public void putAll(java.util.Map<? extends K!,? extends V!>);
+ method public V! remove(Object?);
+ method public boolean removeAll(java.util.Collection<? extends java.lang.Object!>);
+ method public boolean retainAll(java.util.Collection<? extends java.lang.Object!>);
+ method public java.util.Collection<V!> values();
+ }
+
+ public final class ArrayMapKt {
+ method public static inline <K, V> androidx.collection.ArrayMap<K,V> arrayMapOf();
+ method public static <K, V> androidx.collection.ArrayMap<K,V> arrayMapOf(kotlin.Pair<? extends K,? extends V>... pairs);
+ }
+
+ public final class ArraySet<E> implements java.util.Collection<E> kotlin.jvm.internal.markers.KMutableCollection kotlin.jvm.internal.markers.KMutableSet java.util.Set<E> {
+ ctor public ArraySet();
+ ctor public ArraySet(androidx.collection.ArraySet<? extends E>? set);
+ ctor public ArraySet(E[]? array);
+ ctor public ArraySet(optional int capacity);
+ ctor public ArraySet(java.util.Collection<? extends E>? set);
+ method public boolean add(E element);
+ method public void addAll(androidx.collection.ArraySet<? extends E> array);
+ method public boolean addAll(java.util.Collection<? extends E> elements);
+ method public void clear();
+ method public operator boolean contains(E element);
+ method public boolean containsAll(java.util.Collection<? extends E> elements);
+ method public void ensureCapacity(int minimumCapacity);
+ method public int getSize();
+ method public int indexOf(Object? key);
+ method public boolean isEmpty();
+ method public java.util.Iterator<E> iterator();
+ method public boolean remove(E element);
+ method public boolean removeAll(androidx.collection.ArraySet<? extends E> array);
+ method public boolean removeAll(java.util.Collection<? extends E> elements);
+ method public E removeAt(int index);
+ method public boolean retainAll(java.util.Collection<? extends E> elements);
+ method public Object?[] toArray();
+ method public <T> T[] toArray(T[] array);
+ method public E valueAt(int index);
+ property public int size;
+ }
+
+ public final class ArraySetKt {
+ method public static inline <T> androidx.collection.ArraySet<T> arraySetOf();
+ method public static <T> androidx.collection.ArraySet<T> arraySetOf(T... values);
+ }
+
+ public final class CircularArray<E> {
+ ctor public CircularArray();
+ ctor public CircularArray(optional int minCapacity);
+ method public void addFirst(E element);
+ method public void addLast(E element);
+ method public void clear();
+ method public operator E get(int index);
+ method public E getFirst();
+ method public E getLast();
+ method public boolean isEmpty();
+ method public E popFirst();
+ method public E popLast();
+ method public void removeFromEnd(int count);
+ method public void removeFromStart(int count);
+ method public int size();
+ property public final E first;
+ property public final E last;
+ }
+
+ public final class CircularIntArray {
+ ctor public CircularIntArray();
+ ctor public CircularIntArray(optional int minCapacity);
+ method public void addFirst(int element);
+ method public void addLast(int element);
+ method public void clear();
+ method public operator int get(int index);
+ method public int getFirst();
+ method public int getLast();
+ method public boolean isEmpty();
+ method public int popFirst();
+ method public int popLast();
+ method public void removeFromEnd(int count);
+ method public void removeFromStart(int count);
+ method public int size();
+ property public final int first;
+ property public final int last;
+ }
+
+ public abstract sealed class DoubleList {
+ method public final inline boolean any();
+ method public final inline boolean any(kotlin.jvm.functions.Function1<? super java.lang.Double,java.lang.Boolean> predicate);
+ method public final int binarySearch(int element);
+ method public final int binarySearch(int element, optional int fromIndex);
+ method public final int binarySearch(int element, optional int fromIndex, optional int toIndex);
+ method public final operator boolean contains(double element);
+ method public final boolean containsAll(androidx.collection.DoubleList elements);
+ method public final inline int count();
+ method public final inline int count(kotlin.jvm.functions.Function1<? super java.lang.Double,java.lang.Boolean> predicate);
+ method public final double elementAt(@IntRange(from=0L) int index);
+ method public final inline double elementAtOrElse(@IntRange(from=0L) int index, kotlin.jvm.functions.Function1<? super java.lang.Integer,java.lang.Double> defaultValue);
+ method public final double first();
+ method public final inline double first(kotlin.jvm.functions.Function1<? super java.lang.Double,java.lang.Boolean> predicate);
+ method public final inline <R> R fold(R initial, kotlin.jvm.functions.Function2<? super R,? super java.lang.Double,? extends R> operation);
+ method public final inline <R> R foldIndexed(R initial, kotlin.jvm.functions.Function3<? super java.lang.Integer,? super R,? super java.lang.Double,? extends R> operation);
+ method public final inline <R> R foldRight(R initial, kotlin.jvm.functions.Function2<? super java.lang.Double,? super R,? extends R> operation);
+ method public final inline <R> R foldRightIndexed(R initial, kotlin.jvm.functions.Function3<? super java.lang.Integer,? super java.lang.Double,? super R,? extends R> operation);
+ method public final inline void forEach(kotlin.jvm.functions.Function1<? super java.lang.Double,kotlin.Unit> block);
+ method public final inline void forEachIndexed(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Double,kotlin.Unit> block);
+ method public final inline void forEachReversed(kotlin.jvm.functions.Function1<? super java.lang.Double,kotlin.Unit> block);
+ method public final inline void forEachReversedIndexed(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Double,kotlin.Unit> block);
+ method public final operator double get(@IntRange(from=0L) int index);
+ method public final inline kotlin.ranges.IntRange getIndices();
+ method @IntRange(from=-1L) public final inline int getLastIndex();
+ method @IntRange(from=0L) public final inline int getSize();
+ method public final int indexOf(double element);
+ method public final inline int indexOfFirst(kotlin.jvm.functions.Function1<? super java.lang.Double,java.lang.Boolean> predicate);
+ method public final inline int indexOfLast(kotlin.jvm.functions.Function1<? super java.lang.Double,java.lang.Boolean> predicate);
+ method public final inline boolean isEmpty();
+ method public final inline boolean isNotEmpty();
+ method public final String joinToString();
+ method public final String joinToString(optional CharSequence separator);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function1<? super java.lang.Double,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function1<? super java.lang.Double,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function1<? super java.lang.Double,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function1<? super java.lang.Double,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function1<? super java.lang.Double,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(kotlin.jvm.functions.Function1<? super java.lang.Double,? extends java.lang.CharSequence> transform);
+ method public final double last();
+ method public final inline double last(kotlin.jvm.functions.Function1<? super java.lang.Double,java.lang.Boolean> predicate);
+ method public final int lastIndexOf(double element);
+ method public final inline boolean none();
+ method public final inline boolean reversedAny(kotlin.jvm.functions.Function1<? super java.lang.Double,java.lang.Boolean> predicate);
+ property @kotlin.PublishedApi internal final int _size;
+ property @kotlin.PublishedApi internal final double[] content;
+ property public final inline kotlin.ranges.IntRange indices;
+ property @IntRange(from=-1L) public final inline int lastIndex;
+ property @IntRange(from=0L) public final inline int size;
+ field @kotlin.PublishedApi internal int _size;
+ field @kotlin.PublishedApi internal double[] content;
+ }
+
+ public final class DoubleListKt {
+ method public static inline androidx.collection.DoubleList buildDoubleList(int initialCapacity, kotlin.jvm.functions.Function1<? super androidx.collection.MutableDoubleList,kotlin.Unit> builderAction);
+ method public static inline androidx.collection.DoubleList buildDoubleList(kotlin.jvm.functions.Function1<? super androidx.collection.MutableDoubleList,kotlin.Unit> builderAction);
+ method public static androidx.collection.DoubleList doubleListOf();
+ method public static androidx.collection.DoubleList doubleListOf(double element1);
+ method public static androidx.collection.DoubleList doubleListOf(double element1, double element2);
+ method public static androidx.collection.DoubleList doubleListOf(double element1, double element2, double element3);
+ method public static androidx.collection.DoubleList doubleListOf(double... elements);
+ method public static androidx.collection.DoubleList emptyDoubleList();
+ method public static inline androidx.collection.MutableDoubleList mutableDoubleListOf();
+ method public static androidx.collection.MutableDoubleList mutableDoubleListOf(double element1);
+ method public static androidx.collection.MutableDoubleList mutableDoubleListOf(double element1, double element2);
+ method public static androidx.collection.MutableDoubleList mutableDoubleListOf(double element1, double element2, double element3);
+ method public static inline androidx.collection.MutableDoubleList mutableDoubleListOf(double... elements);
+ }
+
+ public abstract sealed class FloatFloatMap {
+ method public final inline boolean all(kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Float,java.lang.Boolean> predicate);
+ method public final boolean any();
+ method public final inline boolean any(kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Float,java.lang.Boolean> predicate);
+ method public final inline operator boolean contains(float key);
+ method public final boolean containsKey(float key);
+ method public final boolean containsValue(float value);
+ method public final int count();
+ method public final inline int count(kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Float,java.lang.Boolean> predicate);
+ method @kotlin.PublishedApi internal final int findKeyIndex(float key);
+ method public final inline void forEach(kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Float,kotlin.Unit> block);
+ method @kotlin.PublishedApi internal final inline void forEachIndexed(kotlin.jvm.functions.Function1<? super java.lang.Integer,kotlin.Unit> block);
+ method public final inline void forEachKey(kotlin.jvm.functions.Function1<? super java.lang.Float,kotlin.Unit> block);
+ method public final inline void forEachValue(kotlin.jvm.functions.Function1<? super java.lang.Float,kotlin.Unit> block);
+ method public final operator float get(float key);
+ method public final int getCapacity();
+ method public final float getOrDefault(float key, float defaultValue);
+ method public final inline float getOrElse(float key, kotlin.jvm.functions.Function0<java.lang.Float> defaultValue);
+ method public final int getSize();
+ method public final boolean isEmpty();
+ method public final boolean isNotEmpty();
+ method public final String joinToString();
+ method public final String joinToString(optional CharSequence separator);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final boolean none();
+ property public final int capacity;
+ property @kotlin.PublishedApi internal final float[] keys;
+ property @kotlin.PublishedApi internal final long[] metadata;
+ property public final int size;
+ property @kotlin.PublishedApi internal final float[] values;
+ field @kotlin.PublishedApi internal float[] keys;
+ field @kotlin.PublishedApi internal long[] metadata;
+ field @kotlin.PublishedApi internal float[] values;
+ }
+
+ public final class FloatFloatMapKt {
+ method public static inline androidx.collection.FloatFloatMap buildFloatFloatMap(int initialCapacity, kotlin.jvm.functions.Function1<? super androidx.collection.MutableFloatFloatMap,kotlin.Unit> builderAction);
+ method public static inline androidx.collection.FloatFloatMap buildFloatFloatMap(kotlin.jvm.functions.Function1<? super androidx.collection.MutableFloatFloatMap,kotlin.Unit> builderAction);
+ method public static androidx.collection.FloatFloatMap emptyFloatFloatMap();
+ method public static androidx.collection.FloatFloatMap floatFloatMapOf();
+ method public static androidx.collection.FloatFloatMap floatFloatMapOf(float key1, float value1);
+ method public static androidx.collection.FloatFloatMap floatFloatMapOf(float key1, float value1, float key2, float value2);
+ method public static androidx.collection.FloatFloatMap floatFloatMapOf(float key1, float value1, float key2, float value2, float key3, float value3);
+ method public static androidx.collection.FloatFloatMap floatFloatMapOf(float key1, float value1, float key2, float value2, float key3, float value3, float key4, float value4);
+ method public static androidx.collection.FloatFloatMap floatFloatMapOf(float key1, float value1, float key2, float value2, float key3, float value3, float key4, float value4, float key5, float value5);
+ method public static androidx.collection.MutableFloatFloatMap mutableFloatFloatMapOf();
+ method public static androidx.collection.MutableFloatFloatMap mutableFloatFloatMapOf(float key1, float value1);
+ method public static androidx.collection.MutableFloatFloatMap mutableFloatFloatMapOf(float key1, float value1, float key2, float value2);
+ method public static androidx.collection.MutableFloatFloatMap mutableFloatFloatMapOf(float key1, float value1, float key2, float value2, float key3, float value3);
+ method public static androidx.collection.MutableFloatFloatMap mutableFloatFloatMapOf(float key1, float value1, float key2, float value2, float key3, float value3, float key4, float value4);
+ method public static androidx.collection.MutableFloatFloatMap mutableFloatFloatMapOf(float key1, float value1, float key2, float value2, float key3, float value3, float key4, float value4, float key5, float value5);
+ }
+
+ @kotlin.jvm.JvmInline public final value class FloatFloatPair {
+ ctor public FloatFloatPair(float first, float second);
+ method public inline operator float component1();
+ method public inline operator float component2();
+ property public final inline float first;
+ property public final long packedValue;
+ property public final inline float second;
+ field public final long packedValue;
+ }
+
+ public abstract sealed class FloatIntMap {
+ method public final inline boolean all(kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Integer,java.lang.Boolean> predicate);
+ method public final boolean any();
+ method public final inline boolean any(kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Integer,java.lang.Boolean> predicate);
+ method public final inline operator boolean contains(float key);
+ method public final boolean containsKey(float key);
+ method public final boolean containsValue(int value);
+ method public final int count();
+ method public final inline int count(kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Integer,java.lang.Boolean> predicate);
+ method @kotlin.PublishedApi internal final int findKeyIndex(float key);
+ method public final inline void forEach(kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Integer,kotlin.Unit> block);
+ method @kotlin.PublishedApi internal final inline void forEachIndexed(kotlin.jvm.functions.Function1<? super java.lang.Integer,kotlin.Unit> block);
+ method public final inline void forEachKey(kotlin.jvm.functions.Function1<? super java.lang.Float,kotlin.Unit> block);
+ method public final inline void forEachValue(kotlin.jvm.functions.Function1<? super java.lang.Integer,kotlin.Unit> block);
+ method public final operator int get(float key);
+ method public final int getCapacity();
+ method public final int getOrDefault(float key, int defaultValue);
+ method public final inline int getOrElse(float key, kotlin.jvm.functions.Function0<java.lang.Integer> defaultValue);
+ method public final int getSize();
+ method public final boolean isEmpty();
+ method public final boolean isNotEmpty();
+ method public final String joinToString();
+ method public final String joinToString(optional CharSequence separator);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final boolean none();
+ property public final int capacity;
+ property @kotlin.PublishedApi internal final float[] keys;
+ property @kotlin.PublishedApi internal final long[] metadata;
+ property public final int size;
+ property @kotlin.PublishedApi internal final int[] values;
+ field @kotlin.PublishedApi internal float[] keys;
+ field @kotlin.PublishedApi internal long[] metadata;
+ field @kotlin.PublishedApi internal int[] values;
+ }
+
+ public final class FloatIntMapKt {
+ method public static inline androidx.collection.FloatIntMap buildFloatIntMap(int initialCapacity, kotlin.jvm.functions.Function1<? super androidx.collection.MutableFloatIntMap,kotlin.Unit> builderAction);
+ method public static inline androidx.collection.FloatIntMap buildFloatIntMap(kotlin.jvm.functions.Function1<? super androidx.collection.MutableFloatIntMap,kotlin.Unit> builderAction);
+ method public static androidx.collection.FloatIntMap emptyFloatIntMap();
+ method public static androidx.collection.FloatIntMap floatIntMapOf();
+ method public static androidx.collection.FloatIntMap floatIntMapOf(float key1, int value1);
+ method public static androidx.collection.FloatIntMap floatIntMapOf(float key1, int value1, float key2, int value2);
+ method public static androidx.collection.FloatIntMap floatIntMapOf(float key1, int value1, float key2, int value2, float key3, int value3);
+ method public static androidx.collection.FloatIntMap floatIntMapOf(float key1, int value1, float key2, int value2, float key3, int value3, float key4, int value4);
+ method public static androidx.collection.FloatIntMap floatIntMapOf(float key1, int value1, float key2, int value2, float key3, int value3, float key4, int value4, float key5, int value5);
+ method public static androidx.collection.MutableFloatIntMap mutableFloatIntMapOf();
+ method public static androidx.collection.MutableFloatIntMap mutableFloatIntMapOf(float key1, int value1);
+ method public static androidx.collection.MutableFloatIntMap mutableFloatIntMapOf(float key1, int value1, float key2, int value2);
+ method public static androidx.collection.MutableFloatIntMap mutableFloatIntMapOf(float key1, int value1, float key2, int value2, float key3, int value3);
+ method public static androidx.collection.MutableFloatIntMap mutableFloatIntMapOf(float key1, int value1, float key2, int value2, float key3, int value3, float key4, int value4);
+ method public static androidx.collection.MutableFloatIntMap mutableFloatIntMapOf(float key1, int value1, float key2, int value2, float key3, int value3, float key4, int value4, float key5, int value5);
+ }
+
+ public abstract sealed class FloatList {
+ method public final inline boolean any();
+ method public final inline boolean any(kotlin.jvm.functions.Function1<? super java.lang.Float,java.lang.Boolean> predicate);
+ method public final int binarySearch(int element);
+ method public final int binarySearch(int element, optional int fromIndex);
+ method public final int binarySearch(int element, optional int fromIndex, optional int toIndex);
+ method public final operator boolean contains(float element);
+ method public final boolean containsAll(androidx.collection.FloatList elements);
+ method public final inline int count();
+ method public final inline int count(kotlin.jvm.functions.Function1<? super java.lang.Float,java.lang.Boolean> predicate);
+ method public final float elementAt(@IntRange(from=0L) int index);
+ method public final inline float elementAtOrElse(@IntRange(from=0L) int index, kotlin.jvm.functions.Function1<? super java.lang.Integer,java.lang.Float> defaultValue);
+ method public final float first();
+ method public final inline float first(kotlin.jvm.functions.Function1<? super java.lang.Float,java.lang.Boolean> predicate);
+ method public final inline <R> R fold(R initial, kotlin.jvm.functions.Function2<? super R,? super java.lang.Float,? extends R> operation);
+ method public final inline <R> R foldIndexed(R initial, kotlin.jvm.functions.Function3<? super java.lang.Integer,? super R,? super java.lang.Float,? extends R> operation);
+ method public final inline <R> R foldRight(R initial, kotlin.jvm.functions.Function2<? super java.lang.Float,? super R,? extends R> operation);
+ method public final inline <R> R foldRightIndexed(R initial, kotlin.jvm.functions.Function3<? super java.lang.Integer,? super java.lang.Float,? super R,? extends R> operation);
+ method public final inline void forEach(kotlin.jvm.functions.Function1<? super java.lang.Float,kotlin.Unit> block);
+ method public final inline void forEachIndexed(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Float,kotlin.Unit> block);
+ method public final inline void forEachReversed(kotlin.jvm.functions.Function1<? super java.lang.Float,kotlin.Unit> block);
+ method public final inline void forEachReversedIndexed(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Float,kotlin.Unit> block);
+ method public final operator float get(@IntRange(from=0L) int index);
+ method public final inline kotlin.ranges.IntRange getIndices();
+ method @IntRange(from=-1L) public final inline int getLastIndex();
+ method @IntRange(from=0L) public final inline int getSize();
+ method public final int indexOf(float element);
+ method public final inline int indexOfFirst(kotlin.jvm.functions.Function1<? super java.lang.Float,java.lang.Boolean> predicate);
+ method public final inline int indexOfLast(kotlin.jvm.functions.Function1<? super java.lang.Float,java.lang.Boolean> predicate);
+ method public final inline boolean isEmpty();
+ method public final inline boolean isNotEmpty();
+ method public final String joinToString();
+ method public final String joinToString(optional CharSequence separator);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function1<? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function1<? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function1<? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function1<? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function1<? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(kotlin.jvm.functions.Function1<? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final float last();
+ method public final inline float last(kotlin.jvm.functions.Function1<? super java.lang.Float,java.lang.Boolean> predicate);
+ method public final int lastIndexOf(float element);
+ method public final inline boolean none();
+ method public final inline boolean reversedAny(kotlin.jvm.functions.Function1<? super java.lang.Float,java.lang.Boolean> predicate);
+ property @kotlin.PublishedApi internal final int _size;
+ property @kotlin.PublishedApi internal final float[] content;
+ property public final inline kotlin.ranges.IntRange indices;
+ property @IntRange(from=-1L) public final inline int lastIndex;
+ property @IntRange(from=0L) public final inline int size;
+ field @kotlin.PublishedApi internal int _size;
+ field @kotlin.PublishedApi internal float[] content;
+ }
+
+ public final class FloatListKt {
+ method public static inline androidx.collection.FloatList buildFloatList(int initialCapacity, kotlin.jvm.functions.Function1<? super androidx.collection.MutableFloatList,kotlin.Unit> builderAction);
+ method public static inline androidx.collection.FloatList buildFloatList(kotlin.jvm.functions.Function1<? super androidx.collection.MutableFloatList,kotlin.Unit> builderAction);
+ method public static androidx.collection.FloatList emptyFloatList();
+ method public static androidx.collection.FloatList floatListOf();
+ method public static androidx.collection.FloatList floatListOf(float element1);
+ method public static androidx.collection.FloatList floatListOf(float element1, float element2);
+ method public static androidx.collection.FloatList floatListOf(float element1, float element2, float element3);
+ method public static androidx.collection.FloatList floatListOf(float... elements);
+ method public static inline androidx.collection.MutableFloatList mutableFloatListOf();
+ method public static androidx.collection.MutableFloatList mutableFloatListOf(float element1);
+ method public static androidx.collection.MutableFloatList mutableFloatListOf(float element1, float element2);
+ method public static androidx.collection.MutableFloatList mutableFloatListOf(float element1, float element2, float element3);
+ method public static inline androidx.collection.MutableFloatList mutableFloatListOf(float... elements);
+ }
+
+ public abstract sealed class FloatLongMap {
+ method public final inline boolean all(kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Long,java.lang.Boolean> predicate);
+ method public final boolean any();
+ method public final inline boolean any(kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Long,java.lang.Boolean> predicate);
+ method public final inline operator boolean contains(float key);
+ method public final boolean containsKey(float key);
+ method public final boolean containsValue(long value);
+ method public final int count();
+ method public final inline int count(kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Long,java.lang.Boolean> predicate);
+ method @kotlin.PublishedApi internal final int findKeyIndex(float key);
+ method public final inline void forEach(kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Long,kotlin.Unit> block);
+ method @kotlin.PublishedApi internal final inline void forEachIndexed(kotlin.jvm.functions.Function1<? super java.lang.Integer,kotlin.Unit> block);
+ method public final inline void forEachKey(kotlin.jvm.functions.Function1<? super java.lang.Float,kotlin.Unit> block);
+ method public final inline void forEachValue(kotlin.jvm.functions.Function1<? super java.lang.Long,kotlin.Unit> block);
+ method public final operator long get(float key);
+ method public final int getCapacity();
+ method public final long getOrDefault(float key, long defaultValue);
+ method public final inline long getOrElse(float key, kotlin.jvm.functions.Function0<java.lang.Long> defaultValue);
+ method public final int getSize();
+ method public final boolean isEmpty();
+ method public final boolean isNotEmpty();
+ method public final String joinToString();
+ method public final String joinToString(optional CharSequence separator);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final boolean none();
+ property public final int capacity;
+ property @kotlin.PublishedApi internal final float[] keys;
+ property @kotlin.PublishedApi internal final long[] metadata;
+ property public final int size;
+ property @kotlin.PublishedApi internal final long[] values;
+ field @kotlin.PublishedApi internal float[] keys;
+ field @kotlin.PublishedApi internal long[] metadata;
+ field @kotlin.PublishedApi internal long[] values;
+ }
+
+ public final class FloatLongMapKt {
+ method public static inline androidx.collection.FloatLongMap buildFloatLongMap(int initialCapacity, kotlin.jvm.functions.Function1<? super androidx.collection.MutableFloatLongMap,kotlin.Unit> builderAction);
+ method public static inline androidx.collection.FloatLongMap buildFloatLongMap(kotlin.jvm.functions.Function1<? super androidx.collection.MutableFloatLongMap,kotlin.Unit> builderAction);
+ method public static androidx.collection.FloatLongMap emptyFloatLongMap();
+ method public static androidx.collection.FloatLongMap floatLongMapOf();
+ method public static androidx.collection.FloatLongMap floatLongMapOf(float key1, long value1);
+ method public static androidx.collection.FloatLongMap floatLongMapOf(float key1, long value1, float key2, long value2);
+ method public static androidx.collection.FloatLongMap floatLongMapOf(float key1, long value1, float key2, long value2, float key3, long value3);
+ method public static androidx.collection.FloatLongMap floatLongMapOf(float key1, long value1, float key2, long value2, float key3, long value3, float key4, long value4);
+ method public static androidx.collection.FloatLongMap floatLongMapOf(float key1, long value1, float key2, long value2, float key3, long value3, float key4, long value4, float key5, long value5);
+ method public static androidx.collection.MutableFloatLongMap mutableFloatLongMapOf();
+ method public static androidx.collection.MutableFloatLongMap mutableFloatLongMapOf(float key1, long value1);
+ method public static androidx.collection.MutableFloatLongMap mutableFloatLongMapOf(float key1, long value1, float key2, long value2);
+ method public static androidx.collection.MutableFloatLongMap mutableFloatLongMapOf(float key1, long value1, float key2, long value2, float key3, long value3);
+ method public static androidx.collection.MutableFloatLongMap mutableFloatLongMapOf(float key1, long value1, float key2, long value2, float key3, long value3, float key4, long value4);
+ method public static androidx.collection.MutableFloatLongMap mutableFloatLongMapOf(float key1, long value1, float key2, long value2, float key3, long value3, float key4, long value4, float key5, long value5);
+ }
+
+ public abstract sealed class FloatObjectMap<V> {
+ method public final inline boolean all(kotlin.jvm.functions.Function2<? super java.lang.Float,? super V,java.lang.Boolean> predicate);
+ method public final boolean any();
+ method public final inline boolean any(kotlin.jvm.functions.Function2<? super java.lang.Float,? super V,java.lang.Boolean> predicate);
+ method public final inline operator boolean contains(float key);
+ method public final boolean containsKey(float key);
+ method public final boolean containsValue(V value);
+ method public final int count();
+ method public final inline int count(kotlin.jvm.functions.Function2<? super java.lang.Float,? super V,java.lang.Boolean> predicate);
+ method public final inline void forEach(kotlin.jvm.functions.Function2<? super java.lang.Float,? super V,kotlin.Unit> block);
+ method @kotlin.PublishedApi internal final inline void forEachIndexed(kotlin.jvm.functions.Function1<? super java.lang.Integer,kotlin.Unit> block);
+ method public final inline void forEachKey(kotlin.jvm.functions.Function1<? super java.lang.Float,kotlin.Unit> block);
+ method public final inline void forEachValue(kotlin.jvm.functions.Function1<? super V,kotlin.Unit> block);
+ method public final operator V? get(float key);
+ method public final int getCapacity();
+ method public final V getOrDefault(float key, V defaultValue);
+ method public final inline V getOrElse(float key, kotlin.jvm.functions.Function0<? extends V> defaultValue);
+ method public final int getSize();
+ method public final boolean isEmpty();
+ method public final boolean isNotEmpty();
+ method public final String joinToString();
+ method public final String joinToString(optional CharSequence separator);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2<? super java.lang.Float,? super V,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2<? super java.lang.Float,? super V,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2<? super java.lang.Float,? super V,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2<? super java.lang.Float,? super V,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2<? super java.lang.Float,? super V,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(kotlin.jvm.functions.Function2<? super java.lang.Float,? super V,? extends java.lang.CharSequence> transform);
+ method public final boolean none();
+ property public final int capacity;
+ property @kotlin.PublishedApi internal final float[] keys;
+ property @kotlin.PublishedApi internal final long[] metadata;
+ property public final int size;
+ property @kotlin.PublishedApi internal final Object?[] values;
+ field @kotlin.PublishedApi internal float[] keys;
+ field @kotlin.PublishedApi internal long[] metadata;
+ field @kotlin.PublishedApi internal Object?[] values;
+ }
+
+ public final class FloatObjectMapKt {
+ method public static inline <V> androidx.collection.FloatObjectMap<V> buildFloatObjectMap(int initialCapacity, kotlin.jvm.functions.Function1<? super androidx.collection.MutableFloatObjectMap<V>,kotlin.Unit> builderAction);
+ method public static inline <V> androidx.collection.FloatObjectMap<V> buildFloatObjectMap(kotlin.jvm.functions.Function1<? super androidx.collection.MutableFloatObjectMap<V>,kotlin.Unit> builderAction);
+ method public static <V> androidx.collection.FloatObjectMap<V> emptyFloatObjectMap();
+ method public static <V> androidx.collection.FloatObjectMap<V> floatObjectMapOf();
+ method public static <V> androidx.collection.FloatObjectMap<V> floatObjectMapOf(float key1, V value1);
+ method public static <V> androidx.collection.FloatObjectMap<V> floatObjectMapOf(float key1, V value1, float key2, V value2);
+ method public static <V> androidx.collection.FloatObjectMap<V> floatObjectMapOf(float key1, V value1, float key2, V value2, float key3, V value3);
+ method public static <V> androidx.collection.FloatObjectMap<V> floatObjectMapOf(float key1, V value1, float key2, V value2, float key3, V value3, float key4, V value4);
+ method public static <V> androidx.collection.FloatObjectMap<V> floatObjectMapOf(float key1, V value1, float key2, V value2, float key3, V value3, float key4, V value4, float key5, V value5);
+ method public static <V> androidx.collection.MutableFloatObjectMap<V> mutableFloatObjectMapOf();
+ method public static <V> androidx.collection.MutableFloatObjectMap<V> mutableFloatObjectMapOf(float key1, V value1);
+ method public static <V> androidx.collection.MutableFloatObjectMap<V> mutableFloatObjectMapOf(float key1, V value1, float key2, V value2);
+ method public static <V> androidx.collection.MutableFloatObjectMap<V> mutableFloatObjectMapOf(float key1, V value1, float key2, V value2, float key3, V value3);
+ method public static <V> androidx.collection.MutableFloatObjectMap<V> mutableFloatObjectMapOf(float key1, V value1, float key2, V value2, float key3, V value3, float key4, V value4);
+ method public static <V> androidx.collection.MutableFloatObjectMap<V> mutableFloatObjectMapOf(float key1, V value1, float key2, V value2, float key3, V value3, float key4, V value4, float key5, V value5);
+ }
+
+ public abstract sealed class FloatSet {
+ method public final inline boolean all(kotlin.jvm.functions.Function1<? super java.lang.Float,java.lang.Boolean> predicate);
+ method public final boolean any();
+ method public final inline boolean any(kotlin.jvm.functions.Function1<? super java.lang.Float,java.lang.Boolean> predicate);
+ method public final operator boolean contains(float element);
+ method @IntRange(from=0L) public final int count();
+ method @IntRange(from=0L) public final inline int count(kotlin.jvm.functions.Function1<? super java.lang.Float,java.lang.Boolean> predicate);
+ method public final inline float first();
+ method public final inline float first(kotlin.jvm.functions.Function1<? super java.lang.Float,java.lang.Boolean> predicate);
+ method public final inline void forEach(kotlin.jvm.functions.Function1<? super java.lang.Float,kotlin.Unit> block);
+ method @kotlin.PublishedApi internal final inline void forEachIndex(kotlin.jvm.functions.Function1<? super java.lang.Integer,kotlin.Unit> block);
+ method @IntRange(from=0L) public final int getCapacity();
+ method @IntRange(from=0L) public final int getSize();
+ method public final boolean isEmpty();
+ method public final boolean isNotEmpty();
+ method public final String joinToString();
+ method public final String joinToString(optional CharSequence separator);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function1<? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function1<? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function1<? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function1<? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function1<? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(kotlin.jvm.functions.Function1<? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final boolean none();
+ property @IntRange(from=0L) public final int capacity;
+ property @kotlin.PublishedApi internal final float[] elements;
+ property @kotlin.PublishedApi internal final long[] metadata;
+ property @IntRange(from=0L) public final int size;
+ field @kotlin.PublishedApi internal float[] elements;
+ field @kotlin.PublishedApi internal long[] metadata;
+ }
+
+ public final class FloatSetKt {
+ method public static inline androidx.collection.FloatSet buildFloatSet(int initialCapacity, kotlin.jvm.functions.Function1<? super androidx.collection.MutableFloatSet,kotlin.Unit> builderAction);
+ method public static inline androidx.collection.FloatSet buildFloatSet(kotlin.jvm.functions.Function1<? super androidx.collection.MutableFloatSet,kotlin.Unit> builderAction);
+ method public static androidx.collection.FloatSet emptyFloatSet();
+ method public static androidx.collection.FloatSet floatSetOf();
+ method public static androidx.collection.FloatSet floatSetOf(float element1);
+ method public static androidx.collection.FloatSet floatSetOf(float element1, float element2);
+ method public static androidx.collection.FloatSet floatSetOf(float element1, float element2, float element3);
+ method public static androidx.collection.FloatSet floatSetOf(float... elements);
+ method public static androidx.collection.MutableFloatSet mutableFloatSetOf();
+ method public static androidx.collection.MutableFloatSet mutableFloatSetOf(float element1);
+ method public static androidx.collection.MutableFloatSet mutableFloatSetOf(float element1, float element2);
+ method public static androidx.collection.MutableFloatSet mutableFloatSetOf(float element1, float element2, float element3);
+ method public static androidx.collection.MutableFloatSet mutableFloatSetOf(float... elements);
+ }
+
+ public abstract sealed class IntFloatMap {
+ method public final inline boolean all(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Float,java.lang.Boolean> predicate);
+ method public final boolean any();
+ method public final inline boolean any(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Float,java.lang.Boolean> predicate);
+ method public final inline operator boolean contains(int key);
+ method public final boolean containsKey(int key);
+ method public final boolean containsValue(float value);
+ method public final int count();
+ method public final inline int count(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Float,java.lang.Boolean> predicate);
+ method @kotlin.PublishedApi internal final int findKeyIndex(int key);
+ method public final inline void forEach(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Float,kotlin.Unit> block);
+ method @kotlin.PublishedApi internal final inline void forEachIndexed(kotlin.jvm.functions.Function1<? super java.lang.Integer,kotlin.Unit> block);
+ method public final inline void forEachKey(kotlin.jvm.functions.Function1<? super java.lang.Integer,kotlin.Unit> block);
+ method public final inline void forEachValue(kotlin.jvm.functions.Function1<? super java.lang.Float,kotlin.Unit> block);
+ method public final operator float get(int key);
+ method public final int getCapacity();
+ method public final float getOrDefault(int key, float defaultValue);
+ method public final inline float getOrElse(int key, kotlin.jvm.functions.Function0<java.lang.Float> defaultValue);
+ method public final int getSize();
+ method public final boolean isEmpty();
+ method public final boolean isNotEmpty();
+ method public final String joinToString();
+ method public final String joinToString(optional CharSequence separator);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final boolean none();
+ property public final int capacity;
+ property @kotlin.PublishedApi internal final int[] keys;
+ property @kotlin.PublishedApi internal final long[] metadata;
+ property public final int size;
+ property @kotlin.PublishedApi internal final float[] values;
+ field @kotlin.PublishedApi internal int[] keys;
+ field @kotlin.PublishedApi internal long[] metadata;
+ field @kotlin.PublishedApi internal float[] values;
+ }
+
+ public final class IntFloatMapKt {
+ method public static inline androidx.collection.IntFloatMap buildIntFloatMap(int initialCapacity, kotlin.jvm.functions.Function1<? super androidx.collection.MutableIntFloatMap,kotlin.Unit> builderAction);
+ method public static inline androidx.collection.IntFloatMap buildIntFloatMap(kotlin.jvm.functions.Function1<? super androidx.collection.MutableIntFloatMap,kotlin.Unit> builderAction);
+ method public static androidx.collection.IntFloatMap emptyIntFloatMap();
+ method public static androidx.collection.IntFloatMap intFloatMapOf();
+ method public static androidx.collection.IntFloatMap intFloatMapOf(int key1, float value1);
+ method public static androidx.collection.IntFloatMap intFloatMapOf(int key1, float value1, int key2, float value2);
+ method public static androidx.collection.IntFloatMap intFloatMapOf(int key1, float value1, int key2, float value2, int key3, float value3);
+ method public static androidx.collection.IntFloatMap intFloatMapOf(int key1, float value1, int key2, float value2, int key3, float value3, int key4, float value4);
+ method public static androidx.collection.IntFloatMap intFloatMapOf(int key1, float value1, int key2, float value2, int key3, float value3, int key4, float value4, int key5, float value5);
+ method public static androidx.collection.MutableIntFloatMap mutableIntFloatMapOf();
+ method public static androidx.collection.MutableIntFloatMap mutableIntFloatMapOf(int key1, float value1);
+ method public static androidx.collection.MutableIntFloatMap mutableIntFloatMapOf(int key1, float value1, int key2, float value2);
+ method public static androidx.collection.MutableIntFloatMap mutableIntFloatMapOf(int key1, float value1, int key2, float value2, int key3, float value3);
+ method public static androidx.collection.MutableIntFloatMap mutableIntFloatMapOf(int key1, float value1, int key2, float value2, int key3, float value3, int key4, float value4);
+ method public static androidx.collection.MutableIntFloatMap mutableIntFloatMapOf(int key1, float value1, int key2, float value2, int key3, float value3, int key4, float value4, int key5, float value5);
+ }
+
+ public abstract sealed class IntIntMap {
+ method public final inline boolean all(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Integer,java.lang.Boolean> predicate);
+ method public final boolean any();
+ method public final inline boolean any(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Integer,java.lang.Boolean> predicate);
+ method public final inline operator boolean contains(int key);
+ method public final boolean containsKey(int key);
+ method public final boolean containsValue(int value);
+ method public final int count();
+ method public final inline int count(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Integer,java.lang.Boolean> predicate);
+ method @kotlin.PublishedApi internal final int findKeyIndex(int key);
+ method public final inline void forEach(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Integer,kotlin.Unit> block);
+ method @kotlin.PublishedApi internal final inline void forEachIndexed(kotlin.jvm.functions.Function1<? super java.lang.Integer,kotlin.Unit> block);
+ method public final inline void forEachKey(kotlin.jvm.functions.Function1<? super java.lang.Integer,kotlin.Unit> block);
+ method public final inline void forEachValue(kotlin.jvm.functions.Function1<? super java.lang.Integer,kotlin.Unit> block);
+ method public final operator int get(int key);
+ method public final int getCapacity();
+ method public final int getOrDefault(int key, int defaultValue);
+ method public final inline int getOrElse(int key, kotlin.jvm.functions.Function0<java.lang.Integer> defaultValue);
+ method public final int getSize();
+ method public final boolean isEmpty();
+ method public final boolean isNotEmpty();
+ method public final String joinToString();
+ method public final String joinToString(optional CharSequence separator);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final boolean none();
+ property public final int capacity;
+ property @kotlin.PublishedApi internal final int[] keys;
+ property @kotlin.PublishedApi internal final long[] metadata;
+ property public final int size;
+ property @kotlin.PublishedApi internal final int[] values;
+ field @kotlin.PublishedApi internal int[] keys;
+ field @kotlin.PublishedApi internal long[] metadata;
+ field @kotlin.PublishedApi internal int[] values;
+ }
+
+ public final class IntIntMapKt {
+ method public static inline androidx.collection.IntIntMap buildIntIntMap(int initialCapacity, kotlin.jvm.functions.Function1<? super androidx.collection.MutableIntIntMap,kotlin.Unit> builderAction);
+ method public static inline androidx.collection.IntIntMap buildIntIntMap(kotlin.jvm.functions.Function1<? super androidx.collection.MutableIntIntMap,kotlin.Unit> builderAction);
+ method public static androidx.collection.IntIntMap emptyIntIntMap();
+ method public static androidx.collection.IntIntMap intIntMapOf();
+ method public static androidx.collection.IntIntMap intIntMapOf(int key1, int value1);
+ method public static androidx.collection.IntIntMap intIntMapOf(int key1, int value1, int key2, int value2);
+ method public static androidx.collection.IntIntMap intIntMapOf(int key1, int value1, int key2, int value2, int key3, int value3);
+ method public static androidx.collection.IntIntMap intIntMapOf(int key1, int value1, int key2, int value2, int key3, int value3, int key4, int value4);
+ method public static androidx.collection.IntIntMap intIntMapOf(int key1, int value1, int key2, int value2, int key3, int value3, int key4, int value4, int key5, int value5);
+ method public static androidx.collection.MutableIntIntMap mutableIntIntMapOf();
+ method public static androidx.collection.MutableIntIntMap mutableIntIntMapOf(int key1, int value1);
+ method public static androidx.collection.MutableIntIntMap mutableIntIntMapOf(int key1, int value1, int key2, int value2);
+ method public static androidx.collection.MutableIntIntMap mutableIntIntMapOf(int key1, int value1, int key2, int value2, int key3, int value3);
+ method public static androidx.collection.MutableIntIntMap mutableIntIntMapOf(int key1, int value1, int key2, int value2, int key3, int value3, int key4, int value4);
+ method public static androidx.collection.MutableIntIntMap mutableIntIntMapOf(int key1, int value1, int key2, int value2, int key3, int value3, int key4, int value4, int key5, int value5);
+ }
+
+ @kotlin.jvm.JvmInline public final value class IntIntPair {
+ ctor public IntIntPair(int first, int second);
+ method public inline operator int component1();
+ method public inline operator int component2();
+ property public final int first;
+ property public final long packedValue;
+ property public final int second;
+ field public final long packedValue;
+ }
+
+ public abstract sealed class IntList {
+ method public final inline boolean any();
+ method public final inline boolean any(kotlin.jvm.functions.Function1<? super java.lang.Integer,java.lang.Boolean> predicate);
+ method public final int binarySearch(int element);
+ method public final int binarySearch(int element, optional int fromIndex);
+ method public final int binarySearch(int element, optional int fromIndex, optional int toIndex);
+ method public final operator boolean contains(int element);
+ method public final boolean containsAll(androidx.collection.IntList elements);
+ method public final inline int count();
+ method public final inline int count(kotlin.jvm.functions.Function1<? super java.lang.Integer,java.lang.Boolean> predicate);
+ method public final int elementAt(@IntRange(from=0L) int index);
+ method public final inline int elementAtOrElse(@IntRange(from=0L) int index, kotlin.jvm.functions.Function1<? super java.lang.Integer,java.lang.Integer> defaultValue);
+ method public final int first();
+ method public final inline int first(kotlin.jvm.functions.Function1<? super java.lang.Integer,java.lang.Boolean> predicate);
+ method public final inline <R> R fold(R initial, kotlin.jvm.functions.Function2<? super R,? super java.lang.Integer,? extends R> operation);
+ method public final inline <R> R foldIndexed(R initial, kotlin.jvm.functions.Function3<? super java.lang.Integer,? super R,? super java.lang.Integer,? extends R> operation);
+ method public final inline <R> R foldRight(R initial, kotlin.jvm.functions.Function2<? super java.lang.Integer,? super R,? extends R> operation);
+ method public final inline <R> R foldRightIndexed(R initial, kotlin.jvm.functions.Function3<? super java.lang.Integer,? super java.lang.Integer,? super R,? extends R> operation);
+ method public final inline void forEach(kotlin.jvm.functions.Function1<? super java.lang.Integer,kotlin.Unit> block);
+ method public final inline void forEachIndexed(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Integer,kotlin.Unit> block);
+ method public final inline void forEachReversed(kotlin.jvm.functions.Function1<? super java.lang.Integer,kotlin.Unit> block);
+ method public final inline void forEachReversedIndexed(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Integer,kotlin.Unit> block);
+ method public final operator int get(@IntRange(from=0L) int index);
+ method public final inline kotlin.ranges.IntRange getIndices();
+ method @IntRange(from=-1L) public final inline int getLastIndex();
+ method @IntRange(from=0L) public final inline int getSize();
+ method public final int indexOf(int element);
+ method public final inline int indexOfFirst(kotlin.jvm.functions.Function1<? super java.lang.Integer,java.lang.Boolean> predicate);
+ method public final inline int indexOfLast(kotlin.jvm.functions.Function1<? super java.lang.Integer,java.lang.Boolean> predicate);
+ method public final inline boolean isEmpty();
+ method public final inline boolean isNotEmpty();
+ method public final String joinToString();
+ method public final String joinToString(optional CharSequence separator);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function1<? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function1<? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function1<? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function1<? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function1<? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(kotlin.jvm.functions.Function1<? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final int last();
+ method public final inline int last(kotlin.jvm.functions.Function1<? super java.lang.Integer,java.lang.Boolean> predicate);
+ method public final int lastIndexOf(int element);
+ method public final inline boolean none();
+ method public final inline boolean reversedAny(kotlin.jvm.functions.Function1<? super java.lang.Integer,java.lang.Boolean> predicate);
+ property @kotlin.PublishedApi internal final int _size;
+ property @kotlin.PublishedApi internal final int[] content;
+ property public final inline kotlin.ranges.IntRange indices;
+ property @IntRange(from=-1L) public final inline int lastIndex;
+ property @IntRange(from=0L) public final inline int size;
+ field @kotlin.PublishedApi internal int _size;
+ field @kotlin.PublishedApi internal int[] content;
+ }
+
+ public final class IntListKt {
+ method public static inline androidx.collection.IntList buildIntList(int initialCapacity, kotlin.jvm.functions.Function1<? super androidx.collection.MutableIntList,kotlin.Unit> builderAction);
+ method public static inline androidx.collection.IntList buildIntList(kotlin.jvm.functions.Function1<? super androidx.collection.MutableIntList,kotlin.Unit> builderAction);
+ method public static androidx.collection.IntList emptyIntList();
+ method public static androidx.collection.IntList intListOf();
+ method public static androidx.collection.IntList intListOf(int element1);
+ method public static androidx.collection.IntList intListOf(int element1, int element2);
+ method public static androidx.collection.IntList intListOf(int element1, int element2, int element3);
+ method public static androidx.collection.IntList intListOf(int... elements);
+ method public static inline androidx.collection.MutableIntList mutableIntListOf();
+ method public static androidx.collection.MutableIntList mutableIntListOf(int element1);
+ method public static androidx.collection.MutableIntList mutableIntListOf(int element1, int element2);
+ method public static androidx.collection.MutableIntList mutableIntListOf(int element1, int element2, int element3);
+ method public static inline androidx.collection.MutableIntList mutableIntListOf(int... elements);
+ }
+
+ public abstract sealed class IntLongMap {
+ method public final inline boolean all(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Long,java.lang.Boolean> predicate);
+ method public final boolean any();
+ method public final inline boolean any(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Long,java.lang.Boolean> predicate);
+ method public final inline operator boolean contains(int key);
+ method public final boolean containsKey(int key);
+ method public final boolean containsValue(long value);
+ method public final int count();
+ method public final inline int count(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Long,java.lang.Boolean> predicate);
+ method @kotlin.PublishedApi internal final int findKeyIndex(int key);
+ method public final inline void forEach(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Long,kotlin.Unit> block);
+ method @kotlin.PublishedApi internal final inline void forEachIndexed(kotlin.jvm.functions.Function1<? super java.lang.Integer,kotlin.Unit> block);
+ method public final inline void forEachKey(kotlin.jvm.functions.Function1<? super java.lang.Integer,kotlin.Unit> block);
+ method public final inline void forEachValue(kotlin.jvm.functions.Function1<? super java.lang.Long,kotlin.Unit> block);
+ method public final operator long get(int key);
+ method public final int getCapacity();
+ method public final long getOrDefault(int key, long defaultValue);
+ method public final inline long getOrElse(int key, kotlin.jvm.functions.Function0<java.lang.Long> defaultValue);
+ method public final int getSize();
+ method public final boolean isEmpty();
+ method public final boolean isNotEmpty();
+ method public final String joinToString();
+ method public final String joinToString(optional CharSequence separator);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final boolean none();
+ property public final int capacity;
+ property @kotlin.PublishedApi internal final int[] keys;
+ property @kotlin.PublishedApi internal final long[] metadata;
+ property public final int size;
+ property @kotlin.PublishedApi internal final long[] values;
+ field @kotlin.PublishedApi internal int[] keys;
+ field @kotlin.PublishedApi internal long[] metadata;
+ field @kotlin.PublishedApi internal long[] values;
+ }
+
+ public final class IntLongMapKt {
+ method public static inline androidx.collection.IntLongMap buildIntLongMap(int initialCapacity, kotlin.jvm.functions.Function1<? super androidx.collection.MutableIntLongMap,kotlin.Unit> builderAction);
+ method public static inline androidx.collection.IntLongMap buildIntLongMap(kotlin.jvm.functions.Function1<? super androidx.collection.MutableIntLongMap,kotlin.Unit> builderAction);
+ method public static androidx.collection.IntLongMap emptyIntLongMap();
+ method public static androidx.collection.IntLongMap intLongMapOf();
+ method public static androidx.collection.IntLongMap intLongMapOf(int key1, long value1);
+ method public static androidx.collection.IntLongMap intLongMapOf(int key1, long value1, int key2, long value2);
+ method public static androidx.collection.IntLongMap intLongMapOf(int key1, long value1, int key2, long value2, int key3, long value3);
+ method public static androidx.collection.IntLongMap intLongMapOf(int key1, long value1, int key2, long value2, int key3, long value3, int key4, long value4);
+ method public static androidx.collection.IntLongMap intLongMapOf(int key1, long value1, int key2, long value2, int key3, long value3, int key4, long value4, int key5, long value5);
+ method public static androidx.collection.MutableIntLongMap mutableIntLongMapOf();
+ method public static androidx.collection.MutableIntLongMap mutableIntLongMapOf(int key1, long value1);
+ method public static androidx.collection.MutableIntLongMap mutableIntLongMapOf(int key1, long value1, int key2, long value2);
+ method public static androidx.collection.MutableIntLongMap mutableIntLongMapOf(int key1, long value1, int key2, long value2, int key3, long value3);
+ method public static androidx.collection.MutableIntLongMap mutableIntLongMapOf(int key1, long value1, int key2, long value2, int key3, long value3, int key4, long value4);
+ method public static androidx.collection.MutableIntLongMap mutableIntLongMapOf(int key1, long value1, int key2, long value2, int key3, long value3, int key4, long value4, int key5, long value5);
+ }
+
+ public abstract sealed class IntObjectMap<V> {
+ method public final inline boolean all(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super V,java.lang.Boolean> predicate);
+ method public final boolean any();
+ method public final inline boolean any(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super V,java.lang.Boolean> predicate);
+ method public final inline operator boolean contains(int key);
+ method public final boolean containsKey(int key);
+ method public final boolean containsValue(V value);
+ method public final int count();
+ method public final inline int count(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super V,java.lang.Boolean> predicate);
+ method public final inline void forEach(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super V,kotlin.Unit> block);
+ method @kotlin.PublishedApi internal final inline void forEachIndexed(kotlin.jvm.functions.Function1<? super java.lang.Integer,kotlin.Unit> block);
+ method public final inline void forEachKey(kotlin.jvm.functions.Function1<? super java.lang.Integer,kotlin.Unit> block);
+ method public final inline void forEachValue(kotlin.jvm.functions.Function1<? super V,kotlin.Unit> block);
+ method public final operator V? get(int key);
+ method public final int getCapacity();
+ method public final V getOrDefault(int key, V defaultValue);
+ method public final inline V getOrElse(int key, kotlin.jvm.functions.Function0<? extends V> defaultValue);
+ method public final int getSize();
+ method public final boolean isEmpty();
+ method public final boolean isNotEmpty();
+ method public final String joinToString();
+ method public final String joinToString(optional CharSequence separator);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2<? super java.lang.Integer,? super V,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2<? super java.lang.Integer,? super V,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2<? super java.lang.Integer,? super V,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2<? super java.lang.Integer,? super V,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2<? super java.lang.Integer,? super V,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super V,? extends java.lang.CharSequence> transform);
+ method public final boolean none();
+ property public final int capacity;
+ property @kotlin.PublishedApi internal final int[] keys;
+ property @kotlin.PublishedApi internal final long[] metadata;
+ property public final int size;
+ property @kotlin.PublishedApi internal final Object?[] values;
+ field @kotlin.PublishedApi internal int[] keys;
+ field @kotlin.PublishedApi internal long[] metadata;
+ field @kotlin.PublishedApi internal Object?[] values;
+ }
+
+ public final class IntObjectMapKt {
+ method public static inline <V> androidx.collection.IntObjectMap<V> buildIntObjectMap(int initialCapacity, kotlin.jvm.functions.Function1<? super androidx.collection.MutableIntObjectMap<V>,kotlin.Unit> builderAction);
+ method public static inline <V> androidx.collection.IntObjectMap<V> buildIntObjectMap(kotlin.jvm.functions.Function1<? super androidx.collection.MutableIntObjectMap<V>,kotlin.Unit> builderAction);
+ method public static <V> androidx.collection.IntObjectMap<V> emptyIntObjectMap();
+ method public static <V> androidx.collection.IntObjectMap<V> intObjectMapOf();
+ method public static <V> androidx.collection.IntObjectMap<V> intObjectMapOf(int key1, V value1);
+ method public static <V> androidx.collection.IntObjectMap<V> intObjectMapOf(int key1, V value1, int key2, V value2);
+ method public static <V> androidx.collection.IntObjectMap<V> intObjectMapOf(int key1, V value1, int key2, V value2, int key3, V value3);
+ method public static <V> androidx.collection.IntObjectMap<V> intObjectMapOf(int key1, V value1, int key2, V value2, int key3, V value3, int key4, V value4);
+ method public static <V> androidx.collection.IntObjectMap<V> intObjectMapOf(int key1, V value1, int key2, V value2, int key3, V value3, int key4, V value4, int key5, V value5);
+ method public static <V> androidx.collection.MutableIntObjectMap<V> mutableIntObjectMapOf();
+ method public static <V> androidx.collection.MutableIntObjectMap<V> mutableIntObjectMapOf(int key1, V value1);
+ method public static <V> androidx.collection.MutableIntObjectMap<V> mutableIntObjectMapOf(int key1, V value1, int key2, V value2);
+ method public static <V> androidx.collection.MutableIntObjectMap<V> mutableIntObjectMapOf(int key1, V value1, int key2, V value2, int key3, V value3);
+ method public static <V> androidx.collection.MutableIntObjectMap<V> mutableIntObjectMapOf(int key1, V value1, int key2, V value2, int key3, V value3, int key4, V value4);
+ method public static <V> androidx.collection.MutableIntObjectMap<V> mutableIntObjectMapOf(int key1, V value1, int key2, V value2, int key3, V value3, int key4, V value4, int key5, V value5);
+ }
+
+ public abstract sealed class IntSet {
+ method public final inline boolean all(kotlin.jvm.functions.Function1<? super java.lang.Integer,java.lang.Boolean> predicate);
+ method public final boolean any();
+ method public final inline boolean any(kotlin.jvm.functions.Function1<? super java.lang.Integer,java.lang.Boolean> predicate);
+ method public final operator boolean contains(int element);
+ method @IntRange(from=0L) public final int count();
+ method @IntRange(from=0L) public final inline int count(kotlin.jvm.functions.Function1<? super java.lang.Integer,java.lang.Boolean> predicate);
+ method public final inline int first();
+ method public final inline int first(kotlin.jvm.functions.Function1<? super java.lang.Integer,java.lang.Boolean> predicate);
+ method public final inline void forEach(kotlin.jvm.functions.Function1<? super java.lang.Integer,kotlin.Unit> block);
+ method @kotlin.PublishedApi internal final inline void forEachIndex(kotlin.jvm.functions.Function1<? super java.lang.Integer,kotlin.Unit> block);
+ method @IntRange(from=0L) public final int getCapacity();
+ method @IntRange(from=0L) public final int getSize();
+ method public final boolean isEmpty();
+ method public final boolean isNotEmpty();
+ method public final String joinToString();
+ method public final String joinToString(optional CharSequence separator);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function1<? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function1<? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function1<? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function1<? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function1<? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(kotlin.jvm.functions.Function1<? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final boolean none();
+ property @IntRange(from=0L) public final int capacity;
+ property @kotlin.PublishedApi internal final int[] elements;
+ property @kotlin.PublishedApi internal final long[] metadata;
+ property @IntRange(from=0L) public final int size;
+ field @kotlin.PublishedApi internal int[] elements;
+ field @kotlin.PublishedApi internal long[] metadata;
+ }
+
+ public final class IntSetKt {
+ method public static inline androidx.collection.IntSet buildIntSet(int initialCapacity, kotlin.jvm.functions.Function1<? super androidx.collection.MutableIntSet,kotlin.Unit> builderAction);
+ method public static inline androidx.collection.IntSet buildIntSet(kotlin.jvm.functions.Function1<? super androidx.collection.MutableIntSet,kotlin.Unit> builderAction);
+ method public static androidx.collection.IntSet emptyIntSet();
+ method public static androidx.collection.IntSet intSetOf();
+ method public static androidx.collection.IntSet intSetOf(int element1);
+ method public static androidx.collection.IntSet intSetOf(int element1, int element2);
+ method public static androidx.collection.IntSet intSetOf(int element1, int element2, int element3);
+ method public static androidx.collection.IntSet intSetOf(int... elements);
+ method public static androidx.collection.MutableIntSet mutableIntSetOf();
+ method public static androidx.collection.MutableIntSet mutableIntSetOf(int element1);
+ method public static androidx.collection.MutableIntSet mutableIntSetOf(int element1, int element2);
+ method public static androidx.collection.MutableIntSet mutableIntSetOf(int element1, int element2, int element3);
+ method public static androidx.collection.MutableIntSet mutableIntSetOf(int... elements);
+ }
+
+ public abstract sealed class LongFloatMap {
+ method public final inline boolean all(kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Float,java.lang.Boolean> predicate);
+ method public final boolean any();
+ method public final inline boolean any(kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Float,java.lang.Boolean> predicate);
+ method public final inline operator boolean contains(long key);
+ method public final boolean containsKey(long key);
+ method public final boolean containsValue(float value);
+ method public final int count();
+ method public final inline int count(kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Float,java.lang.Boolean> predicate);
+ method @kotlin.PublishedApi internal final int findKeyIndex(long key);
+ method public final inline void forEach(kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Float,kotlin.Unit> block);
+ method @kotlin.PublishedApi internal final inline void forEachIndexed(kotlin.jvm.functions.Function1<? super java.lang.Integer,kotlin.Unit> block);
+ method public final inline void forEachKey(kotlin.jvm.functions.Function1<? super java.lang.Long,kotlin.Unit> block);
+ method public final inline void forEachValue(kotlin.jvm.functions.Function1<? super java.lang.Float,kotlin.Unit> block);
+ method public final operator float get(long key);
+ method public final int getCapacity();
+ method public final float getOrDefault(long key, float defaultValue);
+ method public final inline float getOrElse(long key, kotlin.jvm.functions.Function0<java.lang.Float> defaultValue);
+ method public final int getSize();
+ method public final boolean isEmpty();
+ method public final boolean isNotEmpty();
+ method public final String joinToString();
+ method public final String joinToString(optional CharSequence separator);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final boolean none();
+ property public final int capacity;
+ property @kotlin.PublishedApi internal final long[] keys;
+ property @kotlin.PublishedApi internal final long[] metadata;
+ property public final int size;
+ property @kotlin.PublishedApi internal final float[] values;
+ field @kotlin.PublishedApi internal long[] keys;
+ field @kotlin.PublishedApi internal long[] metadata;
+ field @kotlin.PublishedApi internal float[] values;
+ }
+
+ public final class LongFloatMapKt {
+ method public static inline androidx.collection.LongFloatMap buildLongFloatMap(int initialCapacity, kotlin.jvm.functions.Function1<? super androidx.collection.MutableLongFloatMap,kotlin.Unit> builderAction);
+ method public static inline androidx.collection.LongFloatMap buildLongFloatMap(kotlin.jvm.functions.Function1<? super androidx.collection.MutableLongFloatMap,kotlin.Unit> builderAction);
+ method public static androidx.collection.LongFloatMap emptyLongFloatMap();
+ method public static androidx.collection.LongFloatMap longFloatMapOf();
+ method public static androidx.collection.LongFloatMap longFloatMapOf(long key1, float value1);
+ method public static androidx.collection.LongFloatMap longFloatMapOf(long key1, float value1, long key2, float value2);
+ method public static androidx.collection.LongFloatMap longFloatMapOf(long key1, float value1, long key2, float value2, long key3, float value3);
+ method public static androidx.collection.LongFloatMap longFloatMapOf(long key1, float value1, long key2, float value2, long key3, float value3, long key4, float value4);
+ method public static androidx.collection.LongFloatMap longFloatMapOf(long key1, float value1, long key2, float value2, long key3, float value3, long key4, float value4, long key5, float value5);
+ method public static androidx.collection.MutableLongFloatMap mutableLongFloatMapOf();
+ method public static androidx.collection.MutableLongFloatMap mutableLongFloatMapOf(long key1, float value1);
+ method public static androidx.collection.MutableLongFloatMap mutableLongFloatMapOf(long key1, float value1, long key2, float value2);
+ method public static androidx.collection.MutableLongFloatMap mutableLongFloatMapOf(long key1, float value1, long key2, float value2, long key3, float value3);
+ method public static androidx.collection.MutableLongFloatMap mutableLongFloatMapOf(long key1, float value1, long key2, float value2, long key3, float value3, long key4, float value4);
+ method public static androidx.collection.MutableLongFloatMap mutableLongFloatMapOf(long key1, float value1, long key2, float value2, long key3, float value3, long key4, float value4, long key5, float value5);
+ }
+
+ public abstract sealed class LongIntMap {
+ method public final inline boolean all(kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Integer,java.lang.Boolean> predicate);
+ method public final boolean any();
+ method public final inline boolean any(kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Integer,java.lang.Boolean> predicate);
+ method public final inline operator boolean contains(long key);
+ method public final boolean containsKey(long key);
+ method public final boolean containsValue(int value);
+ method public final int count();
+ method public final inline int count(kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Integer,java.lang.Boolean> predicate);
+ method @kotlin.PublishedApi internal final int findKeyIndex(long key);
+ method public final inline void forEach(kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Integer,kotlin.Unit> block);
+ method @kotlin.PublishedApi internal final inline void forEachIndexed(kotlin.jvm.functions.Function1<? super java.lang.Integer,kotlin.Unit> block);
+ method public final inline void forEachKey(kotlin.jvm.functions.Function1<? super java.lang.Long,kotlin.Unit> block);
+ method public final inline void forEachValue(kotlin.jvm.functions.Function1<? super java.lang.Integer,kotlin.Unit> block);
+ method public final operator int get(long key);
+ method public final int getCapacity();
+ method public final int getOrDefault(long key, int defaultValue);
+ method public final inline int getOrElse(long key, kotlin.jvm.functions.Function0<java.lang.Integer> defaultValue);
+ method public final int getSize();
+ method public final boolean isEmpty();
+ method public final boolean isNotEmpty();
+ method public final String joinToString();
+ method public final String joinToString(optional CharSequence separator);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final boolean none();
+ property public final int capacity;
+ property @kotlin.PublishedApi internal final long[] keys;
+ property @kotlin.PublishedApi internal final long[] metadata;
+ property public final int size;
+ property @kotlin.PublishedApi internal final int[] values;
+ field @kotlin.PublishedApi internal long[] keys;
+ field @kotlin.PublishedApi internal long[] metadata;
+ field @kotlin.PublishedApi internal int[] values;
+ }
+
+ public final class LongIntMapKt {
+ method public static inline androidx.collection.LongIntMap buildLongIntMap(int initialCapacity, kotlin.jvm.functions.Function1<? super androidx.collection.MutableLongIntMap,kotlin.Unit> builderAction);
+ method public static inline androidx.collection.LongIntMap buildLongIntMap(kotlin.jvm.functions.Function1<? super androidx.collection.MutableLongIntMap,kotlin.Unit> builderAction);
+ method public static androidx.collection.LongIntMap emptyLongIntMap();
+ method public static androidx.collection.LongIntMap longIntMapOf();
+ method public static androidx.collection.LongIntMap longIntMapOf(long key1, int value1);
+ method public static androidx.collection.LongIntMap longIntMapOf(long key1, int value1, long key2, int value2);
+ method public static androidx.collection.LongIntMap longIntMapOf(long key1, int value1, long key2, int value2, long key3, int value3);
+ method public static androidx.collection.LongIntMap longIntMapOf(long key1, int value1, long key2, int value2, long key3, int value3, long key4, int value4);
+ method public static androidx.collection.LongIntMap longIntMapOf(long key1, int value1, long key2, int value2, long key3, int value3, long key4, int value4, long key5, int value5);
+ method public static androidx.collection.MutableLongIntMap mutableLongIntMapOf();
+ method public static androidx.collection.MutableLongIntMap mutableLongIntMapOf(long key1, int value1);
+ method public static androidx.collection.MutableLongIntMap mutableLongIntMapOf(long key1, int value1, long key2, int value2);
+ method public static androidx.collection.MutableLongIntMap mutableLongIntMapOf(long key1, int value1, long key2, int value2, long key3, int value3);
+ method public static androidx.collection.MutableLongIntMap mutableLongIntMapOf(long key1, int value1, long key2, int value2, long key3, int value3, long key4, int value4);
+ method public static androidx.collection.MutableLongIntMap mutableLongIntMapOf(long key1, int value1, long key2, int value2, long key3, int value3, long key4, int value4, long key5, int value5);
+ }
+
+ public abstract sealed class LongList {
+ method public final inline boolean any();
+ method public final inline boolean any(kotlin.jvm.functions.Function1<? super java.lang.Long,java.lang.Boolean> predicate);
+ method public final int binarySearch(int element);
+ method public final int binarySearch(int element, optional int fromIndex);
+ method public final int binarySearch(int element, optional int fromIndex, optional int toIndex);
+ method public final operator boolean contains(long element);
+ method public final boolean containsAll(androidx.collection.LongList elements);
+ method public final inline int count();
+ method public final inline int count(kotlin.jvm.functions.Function1<? super java.lang.Long,java.lang.Boolean> predicate);
+ method public final long elementAt(@IntRange(from=0L) int index);
+ method public final inline long elementAtOrElse(@IntRange(from=0L) int index, kotlin.jvm.functions.Function1<? super java.lang.Integer,java.lang.Long> defaultValue);
+ method public final long first();
+ method public final inline long first(kotlin.jvm.functions.Function1<? super java.lang.Long,java.lang.Boolean> predicate);
+ method public final inline <R> R fold(R initial, kotlin.jvm.functions.Function2<? super R,? super java.lang.Long,? extends R> operation);
+ method public final inline <R> R foldIndexed(R initial, kotlin.jvm.functions.Function3<? super java.lang.Integer,? super R,? super java.lang.Long,? extends R> operation);
+ method public final inline <R> R foldRight(R initial, kotlin.jvm.functions.Function2<? super java.lang.Long,? super R,? extends R> operation);
+ method public final inline <R> R foldRightIndexed(R initial, kotlin.jvm.functions.Function3<? super java.lang.Integer,? super java.lang.Long,? super R,? extends R> operation);
+ method public final inline void forEach(kotlin.jvm.functions.Function1<? super java.lang.Long,kotlin.Unit> block);
+ method public final inline void forEachIndexed(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Long,kotlin.Unit> block);
+ method public final inline void forEachReversed(kotlin.jvm.functions.Function1<? super java.lang.Long,kotlin.Unit> block);
+ method public final inline void forEachReversedIndexed(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Long,kotlin.Unit> block);
+ method public final operator long get(@IntRange(from=0L) int index);
+ method public final inline kotlin.ranges.IntRange getIndices();
+ method @IntRange(from=-1L) public final inline int getLastIndex();
+ method @IntRange(from=0L) public final inline int getSize();
+ method public final int indexOf(long element);
+ method public final inline int indexOfFirst(kotlin.jvm.functions.Function1<? super java.lang.Long,java.lang.Boolean> predicate);
+ method public final inline int indexOfLast(kotlin.jvm.functions.Function1<? super java.lang.Long,java.lang.Boolean> predicate);
+ method public final inline boolean isEmpty();
+ method public final inline boolean isNotEmpty();
+ method public final String joinToString();
+ method public final String joinToString(optional CharSequence separator);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function1<? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function1<? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function1<? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function1<? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function1<? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(kotlin.jvm.functions.Function1<? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final long last();
+ method public final inline long last(kotlin.jvm.functions.Function1<? super java.lang.Long,java.lang.Boolean> predicate);
+ method public final int lastIndexOf(long element);
+ method public final inline boolean none();
+ method public final inline boolean reversedAny(kotlin.jvm.functions.Function1<? super java.lang.Long,java.lang.Boolean> predicate);
+ property @kotlin.PublishedApi internal final int _size;
+ property @kotlin.PublishedApi internal final long[] content;
+ property public final inline kotlin.ranges.IntRange indices;
+ property @IntRange(from=-1L) public final inline int lastIndex;
+ property @IntRange(from=0L) public final inline int size;
+ field @kotlin.PublishedApi internal int _size;
+ field @kotlin.PublishedApi internal long[] content;
+ }
+
+ public final class LongListKt {
+ method public static inline androidx.collection.LongList buildLongList(int initialCapacity, kotlin.jvm.functions.Function1<? super androidx.collection.MutableLongList,kotlin.Unit> builderAction);
+ method public static inline androidx.collection.LongList buildLongList(kotlin.jvm.functions.Function1<? super androidx.collection.MutableLongList,kotlin.Unit> builderAction);
+ method public static androidx.collection.LongList emptyLongList();
+ method public static androidx.collection.LongList longListOf();
+ method public static androidx.collection.LongList longListOf(long element1);
+ method public static androidx.collection.LongList longListOf(long element1, long element2);
+ method public static androidx.collection.LongList longListOf(long element1, long element2, long element3);
+ method public static androidx.collection.LongList longListOf(long... elements);
+ method public static inline androidx.collection.MutableLongList mutableLongListOf();
+ method public static androidx.collection.MutableLongList mutableLongListOf(long element1);
+ method public static androidx.collection.MutableLongList mutableLongListOf(long element1, long element2);
+ method public static androidx.collection.MutableLongList mutableLongListOf(long element1, long element2, long element3);
+ method public static inline androidx.collection.MutableLongList mutableLongListOf(long... elements);
+ }
+
+ public abstract sealed class LongLongMap {
+ method public final inline boolean all(kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Long,java.lang.Boolean> predicate);
+ method public final boolean any();
+ method public final inline boolean any(kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Long,java.lang.Boolean> predicate);
+ method public final inline operator boolean contains(long key);
+ method public final boolean containsKey(long key);
+ method public final boolean containsValue(long value);
+ method public final int count();
+ method public final inline int count(kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Long,java.lang.Boolean> predicate);
+ method @kotlin.PublishedApi internal final int findKeyIndex(long key);
+ method public final inline void forEach(kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Long,kotlin.Unit> block);
+ method @kotlin.PublishedApi internal final inline void forEachIndexed(kotlin.jvm.functions.Function1<? super java.lang.Integer,kotlin.Unit> block);
+ method public final inline void forEachKey(kotlin.jvm.functions.Function1<? super java.lang.Long,kotlin.Unit> block);
+ method public final inline void forEachValue(kotlin.jvm.functions.Function1<? super java.lang.Long,kotlin.Unit> block);
+ method public final operator long get(long key);
+ method public final int getCapacity();
+ method public final long getOrDefault(long key, long defaultValue);
+ method public final inline long getOrElse(long key, kotlin.jvm.functions.Function0<java.lang.Long> defaultValue);
+ method public final int getSize();
+ method public final boolean isEmpty();
+ method public final boolean isNotEmpty();
+ method public final String joinToString();
+ method public final String joinToString(optional CharSequence separator);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final boolean none();
+ property public final int capacity;
+ property @kotlin.PublishedApi internal final long[] keys;
+ property @kotlin.PublishedApi internal final long[] metadata;
+ property public final int size;
+ property @kotlin.PublishedApi internal final long[] values;
+ field @kotlin.PublishedApi internal long[] keys;
+ field @kotlin.PublishedApi internal long[] metadata;
+ field @kotlin.PublishedApi internal long[] values;
+ }
+
+ public final class LongLongMapKt {
+ method public static inline androidx.collection.LongLongMap buildLongLongMap(int initialCapacity, kotlin.jvm.functions.Function1<? super androidx.collection.MutableLongLongMap,kotlin.Unit> builderAction);
+ method public static inline androidx.collection.LongLongMap buildLongLongMap(kotlin.jvm.functions.Function1<? super androidx.collection.MutableLongLongMap,kotlin.Unit> builderAction);
+ method public static androidx.collection.LongLongMap emptyLongLongMap();
+ method public static androidx.collection.LongLongMap longLongMapOf();
+ method public static androidx.collection.LongLongMap longLongMapOf(long key1, long value1);
+ method public static androidx.collection.LongLongMap longLongMapOf(long key1, long value1, long key2, long value2);
+ method public static androidx.collection.LongLongMap longLongMapOf(long key1, long value1, long key2, long value2, long key3, long value3);
+ method public static androidx.collection.LongLongMap longLongMapOf(long key1, long value1, long key2, long value2, long key3, long value3, long key4, long value4);
+ method public static androidx.collection.LongLongMap longLongMapOf(long key1, long value1, long key2, long value2, long key3, long value3, long key4, long value4, long key5, long value5);
+ method public static androidx.collection.MutableLongLongMap mutableLongLongMapOf();
+ method public static androidx.collection.MutableLongLongMap mutableLongLongMapOf(long key1, long value1);
+ method public static androidx.collection.MutableLongLongMap mutableLongLongMapOf(long key1, long value1, long key2, long value2);
+ method public static androidx.collection.MutableLongLongMap mutableLongLongMapOf(long key1, long value1, long key2, long value2, long key3, long value3);
+ method public static androidx.collection.MutableLongLongMap mutableLongLongMapOf(long key1, long value1, long key2, long value2, long key3, long value3, long key4, long value4);
+ method public static androidx.collection.MutableLongLongMap mutableLongLongMapOf(long key1, long value1, long key2, long value2, long key3, long value3, long key4, long value4, long key5, long value5);
+ }
+
+ public final class LongLongPair {
+ ctor public LongLongPair(long first, long second);
+ method public inline operator long component1();
+ method public inline operator long component2();
+ method public long getFirst();
+ method public long getSecond();
+ property public final long first;
+ property public final long second;
+ }
+
+ public abstract sealed class LongObjectMap<V> {
+ method public final inline boolean all(kotlin.jvm.functions.Function2<? super java.lang.Long,? super V,java.lang.Boolean> predicate);
+ method public final boolean any();
+ method public final inline boolean any(kotlin.jvm.functions.Function2<? super java.lang.Long,? super V,java.lang.Boolean> predicate);
+ method public final inline operator boolean contains(long key);
+ method public final boolean containsKey(long key);
+ method public final boolean containsValue(V value);
+ method public final int count();
+ method public final inline int count(kotlin.jvm.functions.Function2<? super java.lang.Long,? super V,java.lang.Boolean> predicate);
+ method public final inline void forEach(kotlin.jvm.functions.Function2<? super java.lang.Long,? super V,kotlin.Unit> block);
+ method @kotlin.PublishedApi internal final inline void forEachIndexed(kotlin.jvm.functions.Function1<? super java.lang.Integer,kotlin.Unit> block);
+ method public final inline void forEachKey(kotlin.jvm.functions.Function1<? super java.lang.Long,kotlin.Unit> block);
+ method public final inline void forEachValue(kotlin.jvm.functions.Function1<? super V,kotlin.Unit> block);
+ method public final operator V? get(long key);
+ method public final int getCapacity();
+ method public final V getOrDefault(long key, V defaultValue);
+ method public final inline V getOrElse(long key, kotlin.jvm.functions.Function0<? extends V> defaultValue);
+ method public final int getSize();
+ method public final boolean isEmpty();
+ method public final boolean isNotEmpty();
+ method public final String joinToString();
+ method public final String joinToString(optional CharSequence separator);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2<? super java.lang.Long,? super V,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2<? super java.lang.Long,? super V,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2<? super java.lang.Long,? super V,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2<? super java.lang.Long,? super V,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2<? super java.lang.Long,? super V,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(kotlin.jvm.functions.Function2<? super java.lang.Long,? super V,? extends java.lang.CharSequence> transform);
+ method public final boolean none();
+ property public final int capacity;
+ property @kotlin.PublishedApi internal final long[] keys;
+ property @kotlin.PublishedApi internal final long[] metadata;
+ property public final int size;
+ property @kotlin.PublishedApi internal final Object?[] values;
+ field @kotlin.PublishedApi internal long[] keys;
+ field @kotlin.PublishedApi internal long[] metadata;
+ field @kotlin.PublishedApi internal Object?[] values;
+ }
+
+ public final class LongObjectMapKt {
+ method public static inline <V> androidx.collection.LongObjectMap<V> buildLongObjectMap(int initialCapacity, kotlin.jvm.functions.Function1<? super androidx.collection.MutableLongObjectMap<V>,kotlin.Unit> builderAction);
+ method public static inline <V> androidx.collection.LongObjectMap<V> buildLongObjectMap(kotlin.jvm.functions.Function1<? super androidx.collection.MutableLongObjectMap<V>,kotlin.Unit> builderAction);
+ method public static <V> androidx.collection.LongObjectMap<V> emptyLongObjectMap();
+ method public static <V> androidx.collection.LongObjectMap<V> longObjectMapOf();
+ method public static <V> androidx.collection.LongObjectMap<V> longObjectMapOf(long key1, V value1);
+ method public static <V> androidx.collection.LongObjectMap<V> longObjectMapOf(long key1, V value1, long key2, V value2);
+ method public static <V> androidx.collection.LongObjectMap<V> longObjectMapOf(long key1, V value1, long key2, V value2, long key3, V value3);
+ method public static <V> androidx.collection.LongObjectMap<V> longObjectMapOf(long key1, V value1, long key2, V value2, long key3, V value3, long key4, V value4);
+ method public static <V> androidx.collection.LongObjectMap<V> longObjectMapOf(long key1, V value1, long key2, V value2, long key3, V value3, long key4, V value4, long key5, V value5);
+ method public static <V> androidx.collection.MutableLongObjectMap<V> mutableLongObjectMapOf();
+ method public static <V> androidx.collection.MutableLongObjectMap<V> mutableLongObjectMapOf(long key1, V value1);
+ method public static <V> androidx.collection.MutableLongObjectMap<V> mutableLongObjectMapOf(long key1, V value1, long key2, V value2);
+ method public static <V> androidx.collection.MutableLongObjectMap<V> mutableLongObjectMapOf(long key1, V value1, long key2, V value2, long key3, V value3);
+ method public static <V> androidx.collection.MutableLongObjectMap<V> mutableLongObjectMapOf(long key1, V value1, long key2, V value2, long key3, V value3, long key4, V value4);
+ method public static <V> androidx.collection.MutableLongObjectMap<V> mutableLongObjectMapOf(long key1, V value1, long key2, V value2, long key3, V value3, long key4, V value4, long key5, V value5);
+ }
+
+ public abstract sealed class LongSet {
+ method public final inline boolean all(kotlin.jvm.functions.Function1<? super java.lang.Long,java.lang.Boolean> predicate);
+ method public final boolean any();
+ method public final inline boolean any(kotlin.jvm.functions.Function1<? super java.lang.Long,java.lang.Boolean> predicate);
+ method public final operator boolean contains(long element);
+ method @IntRange(from=0L) public final int count();
+ method @IntRange(from=0L) public final inline int count(kotlin.jvm.functions.Function1<? super java.lang.Long,java.lang.Boolean> predicate);
+ method public final inline long first();
+ method public final inline long first(kotlin.jvm.functions.Function1<? super java.lang.Long,java.lang.Boolean> predicate);
+ method public final inline void forEach(kotlin.jvm.functions.Function1<? super java.lang.Long,kotlin.Unit> block);
+ method @kotlin.PublishedApi internal final inline void forEachIndex(kotlin.jvm.functions.Function1<? super java.lang.Integer,kotlin.Unit> block);
+ method @IntRange(from=0L) public final int getCapacity();
+ method @IntRange(from=0L) public final int getSize();
+ method public final boolean isEmpty();
+ method public final boolean isNotEmpty();
+ method public final String joinToString();
+ method public final String joinToString(optional CharSequence separator);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function1<? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function1<? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function1<? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function1<? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function1<? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(kotlin.jvm.functions.Function1<? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final boolean none();
+ property @IntRange(from=0L) public final int capacity;
+ property @kotlin.PublishedApi internal final long[] elements;
+ property @kotlin.PublishedApi internal final long[] metadata;
+ property @IntRange(from=0L) public final int size;
+ field @kotlin.PublishedApi internal long[] elements;
+ field @kotlin.PublishedApi internal long[] metadata;
+ }
+
+ public final class LongSetKt {
+ method public static inline androidx.collection.LongSet buildLongSet(int initialCapacity, kotlin.jvm.functions.Function1<? super androidx.collection.MutableLongSet,kotlin.Unit> builderAction);
+ method public static inline androidx.collection.LongSet buildLongSet(kotlin.jvm.functions.Function1<? super androidx.collection.MutableLongSet,kotlin.Unit> builderAction);
+ method public static androidx.collection.LongSet emptyLongSet();
+ method public static androidx.collection.LongSet longSetOf();
+ method public static androidx.collection.LongSet longSetOf(long element1);
+ method public static androidx.collection.LongSet longSetOf(long element1, long element2);
+ method public static androidx.collection.LongSet longSetOf(long element1, long element2, long element3);
+ method public static androidx.collection.LongSet longSetOf(long... elements);
+ method public static androidx.collection.MutableLongSet mutableLongSetOf();
+ method public static androidx.collection.MutableLongSet mutableLongSetOf(long element1);
+ method public static androidx.collection.MutableLongSet mutableLongSetOf(long element1, long element2);
+ method public static androidx.collection.MutableLongSet mutableLongSetOf(long element1, long element2, long element3);
+ method public static androidx.collection.MutableLongSet mutableLongSetOf(long... elements);
+ }
+
+ public class LongSparseArray<E> implements java.lang.Cloneable {
+ ctor public LongSparseArray();
+ ctor public LongSparseArray(optional int initialCapacity);
+ method public void append(long key, E value);
+ method public void clear();
+ method public androidx.collection.LongSparseArray<E> clone();
+ method public boolean containsKey(long key);
+ method public boolean containsValue(E value);
+ method @Deprecated public void delete(long key);
+ method public operator E? get(long key);
+ method public E get(long key, E defaultValue);
+ method public int indexOfKey(long key);
+ method public int indexOfValue(E value);
+ method public boolean isEmpty();
+ method public long keyAt(int index);
+ method public void put(long key, E value);
+ method public void putAll(androidx.collection.LongSparseArray<? extends E> other);
+ method public E? putIfAbsent(long key, E value);
+ method public void remove(long key);
+ method public boolean remove(long key, E value);
+ method public void removeAt(int index);
+ method public E? replace(long key, E value);
+ method public boolean replace(long key, E oldValue, E newValue);
+ method public void setValueAt(int index, E value);
+ method public int size();
+ method public E valueAt(int index);
+ }
+
+ public final class LongSparseArrayKt {
+ method public static inline operator <T> boolean contains(androidx.collection.LongSparseArray<T>, long key);
+ method public static inline <T> void forEach(androidx.collection.LongSparseArray<T>, kotlin.jvm.functions.Function2<? super java.lang.Long,? super T,kotlin.Unit> action);
+ method public static inline <T> T getOrDefault(androidx.collection.LongSparseArray<T>, long key, T defaultValue);
+ method public static inline <T> T getOrElse(androidx.collection.LongSparseArray<T>, long key, kotlin.jvm.functions.Function0<? extends T> defaultValue);
+ method public static inline <T> int getSize(androidx.collection.LongSparseArray<T>);
+ method public static inline <T> boolean isNotEmpty(androidx.collection.LongSparseArray<T>);
+ method public static <T> kotlin.collections.LongIterator keyIterator(androidx.collection.LongSparseArray<T>);
+ method public static operator <T> androidx.collection.LongSparseArray<T> plus(androidx.collection.LongSparseArray<T>, androidx.collection.LongSparseArray<T> other);
+ method @Deprecated public static <T> boolean remove(androidx.collection.LongSparseArray<T>, long key, T value);
+ method public static inline operator <T> void set(androidx.collection.LongSparseArray<T>, long key, T value);
+ method public static <T> java.util.Iterator<T> valueIterator(androidx.collection.LongSparseArray<T>);
+ }
+
+ public class LruCache<K, V> {
+ ctor public LruCache(@IntRange(from=1L, to=androidx.collection.LruCacheKt.MAX_SIZE) int maxSize);
+ method protected V? create(K key);
+ method public final int createCount();
+ method protected void entryRemoved(boolean evicted, K key, V oldValue, V? newValue);
+ method public final void evictAll();
+ method public final int evictionCount();
+ method public final operator V? get(K key);
+ method public final int hitCount();
+ method public final int maxSize();
+ method public final int missCount();
+ method public final V? put(K key, V value);
+ method public final int putCount();
+ method public final V? remove(K key);
+ method public void resize(@IntRange(from=1L, to=androidx.collection.LruCacheKt.MAX_SIZE) int maxSize);
+ method public final int size();
+ method protected int sizeOf(K key, V value);
+ method public final java.util.Map<K,V> snapshot();
+ method public void trimToSize(int maxSize);
+ }
+
+ public final class LruCacheKt {
+ method public static inline <K, V> androidx.collection.LruCache<K,V> lruCache(int maxSize, optional kotlin.jvm.functions.Function2<? super K,? super V,java.lang.Integer> sizeOf, optional kotlin.jvm.functions.Function1<? super K,? extends V?> create, optional kotlin.jvm.functions.Function4<? super java.lang.Boolean,? super K,? super V,? super V?,kotlin.Unit> onEntryRemoved);
+ }
+
+ public final class MutableDoubleList extends androidx.collection.DoubleList {
+ ctor public MutableDoubleList();
+ ctor public MutableDoubleList(optional int initialCapacity);
+ method public boolean add(double element);
+ method public void add(@IntRange(from=0L) int index, double element);
+ method public inline boolean addAll(androidx.collection.DoubleList elements);
+ method public inline boolean addAll(double[] elements);
+ method public boolean addAll(@IntRange(from=0L) int index, androidx.collection.DoubleList elements);
+ method public boolean addAll(@IntRange(from=0L) int index, double[] elements);
+ method public void clear();
+ method public void ensureCapacity(int capacity);
+ method public inline int getCapacity();
+ method public operator void minusAssign(androidx.collection.DoubleList elements);
+ method public inline operator void minusAssign(double element);
+ method public operator void minusAssign(double[] elements);
+ method public inline operator void plusAssign(androidx.collection.DoubleList elements);
+ method public inline operator void plusAssign(double element);
+ method public inline operator void plusAssign(double[] elements);
+ method public boolean remove(double element);
+ method public boolean removeAll(androidx.collection.DoubleList elements);
+ method public boolean removeAll(double[] elements);
+ method public double removeAt(@IntRange(from=0L) int index);
+ method public void removeRange(@IntRange(from=0L) int start, @IntRange(from=0L) int end);
+ method public boolean retainAll(androidx.collection.DoubleList elements);
+ method public boolean retainAll(double[] elements);
+ method public operator double set(@IntRange(from=0L) int index, double element);
+ method public void sort();
+ method public void sortDescending();
+ method public void trim(optional int minCapacity);
+ property public final inline int capacity;
+ }
+
+ public final class MutableFloatFloatMap extends androidx.collection.FloatFloatMap {
+ ctor public MutableFloatFloatMap();
+ ctor public MutableFloatFloatMap(optional int initialCapacity);
+ method public void clear();
+ method public inline float getOrPut(float key, kotlin.jvm.functions.Function0<java.lang.Float> defaultValue);
+ method public inline operator void minusAssign(androidx.collection.FloatList keys);
+ method public inline operator void minusAssign(androidx.collection.FloatSet keys);
+ method public inline operator void minusAssign(float key);
+ method public inline operator void minusAssign(float[] keys);
+ method public inline operator void plusAssign(androidx.collection.FloatFloatMap from);
+ method public void put(float key, float value);
+ method public float put(float key, float value, float default);
+ method public void putAll(androidx.collection.FloatFloatMap from);
+ method public void remove(float key);
+ method public boolean remove(float key, float value);
+ method public inline void removeIf(kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Float,java.lang.Boolean> predicate);
+ method @kotlin.PublishedApi internal void removeValueAt(int index);
+ method public operator void set(float key, float value);
+ method public int trim();
+ }
+
+ public final class MutableFloatIntMap extends androidx.collection.FloatIntMap {
+ ctor public MutableFloatIntMap();
+ ctor public MutableFloatIntMap(optional int initialCapacity);
+ method public void clear();
+ method public inline int getOrPut(float key, kotlin.jvm.functions.Function0<java.lang.Integer> defaultValue);
+ method public inline operator void minusAssign(androidx.collection.FloatList keys);
+ method public inline operator void minusAssign(androidx.collection.FloatSet keys);
+ method public inline operator void minusAssign(float key);
+ method public inline operator void minusAssign(float[] keys);
+ method public inline operator void plusAssign(androidx.collection.FloatIntMap from);
+ method public void put(float key, int value);
+ method public int put(float key, int value, int default);
+ method public void putAll(androidx.collection.FloatIntMap from);
+ method public void remove(float key);
+ method public boolean remove(float key, int value);
+ method public inline void removeIf(kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Integer,java.lang.Boolean> predicate);
+ method @kotlin.PublishedApi internal void removeValueAt(int index);
+ method public operator void set(float key, int value);
+ method public int trim();
+ }
+
+ public final class MutableFloatList extends androidx.collection.FloatList {
+ ctor public MutableFloatList();
+ ctor public MutableFloatList(optional int initialCapacity);
+ method public boolean add(float element);
+ method public void add(@IntRange(from=0L) int index, float element);
+ method public inline boolean addAll(androidx.collection.FloatList elements);
+ method public inline boolean addAll(float[] elements);
+ method public boolean addAll(@IntRange(from=0L) int index, androidx.collection.FloatList elements);
+ method public boolean addAll(@IntRange(from=0L) int index, float[] elements);
+ method public void clear();
+ method public void ensureCapacity(int capacity);
+ method public inline int getCapacity();
+ method public operator void minusAssign(androidx.collection.FloatList elements);
+ method public inline operator void minusAssign(float element);
+ method public operator void minusAssign(float[] elements);
+ method public inline operator void plusAssign(androidx.collection.FloatList elements);
+ method public inline operator void plusAssign(float element);
+ method public inline operator void plusAssign(float[] elements);
+ method public boolean remove(float element);
+ method public boolean removeAll(androidx.collection.FloatList elements);
+ method public boolean removeAll(float[] elements);
+ method public float removeAt(@IntRange(from=0L) int index);
+ method public void removeRange(@IntRange(from=0L) int start, @IntRange(from=0L) int end);
+ method public boolean retainAll(androidx.collection.FloatList elements);
+ method public boolean retainAll(float[] elements);
+ method public operator float set(@IntRange(from=0L) int index, float element);
+ method public void sort();
+ method public void sortDescending();
+ method public void trim(optional int minCapacity);
+ property public final inline int capacity;
+ }
+
+ public final class MutableFloatLongMap extends androidx.collection.FloatLongMap {
+ ctor public MutableFloatLongMap();
+ ctor public MutableFloatLongMap(optional int initialCapacity);
+ method public void clear();
+ method public inline long getOrPut(float key, kotlin.jvm.functions.Function0<java.lang.Long> defaultValue);
+ method public inline operator void minusAssign(androidx.collection.FloatList keys);
+ method public inline operator void minusAssign(androidx.collection.FloatSet keys);
+ method public inline operator void minusAssign(float key);
+ method public inline operator void minusAssign(float[] keys);
+ method public inline operator void plusAssign(androidx.collection.FloatLongMap from);
+ method public void put(float key, long value);
+ method public long put(float key, long value, long default);
+ method public void putAll(androidx.collection.FloatLongMap from);
+ method public void remove(float key);
+ method public boolean remove(float key, long value);
+ method public inline void removeIf(kotlin.jvm.functions.Function2<? super java.lang.Float,? super java.lang.Long,java.lang.Boolean> predicate);
+ method @kotlin.PublishedApi internal void removeValueAt(int index);
+ method public operator void set(float key, long value);
+ method public int trim();
+ }
+
+ public final class MutableFloatObjectMap<V> extends androidx.collection.FloatObjectMap<V> {
+ ctor public MutableFloatObjectMap();
+ ctor public MutableFloatObjectMap(optional int initialCapacity);
+ method public void clear();
+ method public inline V getOrPut(float key, kotlin.jvm.functions.Function0<? extends V> defaultValue);
+ method public inline operator void minusAssign(androidx.collection.FloatList keys);
+ method public inline operator void minusAssign(androidx.collection.FloatSet keys);
+ method public inline operator void minusAssign(float key);
+ method public inline operator void minusAssign(float[] keys);
+ method public inline operator void plusAssign(androidx.collection.FloatObjectMap<V> from);
+ method public V? put(float key, V value);
+ method public void putAll(androidx.collection.FloatObjectMap<V> from);
+ method public V? remove(float key);
+ method public boolean remove(float key, V value);
+ method public inline void removeIf(kotlin.jvm.functions.Function2<? super java.lang.Float,? super V,java.lang.Boolean> predicate);
+ method @kotlin.PublishedApi internal V? removeValueAt(int index);
+ method public operator void set(float key, V value);
+ method public int trim();
+ }
+
+ public final class MutableFloatSet extends androidx.collection.FloatSet {
+ ctor public MutableFloatSet();
+ ctor public MutableFloatSet(optional int initialCapacity);
+ method public boolean add(float element);
+ method public boolean addAll(androidx.collection.FloatSet elements);
+ method public boolean addAll(float[] elements);
+ method public void clear();
+ method public operator void minusAssign(androidx.collection.FloatSet elements);
+ method public operator void minusAssign(float element);
+ method public operator void minusAssign(float[] elements);
+ method public operator void plusAssign(androidx.collection.FloatSet elements);
+ method public operator void plusAssign(float element);
+ method public operator void plusAssign(float[] elements);
+ method public boolean remove(float element);
+ method public boolean removeAll(androidx.collection.FloatSet elements);
+ method public boolean removeAll(float[] elements);
+ method @IntRange(from=0L) public int trim();
+ }
+
+ public final class MutableIntFloatMap extends androidx.collection.IntFloatMap {
+ ctor public MutableIntFloatMap();
+ ctor public MutableIntFloatMap(optional int initialCapacity);
+ method public void clear();
+ method public inline float getOrPut(int key, kotlin.jvm.functions.Function0<java.lang.Float> defaultValue);
+ method public inline operator void minusAssign(androidx.collection.IntList keys);
+ method public inline operator void minusAssign(androidx.collection.IntSet keys);
+ method public inline operator void minusAssign(int key);
+ method public inline operator void minusAssign(int[] keys);
+ method public inline operator void plusAssign(androidx.collection.IntFloatMap from);
+ method public void put(int key, float value);
+ method public float put(int key, float value, float default);
+ method public void putAll(androidx.collection.IntFloatMap from);
+ method public void remove(int key);
+ method public boolean remove(int key, float value);
+ method public inline void removeIf(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Float,java.lang.Boolean> predicate);
+ method @kotlin.PublishedApi internal void removeValueAt(int index);
+ method public operator void set(int key, float value);
+ method public int trim();
+ }
+
+ public final class MutableIntIntMap extends androidx.collection.IntIntMap {
+ ctor public MutableIntIntMap();
+ ctor public MutableIntIntMap(optional int initialCapacity);
+ method public void clear();
+ method public inline int getOrPut(int key, kotlin.jvm.functions.Function0<java.lang.Integer> defaultValue);
+ method public inline operator void minusAssign(androidx.collection.IntList keys);
+ method public inline operator void minusAssign(androidx.collection.IntSet keys);
+ method public inline operator void minusAssign(int key);
+ method public inline operator void minusAssign(int[] keys);
+ method public inline operator void plusAssign(androidx.collection.IntIntMap from);
+ method public void put(int key, int value);
+ method public int put(int key, int value, int default);
+ method public void putAll(androidx.collection.IntIntMap from);
+ method public void remove(int key);
+ method public boolean remove(int key, int value);
+ method public inline void removeIf(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Integer,java.lang.Boolean> predicate);
+ method @kotlin.PublishedApi internal void removeValueAt(int index);
+ method public operator void set(int key, int value);
+ method public int trim();
+ }
+
+ public final class MutableIntList extends androidx.collection.IntList {
+ ctor public MutableIntList();
+ ctor public MutableIntList(optional int initialCapacity);
+ method public boolean add(int element);
+ method public void add(@IntRange(from=0L) int index, int element);
+ method public inline boolean addAll(androidx.collection.IntList elements);
+ method public boolean addAll(@IntRange(from=0L) int index, androidx.collection.IntList elements);
+ method public boolean addAll(@IntRange(from=0L) int index, int[] elements);
+ method public inline boolean addAll(int[] elements);
+ method public void clear();
+ method public void ensureCapacity(int capacity);
+ method public inline int getCapacity();
+ method public operator void minusAssign(androidx.collection.IntList elements);
+ method public inline operator void minusAssign(int element);
+ method public operator void minusAssign(int[] elements);
+ method public inline operator void plusAssign(androidx.collection.IntList elements);
+ method public inline operator void plusAssign(int element);
+ method public inline operator void plusAssign(int[] elements);
+ method public boolean remove(int element);
+ method public boolean removeAll(androidx.collection.IntList elements);
+ method public boolean removeAll(int[] elements);
+ method public int removeAt(@IntRange(from=0L) int index);
+ method public void removeRange(@IntRange(from=0L) int start, @IntRange(from=0L) int end);
+ method public boolean retainAll(androidx.collection.IntList elements);
+ method public boolean retainAll(int[] elements);
+ method public operator int set(@IntRange(from=0L) int index, int element);
+ method public void sort();
+ method public void sortDescending();
+ method public void trim(optional int minCapacity);
+ property public final inline int capacity;
+ }
+
+ public final class MutableIntLongMap extends androidx.collection.IntLongMap {
+ ctor public MutableIntLongMap();
+ ctor public MutableIntLongMap(optional int initialCapacity);
+ method public void clear();
+ method public inline long getOrPut(int key, kotlin.jvm.functions.Function0<java.lang.Long> defaultValue);
+ method public inline operator void minusAssign(androidx.collection.IntList keys);
+ method public inline operator void minusAssign(androidx.collection.IntSet keys);
+ method public inline operator void minusAssign(int key);
+ method public inline operator void minusAssign(int[] keys);
+ method public inline operator void plusAssign(androidx.collection.IntLongMap from);
+ method public void put(int key, long value);
+ method public long put(int key, long value, long default);
+ method public void putAll(androidx.collection.IntLongMap from);
+ method public void remove(int key);
+ method public boolean remove(int key, long value);
+ method public inline void removeIf(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super java.lang.Long,java.lang.Boolean> predicate);
+ method @kotlin.PublishedApi internal void removeValueAt(int index);
+ method public operator void set(int key, long value);
+ method public int trim();
+ }
+
+ public final class MutableIntObjectMap<V> extends androidx.collection.IntObjectMap<V> {
+ ctor public MutableIntObjectMap();
+ ctor public MutableIntObjectMap(optional int initialCapacity);
+ method public void clear();
+ method public inline V getOrPut(int key, kotlin.jvm.functions.Function0<? extends V> defaultValue);
+ method public inline operator void minusAssign(androidx.collection.IntList keys);
+ method public inline operator void minusAssign(androidx.collection.IntSet keys);
+ method public inline operator void minusAssign(int key);
+ method public inline operator void minusAssign(int[] keys);
+ method public inline operator void plusAssign(androidx.collection.IntObjectMap<V> from);
+ method public V? put(int key, V value);
+ method public void putAll(androidx.collection.IntObjectMap<V> from);
+ method public V? remove(int key);
+ method public boolean remove(int key, V value);
+ method public inline void removeIf(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super V,java.lang.Boolean> predicate);
+ method @kotlin.PublishedApi internal V? removeValueAt(int index);
+ method public operator void set(int key, V value);
+ method public int trim();
+ }
+
+ public final class MutableIntSet extends androidx.collection.IntSet {
+ ctor public MutableIntSet();
+ ctor public MutableIntSet(optional int initialCapacity);
+ method public boolean add(int element);
+ method public boolean addAll(androidx.collection.IntSet elements);
+ method public boolean addAll(int[] elements);
+ method public void clear();
+ method public operator void minusAssign(androidx.collection.IntSet elements);
+ method public operator void minusAssign(int element);
+ method public operator void minusAssign(int[] elements);
+ method public operator void plusAssign(androidx.collection.IntSet elements);
+ method public operator void plusAssign(int element);
+ method public operator void plusAssign(int[] elements);
+ method public boolean remove(int element);
+ method public boolean removeAll(androidx.collection.IntSet elements);
+ method public boolean removeAll(int[] elements);
+ method @IntRange(from=0L) public int trim();
+ }
+
+ public final class MutableLongFloatMap extends androidx.collection.LongFloatMap {
+ ctor public MutableLongFloatMap();
+ ctor public MutableLongFloatMap(optional int initialCapacity);
+ method public void clear();
+ method public inline float getOrPut(long key, kotlin.jvm.functions.Function0<java.lang.Float> defaultValue);
+ method public inline operator void minusAssign(androidx.collection.LongList keys);
+ method public inline operator void minusAssign(androidx.collection.LongSet keys);
+ method public inline operator void minusAssign(long key);
+ method public inline operator void minusAssign(long[] keys);
+ method public inline operator void plusAssign(androidx.collection.LongFloatMap from);
+ method public void put(long key, float value);
+ method public float put(long key, float value, float default);
+ method public void putAll(androidx.collection.LongFloatMap from);
+ method public void remove(long key);
+ method public boolean remove(long key, float value);
+ method public inline void removeIf(kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Float,java.lang.Boolean> predicate);
+ method @kotlin.PublishedApi internal void removeValueAt(int index);
+ method public operator void set(long key, float value);
+ method public int trim();
+ }
+
+ public final class MutableLongIntMap extends androidx.collection.LongIntMap {
+ ctor public MutableLongIntMap();
+ ctor public MutableLongIntMap(optional int initialCapacity);
+ method public void clear();
+ method public inline int getOrPut(long key, kotlin.jvm.functions.Function0<java.lang.Integer> defaultValue);
+ method public inline operator void minusAssign(androidx.collection.LongList keys);
+ method public inline operator void minusAssign(androidx.collection.LongSet keys);
+ method public inline operator void minusAssign(long key);
+ method public inline operator void minusAssign(long[] keys);
+ method public inline operator void plusAssign(androidx.collection.LongIntMap from);
+ method public void put(long key, int value);
+ method public int put(long key, int value, int default);
+ method public void putAll(androidx.collection.LongIntMap from);
+ method public void remove(long key);
+ method public boolean remove(long key, int value);
+ method public inline void removeIf(kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Integer,java.lang.Boolean> predicate);
+ method @kotlin.PublishedApi internal void removeValueAt(int index);
+ method public operator void set(long key, int value);
+ method public int trim();
+ }
+
+ public final class MutableLongList extends androidx.collection.LongList {
+ ctor public MutableLongList();
+ ctor public MutableLongList(optional int initialCapacity);
+ method public void add(@IntRange(from=0L) int index, long element);
+ method public boolean add(long element);
+ method public inline boolean addAll(androidx.collection.LongList elements);
+ method public boolean addAll(@IntRange(from=0L) int index, androidx.collection.LongList elements);
+ method public boolean addAll(@IntRange(from=0L) int index, long[] elements);
+ method public inline boolean addAll(long[] elements);
+ method public void clear();
+ method public void ensureCapacity(int capacity);
+ method public inline int getCapacity();
+ method public operator void minusAssign(androidx.collection.LongList elements);
+ method public inline operator void minusAssign(long element);
+ method public operator void minusAssign(long[] elements);
+ method public inline operator void plusAssign(androidx.collection.LongList elements);
+ method public inline operator void plusAssign(long element);
+ method public inline operator void plusAssign(long[] elements);
+ method public boolean remove(long element);
+ method public boolean removeAll(androidx.collection.LongList elements);
+ method public boolean removeAll(long[] elements);
+ method public long removeAt(@IntRange(from=0L) int index);
+ method public void removeRange(@IntRange(from=0L) int start, @IntRange(from=0L) int end);
+ method public boolean retainAll(androidx.collection.LongList elements);
+ method public boolean retainAll(long[] elements);
+ method public operator long set(@IntRange(from=0L) int index, long element);
+ method public void sort();
+ method public void sortDescending();
+ method public void trim(optional int minCapacity);
+ property public final inline int capacity;
+ }
+
+ public final class MutableLongLongMap extends androidx.collection.LongLongMap {
+ ctor public MutableLongLongMap();
+ ctor public MutableLongLongMap(optional int initialCapacity);
+ method public void clear();
+ method public inline long getOrPut(long key, kotlin.jvm.functions.Function0<java.lang.Long> defaultValue);
+ method public inline operator void minusAssign(androidx.collection.LongList keys);
+ method public inline operator void minusAssign(androidx.collection.LongSet keys);
+ method public inline operator void minusAssign(long key);
+ method public inline operator void minusAssign(long[] keys);
+ method public inline operator void plusAssign(androidx.collection.LongLongMap from);
+ method public void put(long key, long value);
+ method public long put(long key, long value, long default);
+ method public void putAll(androidx.collection.LongLongMap from);
+ method public void remove(long key);
+ method public boolean remove(long key, long value);
+ method public inline void removeIf(kotlin.jvm.functions.Function2<? super java.lang.Long,? super java.lang.Long,java.lang.Boolean> predicate);
+ method @kotlin.PublishedApi internal void removeValueAt(int index);
+ method public operator void set(long key, long value);
+ method public int trim();
+ }
+
+ public final class MutableLongObjectMap<V> extends androidx.collection.LongObjectMap<V> {
+ ctor public MutableLongObjectMap();
+ ctor public MutableLongObjectMap(optional int initialCapacity);
+ method public void clear();
+ method public inline V getOrPut(long key, kotlin.jvm.functions.Function0<? extends V> defaultValue);
+ method public inline operator void minusAssign(androidx.collection.LongList keys);
+ method public inline operator void minusAssign(androidx.collection.LongSet keys);
+ method public inline operator void minusAssign(long key);
+ method public inline operator void minusAssign(long[] keys);
+ method public inline operator void plusAssign(androidx.collection.LongObjectMap<V> from);
+ method public V? put(long key, V value);
+ method public void putAll(androidx.collection.LongObjectMap<V> from);
+ method public V? remove(long key);
+ method public boolean remove(long key, V value);
+ method public inline void removeIf(kotlin.jvm.functions.Function2<? super java.lang.Long,? super V,java.lang.Boolean> predicate);
+ method @kotlin.PublishedApi internal V? removeValueAt(int index);
+ method public operator void set(long key, V value);
+ method public int trim();
+ }
+
+ public final class MutableLongSet extends androidx.collection.LongSet {
+ ctor public MutableLongSet();
+ ctor public MutableLongSet(optional int initialCapacity);
+ method public boolean add(long element);
+ method public boolean addAll(androidx.collection.LongSet elements);
+ method public boolean addAll(long[] elements);
+ method public void clear();
+ method public operator void minusAssign(androidx.collection.LongSet elements);
+ method public operator void minusAssign(long element);
+ method public operator void minusAssign(long[] elements);
+ method public operator void plusAssign(androidx.collection.LongSet elements);
+ method public operator void plusAssign(long element);
+ method public operator void plusAssign(long[] elements);
+ method public boolean remove(long element);
+ method public boolean removeAll(androidx.collection.LongSet elements);
+ method public boolean removeAll(long[] elements);
+ method @IntRange(from=0L) public int trim();
+ }
+
+ public final class MutableObjectFloatMap<K> extends androidx.collection.ObjectFloatMap<K> {
+ ctor public MutableObjectFloatMap();
+ ctor public MutableObjectFloatMap(optional int initialCapacity);
+ method public void clear();
+ method public inline float getOrPut(K key, kotlin.jvm.functions.Function0<java.lang.Float> defaultValue);
+ method public inline operator void minusAssign(androidx.collection.ScatterSet<K> keys);
+ method public inline operator void minusAssign(Iterable<? extends K> keys);
+ method public inline operator void minusAssign(K key);
+ method public inline operator void minusAssign(K[] keys);
+ method public inline operator void minusAssign(kotlin.sequences.Sequence<? extends K> keys);
+ method public inline operator void plusAssign(androidx.collection.ObjectFloatMap<K> from);
+ method public void put(K key, float value);
+ method public float put(K key, float value, float default);
+ method public void putAll(androidx.collection.ObjectFloatMap<K> from);
+ method public void remove(K key);
+ method public boolean remove(K key, float value);
+ method public inline void removeIf(kotlin.jvm.functions.Function2<? super K,? super java.lang.Float,java.lang.Boolean> predicate);
+ method @kotlin.PublishedApi internal void removeValueAt(int index);
+ method public operator void set(K key, float value);
+ method public int trim();
+ }
+
+ public final class MutableObjectIntMap<K> extends androidx.collection.ObjectIntMap<K> {
+ ctor public MutableObjectIntMap();
+ ctor public MutableObjectIntMap(optional int initialCapacity);
+ method public void clear();
+ method public inline int getOrPut(K key, kotlin.jvm.functions.Function0<java.lang.Integer> defaultValue);
+ method public inline operator void minusAssign(androidx.collection.ScatterSet<K> keys);
+ method public inline operator void minusAssign(Iterable<? extends K> keys);
+ method public inline operator void minusAssign(K key);
+ method public inline operator void minusAssign(K[] keys);
+ method public inline operator void minusAssign(kotlin.sequences.Sequence<? extends K> keys);
+ method public inline operator void plusAssign(androidx.collection.ObjectIntMap<K> from);
+ method public void put(K key, int value);
+ method public int put(K key, int value, int default);
+ method public void putAll(androidx.collection.ObjectIntMap<K> from);
+ method public void remove(K key);
+ method public boolean remove(K key, int value);
+ method public inline void removeIf(kotlin.jvm.functions.Function2<? super K,? super java.lang.Integer,java.lang.Boolean> predicate);
+ method @kotlin.PublishedApi internal void removeValueAt(int index);
+ method public operator void set(K key, int value);
+ method public int trim();
+ }
+
+ public final class MutableObjectList<E> extends androidx.collection.ObjectList<E> {
+ ctor public MutableObjectList();
+ ctor public MutableObjectList(optional int initialCapacity);
+ method public boolean add(E element);
+ method public void add(@IntRange(from=0L) int index, E element);
+ method public boolean addAll(androidx.collection.ObjectList<E> elements);
+ method public boolean addAll(androidx.collection.ScatterSet<E> elements);
+ method public boolean addAll(E[] elements);
+ method public boolean addAll(@IntRange(from=0L) int index, androidx.collection.ObjectList<E> elements);
+ method public boolean addAll(@IntRange(from=0L) int index, E[] elements);
+ method public boolean addAll(@IntRange(from=0L) int index, java.util.Collection<? extends E> elements);
+ method public boolean addAll(Iterable<? extends E> elements);
+ method public boolean addAll(java.util.List<? extends E> elements);
+ method public boolean addAll(kotlin.sequences.Sequence<? extends E> elements);
+ method public java.util.List<E> asList();
+ method public java.util.List<E> asMutableList();
+ method public void clear();
+ method public inline void ensureCapacity(int capacity);
+ method public inline int getCapacity();
+ method public operator void minusAssign(androidx.collection.ObjectList<E> elements);
+ method public operator void minusAssign(androidx.collection.ScatterSet<E> elements);
+ method public inline operator void minusAssign(E element);
+ method public operator void minusAssign(E[] elements);
+ method public operator void minusAssign(Iterable<? extends E> elements);
+ method public operator void minusAssign(java.util.List<? extends E> elements);
+ method public operator void minusAssign(kotlin.sequences.Sequence<? extends E> elements);
+ method public operator void plusAssign(androidx.collection.ObjectList<E> elements);
+ method public operator void plusAssign(androidx.collection.ScatterSet<E> elements);
+ method public inline operator void plusAssign(E element);
+ method public operator void plusAssign(E[] elements);
+ method public operator void plusAssign(Iterable<? extends E> elements);
+ method public operator void plusAssign(java.util.List<? extends E> elements);
+ method public operator void plusAssign(kotlin.sequences.Sequence<? extends E> elements);
+ method public boolean remove(E element);
+ method public boolean removeAll(androidx.collection.ObjectList<E> elements);
+ method public boolean removeAll(androidx.collection.ScatterSet<E> elements);
+ method public boolean removeAll(E[] elements);
+ method public boolean removeAll(Iterable<? extends E> elements);
+ method public boolean removeAll(java.util.List<? extends E> elements);
+ method public boolean removeAll(kotlin.sequences.Sequence<? extends E> elements);
+ method public E removeAt(@IntRange(from=0L) int index);
+ method public inline void removeIf(kotlin.jvm.functions.Function1<? super E,java.lang.Boolean> predicate);
+ method public void removeRange(@IntRange(from=0L) int start, @IntRange(from=0L) int end);
+ method @kotlin.PublishedApi internal void resizeStorage(int capacity, Object?[] oldContent);
+ method public boolean retainAll(androidx.collection.ObjectList<E> elements);
+ method public boolean retainAll(E[] elements);
+ method public boolean retainAll(Iterable<? extends E> elements);
+ method public boolean retainAll(java.util.Collection<? extends E> elements);
+ method public boolean retainAll(kotlin.sequences.Sequence<? extends E> elements);
+ method public operator E set(@IntRange(from=0L) int index, E element);
+ method public void trim(optional int minCapacity);
+ property public final inline int capacity;
+ }
+
+ public final class MutableObjectLongMap<K> extends androidx.collection.ObjectLongMap<K> {
+ ctor public MutableObjectLongMap();
+ ctor public MutableObjectLongMap(optional int initialCapacity);
+ method public void clear();
+ method public inline long getOrPut(K key, kotlin.jvm.functions.Function0<java.lang.Long> defaultValue);
+ method public inline operator void minusAssign(androidx.collection.ScatterSet<K> keys);
+ method public inline operator void minusAssign(Iterable<? extends K> keys);
+ method public inline operator void minusAssign(K key);
+ method public inline operator void minusAssign(K[] keys);
+ method public inline operator void minusAssign(kotlin.sequences.Sequence<? extends K> keys);
+ method public inline operator void plusAssign(androidx.collection.ObjectLongMap<K> from);
+ method public void put(K key, long value);
+ method public long put(K key, long value, long default);
+ method public void putAll(androidx.collection.ObjectLongMap<K> from);
+ method public void remove(K key);
+ method public boolean remove(K key, long value);
+ method public inline void removeIf(kotlin.jvm.functions.Function2<? super K,? super java.lang.Long,java.lang.Boolean> predicate);
+ method @kotlin.PublishedApi internal void removeValueAt(int index);
+ method public operator void set(K key, long value);
+ method public int trim();
+ }
+
+ public final class MutableOrderedScatterSet<E> extends androidx.collection.OrderedScatterSet<E> {
+ ctor public MutableOrderedScatterSet();
+ ctor public MutableOrderedScatterSet(optional int initialCapacity);
+ method public boolean add(E element);
+ method public boolean addAll(androidx.collection.ObjectList<E> elements);
+ method public boolean addAll(androidx.collection.OrderedScatterSet<E> elements);
+ method public boolean addAll(androidx.collection.ScatterSet<E> elements);
+ method public boolean addAll(E[] elements);
+ method public boolean addAll(Iterable<? extends E> elements);
+ method public boolean addAll(kotlin.sequences.Sequence<? extends E> elements);
+ method public java.util.Set<E> asMutableSet();
+ method public void clear();
+ method public operator void minusAssign(androidx.collection.ObjectList<E> elements);
+ method public operator void minusAssign(androidx.collection.OrderedScatterSet<E> elements);
+ method public operator void minusAssign(androidx.collection.ScatterSet<E> elements);
+ method public operator void minusAssign(E element);
+ method public operator void minusAssign(E[] elements);
+ method public operator void minusAssign(Iterable<? extends E> elements);
+ method public operator void minusAssign(kotlin.sequences.Sequence<? extends E> elements);
+ method public operator void plusAssign(androidx.collection.ObjectList<E> elements);
+ method public operator void plusAssign(androidx.collection.OrderedScatterSet<E> elements);
+ method public operator void plusAssign(androidx.collection.ScatterSet<E> elements);
+ method public operator void plusAssign(E element);
+ method public operator void plusAssign(E[] elements);
+ method public operator void plusAssign(Iterable<? extends E> elements);
+ method public operator void plusAssign(kotlin.sequences.Sequence<? extends E> elements);
+ method public boolean remove(E element);
+ method public boolean removeAll(androidx.collection.ObjectList<E> elements);
+ method public boolean removeAll(androidx.collection.OrderedScatterSet<E> elements);
+ method public boolean removeAll(androidx.collection.ScatterSet<E> elements);
+ method public boolean removeAll(E[] elements);
+ method public boolean removeAll(Iterable<? extends E> elements);
+ method public boolean removeAll(kotlin.sequences.Sequence<? extends E> elements);
+ method @kotlin.PublishedApi internal void removeElementAt(int index);
+ method public inline void removeIf(kotlin.jvm.functions.Function1<? super E,java.lang.Boolean> predicate);
+ method public boolean retainAll(androidx.collection.OrderedScatterSet<E> elements);
+ method public boolean retainAll(androidx.collection.ScatterSet<E> elements);
+ method public boolean retainAll(java.util.Collection<? extends E> elements);
+ method public inline boolean retainAll(kotlin.jvm.functions.Function1<? super E,java.lang.Boolean> predicate);
+ method @IntRange(from=0L) public int trim();
+ method public void trimToSize(int maxSize);
+ }
+
+ public final class MutableScatterMap<K, V> extends androidx.collection.ScatterMap<K,V> {
+ ctor public MutableScatterMap();
+ ctor public MutableScatterMap(optional int initialCapacity);
+ method public java.util.Map<K,V> asMutableMap();
+ method public void clear();
+ method public inline V compute(K key, kotlin.jvm.functions.Function2<? super K,? super V?,? extends V> computeBlock);
+ method @kotlin.PublishedApi internal int findInsertIndex(K key);
+ method public inline V getOrPut(K key, kotlin.jvm.functions.Function0<? extends V> defaultValue);
+ method public inline operator void minusAssign(androidx.collection.ObjectList<K> keys);
+ method public inline operator void minusAssign(androidx.collection.ScatterSet<K> keys);
+ method public inline operator void minusAssign(Iterable<? extends K> keys);
+ method public inline operator void minusAssign(K key);
+ method public inline operator void minusAssign(K[] keys);
+ method public inline operator void minusAssign(kotlin.sequences.Sequence<? extends K> keys);
+ method public inline operator void plusAssign(androidx.collection.ScatterMap<K,V> from);
+ method public inline operator void plusAssign(Iterable<? extends kotlin.Pair<? extends K,? extends V>> pairs);
+ method public inline operator void plusAssign(java.util.Map<K,? extends V> from);
+ method public inline operator void plusAssign(kotlin.Pair<? extends K,? extends V> pair);
+ method public inline operator void plusAssign(kotlin.Pair<? extends K,? extends V>[] pairs);
+ method public inline operator void plusAssign(kotlin.sequences.Sequence<? extends kotlin.Pair<? extends K,? extends V>> pairs);
+ method public V? put(K key, V value);
+ method public void putAll(androidx.collection.ScatterMap<K,V> from);
+ method public void putAll(Iterable<? extends kotlin.Pair<? extends K,? extends V>> pairs);
+ method public void putAll(java.util.Map<K,? extends V> from);
+ method public void putAll(kotlin.Pair<? extends K,? extends V>[] pairs);
+ method public void putAll(kotlin.sequences.Sequence<? extends kotlin.Pair<? extends K,? extends V>> pairs);
+ method public V? remove(K key);
+ method public boolean remove(K key, V value);
+ method public inline void removeIf(kotlin.jvm.functions.Function2<? super K,? super V,java.lang.Boolean> predicate);
+ method @kotlin.PublishedApi internal V? removeValueAt(int index);
+ method public operator void set(K key, V value);
+ method public int trim();
+ }
+
+ public final class MutableScatterSet<E> extends androidx.collection.ScatterSet<E> {
+ ctor public MutableScatterSet();
+ ctor public MutableScatterSet(optional int initialCapacity);
+ method public boolean add(E element);
+ method public boolean addAll(androidx.collection.ObjectList<E> elements);
+ method public boolean addAll(androidx.collection.OrderedScatterSet<E> elements);
+ method public boolean addAll(androidx.collection.ScatterSet<E> elements);
+ method public boolean addAll(E[] elements);
+ method public boolean addAll(Iterable<? extends E> elements);
+ method public boolean addAll(kotlin.sequences.Sequence<? extends E> elements);
+ method public java.util.Set<E> asMutableSet();
+ method public void clear();
+ method public operator void minusAssign(androidx.collection.ObjectList<E> elements);
+ method public operator void minusAssign(androidx.collection.OrderedScatterSet<E> elements);
+ method public operator void minusAssign(androidx.collection.ScatterSet<E> elements);
+ method public operator void minusAssign(E element);
+ method public operator void minusAssign(E[] elements);
+ method public operator void minusAssign(Iterable<? extends E> elements);
+ method public operator void minusAssign(kotlin.sequences.Sequence<? extends E> elements);
+ method public operator void plusAssign(androidx.collection.ObjectList<E> elements);
+ method public operator void plusAssign(androidx.collection.OrderedScatterSet<E> elements);
+ method public operator void plusAssign(androidx.collection.ScatterSet<E> elements);
+ method public operator void plusAssign(E element);
+ method public operator void plusAssign(E[] elements);
+ method public operator void plusAssign(Iterable<? extends E> elements);
+ method public operator void plusAssign(kotlin.sequences.Sequence<? extends E> elements);
+ method public boolean remove(E element);
+ method public boolean removeAll(androidx.collection.ObjectList<E> elements);
+ method public boolean removeAll(androidx.collection.OrderedScatterSet<E> elements);
+ method public boolean removeAll(androidx.collection.ScatterSet<E> elements);
+ method public boolean removeAll(E[] elements);
+ method public boolean removeAll(Iterable<? extends E> elements);
+ method public boolean removeAll(kotlin.sequences.Sequence<? extends E> elements);
+ method @kotlin.PublishedApi internal void removeElementAt(int index);
+ method public inline void removeIf(kotlin.jvm.functions.Function1<? super E,java.lang.Boolean> predicate);
+ method public boolean retainAll(androidx.collection.OrderedScatterSet<E> elements);
+ method public boolean retainAll(androidx.collection.ScatterSet<E> elements);
+ method public boolean retainAll(java.util.Collection<? extends E> elements);
+ method public boolean retainAll(kotlin.jvm.functions.Function1<? super E,java.lang.Boolean> predicate);
+ method @IntRange(from=0L) public int trim();
+ }
+
+ public abstract sealed class ObjectFloatMap<K> {
+ method public final inline boolean all(kotlin.jvm.functions.Function2<? super K,? super java.lang.Float,java.lang.Boolean> predicate);
+ method public final boolean any();
+ method public final inline boolean any(kotlin.jvm.functions.Function2<? super K,? super java.lang.Float,java.lang.Boolean> predicate);
+ method public final inline operator boolean contains(K key);
+ method public final boolean containsKey(K key);
+ method public final boolean containsValue(float value);
+ method public final int count();
+ method public final inline int count(kotlin.jvm.functions.Function2<? super K,? super java.lang.Float,java.lang.Boolean> predicate);
+ method @kotlin.PublishedApi internal final int findKeyIndex(K key);
+ method public final inline void forEach(kotlin.jvm.functions.Function2<? super K,? super java.lang.Float,kotlin.Unit> block);
+ method @kotlin.PublishedApi internal final inline void forEachIndexed(kotlin.jvm.functions.Function1<? super java.lang.Integer,kotlin.Unit> block);
+ method public final inline void forEachKey(kotlin.jvm.functions.Function1<? super K,kotlin.Unit> block);
+ method public final inline void forEachValue(kotlin.jvm.functions.Function1<? super java.lang.Float,kotlin.Unit> block);
+ method public final operator float get(K key);
+ method public final int getCapacity();
+ method public final float getOrDefault(K key, float defaultValue);
+ method public final inline float getOrElse(K key, kotlin.jvm.functions.Function0<java.lang.Float> defaultValue);
+ method public final int getSize();
+ method public final boolean isEmpty();
+ method public final boolean isNotEmpty();
+ method public final String joinToString();
+ method public final String joinToString(optional CharSequence separator);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2<? super K,? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2<? super K,? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2<? super K,? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2<? super K,? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2<? super K,? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(kotlin.jvm.functions.Function2<? super K,? super java.lang.Float,? extends java.lang.CharSequence> transform);
+ method public final boolean none();
+ property public final int capacity;
+ property @kotlin.PublishedApi internal final Object?[] keys;
+ property @kotlin.PublishedApi internal final long[] metadata;
+ property public final int size;
+ property @kotlin.PublishedApi internal final float[] values;
+ field @kotlin.PublishedApi internal Object?[] keys;
+ field @kotlin.PublishedApi internal long[] metadata;
+ field @kotlin.PublishedApi internal float[] values;
+ }
+
+ public final class ObjectFloatMapKt {
+ method public static inline <K> androidx.collection.ObjectFloatMap<K> buildObjectFloatMap(int initialCapacity, kotlin.jvm.functions.Function1<? super androidx.collection.MutableObjectFloatMap<K>,kotlin.Unit> builderAction);
+ method public static inline <K> androidx.collection.ObjectFloatMap<K> buildObjectFloatMap(kotlin.jvm.functions.Function1<? super androidx.collection.MutableObjectFloatMap<K>,kotlin.Unit> builderAction);
+ method public static <K> androidx.collection.ObjectFloatMap<K> emptyObjectFloatMap();
+ method public static <K> androidx.collection.MutableObjectFloatMap<K> mutableObjectFloatMapOf();
+ method public static <K> androidx.collection.MutableObjectFloatMap<K> mutableObjectFloatMapOf(K key1, float value1);
+ method public static <K> androidx.collection.MutableObjectFloatMap<K> mutableObjectFloatMapOf(K key1, float value1, K key2, float value2);
+ method public static <K> androidx.collection.MutableObjectFloatMap<K> mutableObjectFloatMapOf(K key1, float value1, K key2, float value2, K key3, float value3);
+ method public static <K> androidx.collection.MutableObjectFloatMap<K> mutableObjectFloatMapOf(K key1, float value1, K key2, float value2, K key3, float value3, K key4, float value4);
+ method public static <K> androidx.collection.MutableObjectFloatMap<K> mutableObjectFloatMapOf(K key1, float value1, K key2, float value2, K key3, float value3, K key4, float value4, K key5, float value5);
+ method public static <K> androidx.collection.ObjectFloatMap<K> objectFloatMap();
+ method public static <K> androidx.collection.ObjectFloatMap<K> objectFloatMapOf(K key1, float value1);
+ method public static <K> androidx.collection.ObjectFloatMap<K> objectFloatMapOf(K key1, float value1, K key2, float value2);
+ method public static <K> androidx.collection.ObjectFloatMap<K> objectFloatMapOf(K key1, float value1, K key2, float value2, K key3, float value3);
+ method public static <K> androidx.collection.ObjectFloatMap<K> objectFloatMapOf(K key1, float value1, K key2, float value2, K key3, float value3, K key4, float value4);
+ method public static <K> androidx.collection.ObjectFloatMap<K> objectFloatMapOf(K key1, float value1, K key2, float value2, K key3, float value3, K key4, float value4, K key5, float value5);
+ }
+
+ public abstract sealed class ObjectIntMap<K> {
+ method public final inline boolean all(kotlin.jvm.functions.Function2<? super K,? super java.lang.Integer,java.lang.Boolean> predicate);
+ method public final boolean any();
+ method public final inline boolean any(kotlin.jvm.functions.Function2<? super K,? super java.lang.Integer,java.lang.Boolean> predicate);
+ method public final inline operator boolean contains(K key);
+ method public final boolean containsKey(K key);
+ method public final boolean containsValue(int value);
+ method public final int count();
+ method public final inline int count(kotlin.jvm.functions.Function2<? super K,? super java.lang.Integer,java.lang.Boolean> predicate);
+ method @kotlin.PublishedApi internal final int findKeyIndex(K key);
+ method public final inline void forEach(kotlin.jvm.functions.Function2<? super K,? super java.lang.Integer,kotlin.Unit> block);
+ method @kotlin.PublishedApi internal final inline void forEachIndexed(kotlin.jvm.functions.Function1<? super java.lang.Integer,kotlin.Unit> block);
+ method public final inline void forEachKey(kotlin.jvm.functions.Function1<? super K,kotlin.Unit> block);
+ method public final inline void forEachValue(kotlin.jvm.functions.Function1<? super java.lang.Integer,kotlin.Unit> block);
+ method public final operator int get(K key);
+ method public final int getCapacity();
+ method public final int getOrDefault(K key, int defaultValue);
+ method public final inline int getOrElse(K key, kotlin.jvm.functions.Function0<java.lang.Integer> defaultValue);
+ method public final int getSize();
+ method public final boolean isEmpty();
+ method public final boolean isNotEmpty();
+ method public final String joinToString();
+ method public final String joinToString(optional CharSequence separator);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2<? super K,? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2<? super K,? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2<? super K,? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2<? super K,? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2<? super K,? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(kotlin.jvm.functions.Function2<? super K,? super java.lang.Integer,? extends java.lang.CharSequence> transform);
+ method public final boolean none();
+ property public final int capacity;
+ property @kotlin.PublishedApi internal final Object?[] keys;
+ property @kotlin.PublishedApi internal final long[] metadata;
+ property public final int size;
+ property @kotlin.PublishedApi internal final int[] values;
+ field @kotlin.PublishedApi internal Object?[] keys;
+ field @kotlin.PublishedApi internal long[] metadata;
+ field @kotlin.PublishedApi internal int[] values;
+ }
+
+ public final class ObjectIntMapKt {
+ method public static inline <K> androidx.collection.ObjectIntMap<K> buildObjectIntMap(int initialCapacity, kotlin.jvm.functions.Function1<? super androidx.collection.MutableObjectIntMap<K>,kotlin.Unit> builderAction);
+ method public static inline <K> androidx.collection.ObjectIntMap<K> buildObjectIntMap(kotlin.jvm.functions.Function1<? super androidx.collection.MutableObjectIntMap<K>,kotlin.Unit> builderAction);
+ method public static <K> androidx.collection.ObjectIntMap<K> emptyObjectIntMap();
+ method public static <K> androidx.collection.MutableObjectIntMap<K> mutableObjectIntMapOf();
+ method public static <K> androidx.collection.MutableObjectIntMap<K> mutableObjectIntMapOf(K key1, int value1);
+ method public static <K> androidx.collection.MutableObjectIntMap<K> mutableObjectIntMapOf(K key1, int value1, K key2, int value2);
+ method public static <K> androidx.collection.MutableObjectIntMap<K> mutableObjectIntMapOf(K key1, int value1, K key2, int value2, K key3, int value3);
+ method public static <K> androidx.collection.MutableObjectIntMap<K> mutableObjectIntMapOf(K key1, int value1, K key2, int value2, K key3, int value3, K key4, int value4);
+ method public static <K> androidx.collection.MutableObjectIntMap<K> mutableObjectIntMapOf(K key1, int value1, K key2, int value2, K key3, int value3, K key4, int value4, K key5, int value5);
+ method public static <K> androidx.collection.ObjectIntMap<K> objectIntMap();
+ method public static <K> androidx.collection.ObjectIntMap<K> objectIntMapOf(K key1, int value1);
+ method public static <K> androidx.collection.ObjectIntMap<K> objectIntMapOf(K key1, int value1, K key2, int value2);
+ method public static <K> androidx.collection.ObjectIntMap<K> objectIntMapOf(K key1, int value1, K key2, int value2, K key3, int value3);
+ method public static <K> androidx.collection.ObjectIntMap<K> objectIntMapOf(K key1, int value1, K key2, int value2, K key3, int value3, K key4, int value4);
+ method public static <K> androidx.collection.ObjectIntMap<K> objectIntMapOf(K key1, int value1, K key2, int value2, K key3, int value3, K key4, int value4, K key5, int value5);
+ }
+
+ public abstract sealed class ObjectList<E> {
+ method public final boolean any();
+ method public final inline boolean any(kotlin.jvm.functions.Function1<? super E,java.lang.Boolean> predicate);
+ method public abstract java.util.List<E> asList();
+ method public final operator boolean contains(E element);
+ method public final boolean containsAll(androidx.collection.ObjectList<E> elements);
+ method public final boolean containsAll(E[] elements);
+ method public final boolean containsAll(Iterable<? extends E> elements);
+ method public final boolean containsAll(java.util.List<? extends E> elements);
+ method public final int count();
+ method public final inline int count(kotlin.jvm.functions.Function1<? super E,java.lang.Boolean> predicate);
+ method public final E elementAt(@IntRange(from=0L) int index);
+ method public final inline E elementAtOrElse(@IntRange(from=0L) int index, kotlin.jvm.functions.Function1<? super java.lang.Integer,? extends E> defaultValue);
+ method public final E first();
+ method public final inline E first(kotlin.jvm.functions.Function1<? super E,java.lang.Boolean> predicate);
+ method public final inline E? firstOrNull();
+ method public final inline E? firstOrNull(kotlin.jvm.functions.Function1<? super E,java.lang.Boolean> predicate);
+ method public final inline <R> R fold(R initial, kotlin.jvm.functions.Function2<? super R,? super E,? extends R> operation);
+ method public final inline <R> R foldIndexed(R initial, kotlin.jvm.functions.Function3<? super java.lang.Integer,? super R,? super E,? extends R> operation);
+ method public final inline <R> R foldRight(R initial, kotlin.jvm.functions.Function2<? super E,? super R,? extends R> operation);
+ method public final inline <R> R foldRightIndexed(R initial, kotlin.jvm.functions.Function3<? super java.lang.Integer,? super E,? super R,? extends R> operation);
+ method public final inline void forEach(kotlin.jvm.functions.Function1<? super E,kotlin.Unit> block);
+ method public final inline void forEachIndexed(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super E,kotlin.Unit> block);
+ method public final inline void forEachReversed(kotlin.jvm.functions.Function1<? super E,kotlin.Unit> block);
+ method public final inline void forEachReversedIndexed(kotlin.jvm.functions.Function2<? super java.lang.Integer,? super E,kotlin.Unit> block);
+ method public final operator E get(@IntRange(from=0L) int index);
+ method public final inline kotlin.ranges.IntRange getIndices();
+ method @IntRange(from=-1L) public final inline int getLastIndex();
+ method @IntRange(from=0L) public final int getSize();
+ method public final int indexOf(E element);
+ method public final inline int indexOfFirst(kotlin.jvm.functions.Function1<? super E,java.lang.Boolean> predicate);
+ method public final inline int indexOfLast(kotlin.jvm.functions.Function1<? super E,java.lang.Boolean> predicate);
+ method public final boolean isEmpty();
+ method public final boolean isNotEmpty();
+ method public final String joinToString();
+ method public final String joinToString(optional CharSequence separator);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, optional kotlin.jvm.functions.Function1<? super E,? extends java.lang.CharSequence>? transform);
+ method public final E last();
+ method public final inline E last(kotlin.jvm.functions.Function1<? super E,java.lang.Boolean> predicate);
+ method public final int lastIndexOf(E element);
+ method public final inline E? lastOrNull();
+ method public final inline E? lastOrNull(kotlin.jvm.functions.Function1<? super E,java.lang.Boolean> predicate);
+ method public final boolean none();
+ method public final inline boolean reversedAny(kotlin.jvm.functions.Function1<? super E,java.lang.Boolean> predicate);
+ property @kotlin.PublishedApi internal final int _size;
+ property @kotlin.PublishedApi internal final Object?[] content;
+ property public final inline kotlin.ranges.IntRange indices;
+ property @IntRange(from=-1L) public final inline int lastIndex;
+ property @IntRange(from=0L) public final int size;
+ field @kotlin.PublishedApi internal int _size;
+ field @kotlin.PublishedApi internal Object?[] content;
+ }
+
+ public final class ObjectListKt {
+ method public static <E> androidx.collection.ObjectList<E> emptyObjectList();
+ method public static inline <E> androidx.collection.MutableObjectList<E> mutableObjectListOf();
+ method public static <E> androidx.collection.MutableObjectList<E> mutableObjectListOf(E element1);
+ method public static <E> androidx.collection.MutableObjectList<E> mutableObjectListOf(E element1, E element2);
+ method public static <E> androidx.collection.MutableObjectList<E> mutableObjectListOf(E element1, E element2, E element3);
+ method public static inline <E> androidx.collection.MutableObjectList<E> mutableObjectListOf(E... elements);
+ method public static <E> androidx.collection.ObjectList<E> objectListOf();
+ method public static <E> androidx.collection.ObjectList<E> objectListOf(E element1);
+ method public static <E> androidx.collection.ObjectList<E> objectListOf(E element1, E element2);
+ method public static <E> androidx.collection.ObjectList<E> objectListOf(E element1, E element2, E element3);
+ method public static <E> androidx.collection.ObjectList<E> objectListOf(E... elements);
+ }
+
+ public abstract sealed class ObjectLongMap<K> {
+ method public final inline boolean all(kotlin.jvm.functions.Function2<? super K,? super java.lang.Long,java.lang.Boolean> predicate);
+ method public final boolean any();
+ method public final inline boolean any(kotlin.jvm.functions.Function2<? super K,? super java.lang.Long,java.lang.Boolean> predicate);
+ method public final inline operator boolean contains(K key);
+ method public final boolean containsKey(K key);
+ method public final boolean containsValue(long value);
+ method public final int count();
+ method public final inline int count(kotlin.jvm.functions.Function2<? super K,? super java.lang.Long,java.lang.Boolean> predicate);
+ method @kotlin.PublishedApi internal final int findKeyIndex(K key);
+ method public final inline void forEach(kotlin.jvm.functions.Function2<? super K,? super java.lang.Long,kotlin.Unit> block);
+ method @kotlin.PublishedApi internal final inline void forEachIndexed(kotlin.jvm.functions.Function1<? super java.lang.Integer,kotlin.Unit> block);
+ method public final inline void forEachKey(kotlin.jvm.functions.Function1<? super K,kotlin.Unit> block);
+ method public final inline void forEachValue(kotlin.jvm.functions.Function1<? super java.lang.Long,kotlin.Unit> block);
+ method public final operator long get(K key);
+ method public final int getCapacity();
+ method public final long getOrDefault(K key, long defaultValue);
+ method public final inline long getOrElse(K key, kotlin.jvm.functions.Function0<java.lang.Long> defaultValue);
+ method public final int getSize();
+ method public final boolean isEmpty();
+ method public final boolean isNotEmpty();
+ method public final String joinToString();
+ method public final String joinToString(optional CharSequence separator);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, kotlin.jvm.functions.Function2<? super K,? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, kotlin.jvm.functions.Function2<? super K,? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, kotlin.jvm.functions.Function2<? super K,? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, optional CharSequence prefix, kotlin.jvm.functions.Function2<? super K,? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(optional CharSequence separator, kotlin.jvm.functions.Function2<? super K,? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final inline String joinToString(kotlin.jvm.functions.Function2<? super K,? super java.lang.Long,? extends java.lang.CharSequence> transform);
+ method public final boolean none();
+ property public final int capacity;
+ property @kotlin.PublishedApi internal final Object?[] keys;
+ property @kotlin.PublishedApi internal final long[] metadata;
+ property public final int size;
+ property @kotlin.PublishedApi internal final long[] values;
+ field @kotlin.PublishedApi internal Object?[] keys;
+ field @kotlin.PublishedApi internal long[] metadata;
+ field @kotlin.PublishedApi internal long[] values;
+ }
+
+ public final class ObjectLongMapKt {
+ method public static inline <K> androidx.collection.ObjectLongMap<K> buildObjectLongMap(int initialCapacity, kotlin.jvm.functions.Function1<? super androidx.collection.MutableObjectLongMap<K>,kotlin.Unit> builderAction);
+ method public static inline <K> androidx.collection.ObjectLongMap<K> buildObjectLongMap(kotlin.jvm.functions.Function1<? super androidx.collection.MutableObjectLongMap<K>,kotlin.Unit> builderAction);
+ method public static <K> androidx.collection.ObjectLongMap<K> emptyObjectLongMap();
+ method public static <K> androidx.collection.MutableObjectLongMap<K> mutableObjectLongMapOf();
+ method public static <K> androidx.collection.MutableObjectLongMap<K> mutableObjectLongMapOf(K key1, long value1);
+ method public static <K> androidx.collection.MutableObjectLongMap<K> mutableObjectLongMapOf(K key1, long value1, K key2, long value2);
+ method public static <K> androidx.collection.MutableObjectLongMap<K> mutableObjectLongMapOf(K key1, long value1, K key2, long value2, K key3, long value3);
+ method public static <K> androidx.collection.MutableObjectLongMap<K> mutableObjectLongMapOf(K key1, long value1, K key2, long value2, K key3, long value3, K key4, long value4);
+ method public static <K> androidx.collection.MutableObjectLongMap<K> mutableObjectLongMapOf(K key1, long value1, K key2, long value2, K key3, long value3, K key4, long value4, K key5, long value5);
+ method public static <K> androidx.collection.ObjectLongMap<K> objectLongMap();
+ method public static <K> androidx.collection.ObjectLongMap<K> objectLongMapOf(K key1, long value1);
+ method public static <K> androidx.collection.ObjectLongMap<K> objectLongMapOf(K key1, long value1, K key2, long value2);
+ method public static <K> androidx.collection.ObjectLongMap<K> objectLongMapOf(K key1, long value1, K key2, long value2, K key3, long value3);
+ method public static <K> androidx.collection.ObjectLongMap<K> objectLongMapOf(K key1, long value1, K key2, long value2, K key3, long value3, K key4, long value4);
+ method public static <K> androidx.collection.ObjectLongMap<K> objectLongMapOf(K key1, long value1, K key2, long value2, K key3, long value3, K key4, long value4, K key5, long value5);
+ }
+
+ public abstract sealed class OrderedScatterSet<E> {
+ method public final inline boolean all(kotlin.jvm.functions.Function1<? super E,java.lang.Boolean> predicate);
+ method public final boolean any();
+ method public final inline boolean any(kotlin.jvm.functions.Function1<? super E,java.lang.Boolean> predicate);
+ method public final java.util.Set<E> asSet();
+ method public final operator boolean contains(E element);
+ method @IntRange(from=0L) public final int count();
+ method @IntRange(from=0L) public final inline int count(kotlin.jvm.functions.Function1<? super E,java.lang.Boolean> predicate);
+ method public final E first();
+ method public final inline E first(kotlin.jvm.functions.Function1<? super E,java.lang.Boolean> predicate);
+ method public final inline E? firstOrNull(kotlin.jvm.functions.Function1<? super E,java.lang.Boolean> predicate);
+ method public final inline void forEach(kotlin.jvm.functions.Function1<? super E,kotlin.Unit> block);
+ method public final inline void forEachReverse(kotlin.jvm.functions.Function1<? super E,kotlin.Unit> block);
+ method @IntRange(from=0L) public final int getCapacity();
+ method @IntRange(from=0L) public final int getSize();
+ method public final boolean isEmpty();
+ method public final boolean isNotEmpty();
+ method public final String joinToString();
+ method public final String joinToString(optional CharSequence separator);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, optional kotlin.jvm.functions.Function1<? super E,? extends java.lang.CharSequence>? transform);
+ method public final E last();
+ method public final inline E last(kotlin.jvm.functions.Function1<? super E,java.lang.Boolean> predicate);
+ method public final inline E? lastOrNull(kotlin.jvm.functions.Function1<? super E,java.lang.Boolean> predicate);
+ method public final boolean none();
+ method public final inline java.util.List<E> toList();
+ method @kotlin.PublishedApi internal final inline void unorderedForEach(kotlin.jvm.functions.Function1<? super E,kotlin.Unit> block);
+ method @kotlin.PublishedApi internal final inline void unorderedForEachIndex(kotlin.jvm.functions.Function1<? super java.lang.Integer,kotlin.Unit> block);
+ property @IntRange(from=0L) public final int capacity;
+ property @kotlin.PublishedApi internal final Object?[] elements;
+ property @kotlin.PublishedApi internal final int head;
+ property @kotlin.PublishedApi internal final long[] metadata;
+ property @kotlin.PublishedApi internal final long[] nodes;
+ property @IntRange(from=0L) public final int size;
+ property @kotlin.PublishedApi internal final int tail;
+ field @kotlin.PublishedApi internal Object?[] elements;
+ field @kotlin.PublishedApi internal int head;
+ field @kotlin.PublishedApi internal long[] metadata;
+ field @kotlin.PublishedApi internal long[] nodes;
+ field @kotlin.PublishedApi internal int tail;
+ }
+
+ public final class OrderedScatterSetKt {
+ method public static <E> androidx.collection.OrderedScatterSet<E> emptyOrderedScatterSet();
+ method public static <E> androidx.collection.MutableOrderedScatterSet<E> mutableOrderedScatterSetOf();
+ method public static <E> androidx.collection.MutableOrderedScatterSet<E> mutableOrderedScatterSetOf(E element1);
+ method public static <E> androidx.collection.MutableOrderedScatterSet<E> mutableOrderedScatterSetOf(E element1, E element2);
+ method public static <E> androidx.collection.MutableOrderedScatterSet<E> mutableOrderedScatterSetOf(E element1, E element2, E element3);
+ method public static <E> androidx.collection.MutableOrderedScatterSet<E> mutableOrderedScatterSetOf(E... elements);
+ method public static <E> androidx.collection.OrderedScatterSet<E> orderedScatterSetOf();
+ method public static <E> androidx.collection.OrderedScatterSet<E> orderedScatterSetOf(E element1);
+ method public static <E> androidx.collection.OrderedScatterSet<E> orderedScatterSetOf(E element1, E element2);
+ method public static <E> androidx.collection.OrderedScatterSet<E> orderedScatterSetOf(E element1, E element2, E element3);
+ method public static <E> androidx.collection.OrderedScatterSet<E> orderedScatterSetOf(E... elements);
+ }
+
+ public abstract sealed class ScatterMap<K, V> {
+ method public final inline boolean all(kotlin.jvm.functions.Function2<? super K,? super V,java.lang.Boolean> predicate);
+ method public final boolean any();
+ method public final inline boolean any(kotlin.jvm.functions.Function2<? super K,? super V,java.lang.Boolean> predicate);
+ method public final java.util.Map<K,V> asMap();
+ method public final operator boolean contains(K key);
+ method public final boolean containsKey(K key);
+ method public final boolean containsValue(V value);
+ method public final int count();
+ method public final inline int count(kotlin.jvm.functions.Function2<? super K,? super V,java.lang.Boolean> predicate);
+ method public final inline void forEach(kotlin.jvm.functions.Function2<? super K,? super V,kotlin.Unit> block);
+ method @kotlin.PublishedApi internal final inline void forEachIndexed(kotlin.jvm.functions.Function1<? super java.lang.Integer,kotlin.Unit> block);
+ method public final inline void forEachKey(kotlin.jvm.functions.Function1<? super K,kotlin.Unit> block);
+ method public final inline void forEachValue(kotlin.jvm.functions.Function1<? super V,kotlin.Unit> block);
+ method public final operator V? get(K key);
+ method public final int getCapacity();
+ method public final V getOrDefault(K key, V defaultValue);
+ method public final inline V getOrElse(K key, kotlin.jvm.functions.Function0<? extends V> defaultValue);
+ method public final int getSize();
+ method public final boolean isEmpty();
+ method public final boolean isNotEmpty();
+ method public final String joinToString();
+ method public final String joinToString(optional CharSequence separator);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, optional kotlin.jvm.functions.Function2<? super K,? super V,? extends java.lang.CharSequence>? transform);
+ method public final boolean none();
+ property public final int capacity;
+ property @kotlin.PublishedApi internal final Object?[] keys;
+ property @kotlin.PublishedApi internal final long[] metadata;
+ property public final int size;
+ property @kotlin.PublishedApi internal final Object?[] values;
+ field @kotlin.PublishedApi internal Object?[] keys;
+ field @kotlin.PublishedApi internal long[] metadata;
+ field @kotlin.PublishedApi internal Object?[] values;
+ }
+
+ public final class ScatterMapKt {
+ method public static <K, V> androidx.collection.ScatterMap<K,V> emptyScatterMap();
+ method @kotlin.PublishedApi internal static inline boolean isFull(long value);
+ method @kotlin.PublishedApi internal static inline int lowestBitSet(long);
+ method @kotlin.PublishedApi internal static inline long maskEmptyOrDeleted(long);
+ method @kotlin.PublishedApi internal static inline long match(long, int m);
+ method public static <K, V> androidx.collection.MutableScatterMap<K,V> mutableScatterMapOf();
+ method public static <K, V> androidx.collection.MutableScatterMap<K,V> mutableScatterMapOf(kotlin.Pair<? extends K,? extends V>... pairs);
+ method @kotlin.PublishedApi internal static inline long readRawMetadata(long[] data, int offset);
+ property @kotlin.PublishedApi internal static final long BitmaskLsb;
+ property @kotlin.PublishedApi internal static final long BitmaskMsb;
+ property @kotlin.PublishedApi internal static final long Sentinel;
+ field @kotlin.PublishedApi internal static final long BitmaskLsb = 72340172838076673L; // 0x101010101010101L
+ field @kotlin.PublishedApi internal static final long BitmaskMsb = -9187201950435737472L; // 0x8080808080808080L
+ field @kotlin.PublishedApi internal static final long Sentinel = 255L; // 0xffL
+ }
+
+ public abstract sealed class ScatterSet<E> {
+ method public final inline boolean all(kotlin.jvm.functions.Function1<? super E,java.lang.Boolean> predicate);
+ method public final boolean any();
+ method public final inline boolean any(kotlin.jvm.functions.Function1<? super E,java.lang.Boolean> predicate);
+ method public final java.util.Set<E> asSet();
+ method public final operator boolean contains(E element);
+ method @IntRange(from=0L) public final int count();
+ method @IntRange(from=0L) public final inline int count(kotlin.jvm.functions.Function1<? super E,java.lang.Boolean> predicate);
+ method public final E first();
+ method public final inline E first(kotlin.jvm.functions.Function1<? super E,java.lang.Boolean> predicate);
+ method public final inline E? firstOrNull(kotlin.jvm.functions.Function1<? super E,java.lang.Boolean> predicate);
+ method public final inline void forEach(kotlin.jvm.functions.Function1<? super E,kotlin.Unit> block);
+ method @kotlin.PublishedApi internal final inline void forEachIndex(kotlin.jvm.functions.Function1<? super java.lang.Integer,kotlin.Unit> block);
+ method @IntRange(from=0L) public final int getCapacity();
+ method @IntRange(from=0L) public final int getSize();
+ method public final boolean isEmpty();
+ method public final boolean isNotEmpty();
+ method public final String joinToString();
+ method public final String joinToString(optional CharSequence separator);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated);
+ method public final String joinToString(optional CharSequence separator, optional CharSequence prefix, optional CharSequence postfix, optional int limit, optional CharSequence truncated, optional kotlin.jvm.functions.Function1<? super E,? extends java.lang.CharSequence>? transform);
+ method public final boolean none();
+ property @IntRange(from=0L) public final int capacity;
+ property @kotlin.PublishedApi internal final Object?[] elements;
+ property @kotlin.PublishedApi internal final long[] metadata;
+ property @IntRange(from=0L) public final int size;
+ field @kotlin.PublishedApi internal Object?[] elements;
+ field @kotlin.PublishedApi internal long[] metadata;
+ }
+
+ public final class ScatterSetKt {
+ method public static <E> androidx.collection.ScatterSet<E> emptyScatterSet();
+ method public static <E> androidx.collection.MutableScatterSet<E> mutableScatterSetOf();
+ method public static <E> androidx.collection.MutableScatterSet<E> mutableScatterSetOf(E element1);
+ method public static <E> androidx.collection.MutableScatterSet<E> mutableScatterSetOf(E element1, E element2);
+ method public static <E> androidx.collection.MutableScatterSet<E> mutableScatterSetOf(E element1, E element2, E element3);
+ method public static <E> androidx.collection.MutableScatterSet<E> mutableScatterSetOf(E... elements);
+ method public static <E> androidx.collection.ScatterSet<E> scatterSetOf();
+ method public static <E> androidx.collection.ScatterSet<E> scatterSetOf(E element1);
+ method public static <E> androidx.collection.ScatterSet<E> scatterSetOf(E element1, E element2);
+ method public static <E> androidx.collection.ScatterSet<E> scatterSetOf(E element1, E element2, E element3);
+ method public static <E> androidx.collection.ScatterSet<E> scatterSetOf(E... elements);
+ }
+
+ public final class SieveCache<K, V> {
+ ctor public SieveCache(@IntRange(from=1L, to=androidx.collection.SieveCacheKt.MaxSize) int maxSize, optional @IntRange(from=0L, to=androidx.collection.SieveCacheKt.MaxSize) int initialCapacity, optional kotlin.jvm.functions.Function2<? super K,? super V,java.lang.Integer> sizeOf, optional kotlin.jvm.functions.Function1<? super K,? extends V?> createValueFromKey, optional kotlin.jvm.functions.Function4<? super K,? super V,? super V?,? super java.lang.Boolean,kotlin.Unit> onEntryRemoved);
+ method public inline boolean all(kotlin.jvm.functions.Function2<? super K,? super V,java.lang.Boolean> predicate);
+ method public boolean any();
+ method public inline boolean any(kotlin.jvm.functions.Function2<? super K,? super V,java.lang.Boolean> predicate);
+ method public operator boolean contains(K key);
+ method public boolean containsKey(K key);
+ method public boolean containsValue(V value);
+ method public int count();
+ method public inline int count(kotlin.jvm.functions.Function2<? super K,? super V,java.lang.Boolean> predicate);
+ method public void evictAll();
+ method public inline void forEach(kotlin.jvm.functions.Function2<? super K,? super V,kotlin.Unit> block);
+ method @kotlin.PublishedApi internal inline void forEachIndexed(kotlin.jvm.functions.Function1<? super java.lang.Integer,kotlin.Unit> block);
+ method public inline void forEachKey(kotlin.jvm.functions.Function1<? super K,kotlin.Unit> block);
+ method public inline void forEachValue(kotlin.jvm.functions.Function1<? super V,kotlin.Unit> block);
+ method public operator V? get(K key);
+ method public int getCapacity();
+ method public int getCount();
+ method public int getMaxSize();
+ method public int getSize();
+ method public boolean isEmpty();
+ method public boolean isNotEmpty();
+ method public inline operator void minusAssign(androidx.collection.ObjectList<K> keys);
+ method public inline operator void minusAssign(androidx.collection.ScatterSet<K> keys);
+ method public inline operator void minusAssign(Iterable<? extends K> keys);
+ method public inline operator void minusAssign(K key);
+ method public inline operator void minusAssign(K[] keys);
+ method public inline operator void minusAssign(kotlin.sequences.Sequence<? extends K> keys);
+ method public boolean none();
+ method public inline operator void plusAssign(androidx.collection.ScatterMap<K,V> from);
+ method public inline operator void plusAssign(androidx.collection.SieveCache<K,V> from);
+ method public inline operator void plusAssign(Iterable<? extends kotlin.Pair<? extends K,? extends V>> pairs);
+ method public inline operator void plusAssign(java.util.Map<K,? extends V> from);
+ method public inline operator void plusAssign(kotlin.Pair<? extends K,? extends V> pair);
+ method public inline operator void plusAssign(kotlin.Pair<? extends K,? extends V>[] pairs);
+ method public inline operator void plusAssign(kotlin.sequences.Sequence<? extends kotlin.Pair<? extends K,? extends V>> pairs);
+ method public V? put(K key, V value);
+ method public void putAll(androidx.collection.ScatterMap<K,V> from);
+ method public void putAll(androidx.collection.SieveCache<K,V> from);
+ method public void putAll(Iterable<? extends kotlin.Pair<? extends K,? extends V>> pairs);
+ method public void putAll(java.util.Map<K,? extends V> from);
+ method public void putAll(kotlin.Pair<? extends K,? extends V>[] pairs);
+ method public void putAll(kotlin.sequences.Sequence<? extends kotlin.Pair<? extends K,? extends V>> pairs);
+ method public V? remove(K key);
+ method public boolean remove(K key, V value);
+ method public void removeIf(kotlin.jvm.functions.Function2<? super K,? super V,java.lang.Boolean> predicate);
+ method public void resize(@IntRange(from=1L, to=androidx.collection.SieveCacheKt.MaxSize) int maxSize);
+ method public inline operator void set(K key, V value);
+ method public void trimToSize(int maxSize);
+ property public final int capacity;
+ property public final int count;
+ property @kotlin.PublishedApi internal final Object?[] keys;
+ property public final int maxSize;
+ property @kotlin.PublishedApi internal final long[] metadata;
+ property public final int size;
+ property @kotlin.PublishedApi internal final Object?[] values;
+ field @kotlin.PublishedApi internal Object?[] keys;
+ field @kotlin.PublishedApi internal long[] metadata;
+ field @kotlin.PublishedApi internal Object?[] values;
+ }
+
+ public final class SieveCacheKt {
+ property @kotlin.PublishedApi internal static final int NodeInvalidLink;
+ property @kotlin.PublishedApi internal static final long NodeLinkMask;
+ field @kotlin.PublishedApi internal static final int NodeInvalidLink = 2147483647; // 0x7fffffff
+ field @kotlin.PublishedApi internal static final long NodeLinkMask = 2147483647L; // 0x7fffffffL
+ }
+
+ public class SimpleArrayMap<K, V> {
+ ctor public SimpleArrayMap();
+ ctor public SimpleArrayMap(androidx.collection.SimpleArrayMap<? extends K,? extends V>? map);
+ ctor public SimpleArrayMap(optional int capacity);
+ method public void clear();
+ method public boolean containsKey(K key);
+ method public boolean containsValue(V value);
+ method public void ensureCapacity(int minimumCapacity);
+ method public operator V? get(K key);
+ method public V getOrDefault(Object? key, V defaultValue);
+ method public int indexOfKey(K key);
+ method public boolean isEmpty();
+ method public K keyAt(int index);
+ method public V? put(K key, V value);
+ method public void putAll(androidx.collection.SimpleArrayMap<? extends K,? extends V> map);
+ method public V? putIfAbsent(K key, V value);
+ method public V? remove(K key);
+ method public boolean remove(K key, V value);
+ method public V removeAt(int index);
+ method public V? replace(K key, V value);
+ method public boolean replace(K key, V oldValue, V newValue);
+ method public V setValueAt(int index, V value);
+ method public int size();
+ method public V valueAt(int index);
+ }
+
+ public class SparseArrayCompat<E> implements java.lang.Cloneable {
+ ctor public SparseArrayCompat();
+ ctor public SparseArrayCompat(optional int initialCapacity);
+ method public void append(int key, E value);
+ method public void clear();
+ method public androidx.collection.SparseArrayCompat<E> clone();
+ method public boolean containsKey(int key);
+ method public boolean containsValue(E value);
+ method @Deprecated public void delete(int key);
+ method public operator E? get(int key);
+ method public E get(int key, E defaultValue);
+ method public final boolean getIsEmpty();
+ method public int indexOfKey(int key);
+ method public int indexOfValue(E value);
+ method public boolean isEmpty();
+ method public int keyAt(int index);
+ method public void put(int key, E value);
+ method public void putAll(androidx.collection.SparseArrayCompat<? extends E> other);
+ method public E? putIfAbsent(int key, E value);
+ method public void remove(int key);
+ method public boolean remove(int key, Object? value);
+ method public void removeAt(int index);
+ method public void removeAtRange(int index, int size);
+ method public E? replace(int key, E value);
+ method public boolean replace(int key, E oldValue, E newValue);
+ method public void setValueAt(int index, E value);
+ method public int size();
+ method public E valueAt(int index);
+ property public final boolean isEmpty;
+ }
+
+ public final class SparseArrayKt {
+ method public static inline operator <T> boolean contains(androidx.collection.SparseArrayCompat<T>, int key);
+ method public static inline <T> void forEach(androidx.collection.SparseArrayCompat<T>, kotlin.jvm.functions.Function2<? super java.lang.Integer,? super T,kotlin.Unit> action);
+ method public static inline <T> T getOrDefault(androidx.collection.SparseArrayCompat<T>, int key, T defaultValue);
+ method public static inline <T> T getOrElse(androidx.collection.SparseArrayCompat<T>, int key, kotlin.jvm.functions.Function0<? extends T> defaultValue);
+ method public static inline <T> int getSize(androidx.collection.SparseArrayCompat<T>);
+ method public static inline <T> boolean isNotEmpty(androidx.collection.SparseArrayCompat<T>);
+ method public static <T> kotlin.collections.IntIterator keyIterator(androidx.collection.SparseArrayCompat<T>);
+ method public static operator <T> androidx.collection.SparseArrayCompat<T> plus(androidx.collection.SparseArrayCompat<T>, androidx.collection.SparseArrayCompat<T> other);
+ method @Deprecated public static <T> boolean remove(androidx.collection.SparseArrayCompat<T>, int key, T value);
+ method public static inline operator <T> void set(androidx.collection.SparseArrayCompat<T>, int key, T value);
+ method public static <T> java.util.Iterator<T> valueIterator(androidx.collection.SparseArrayCompat<T>);
+ }
+
+}
+
+package androidx.collection.internal {
+
+ public final class PackingHelpers_jvmKt {
+ method @kotlin.PublishedApi internal static inline float floatFromBits(int bits);
+ }
+
+ public final class RuntimeHelpersKt {
+ method @kotlin.PublishedApi internal static Void throwNoSuchElementExceptionForInline(String message);
+ }
+
+}
+
diff --git a/compose/foundation/foundation-layout/benchmark/src/androidTest/java/androidx/compose/foundation/layout/benchmark/ColumnIntrinsicsBenchmark.kt b/compose/foundation/foundation-layout/benchmark/src/androidTest/java/androidx/compose/foundation/layout/benchmark/ColumnIntrinsicsBenchmark.kt
new file mode 100644
index 0000000..38bbb6b
--- /dev/null
+++ b/compose/foundation/foundation-layout/benchmark/src/androidTest/java/androidx/compose/foundation/layout/benchmark/ColumnIntrinsicsBenchmark.kt
@@ -0,0 +1,65 @@
+/*
+ * Copyright 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.compose.foundation.layout.benchmark
+
+import androidx.compose.foundation.layout.IntrinsicSize
+import androidx.compose.foundation.layout.requiredHeight
+import androidx.compose.foundation.layout.requiredWidth
+import androidx.compose.testutils.benchmark.ComposeBenchmarkRule
+import androidx.compose.testutils.benchmark.benchmarkFirstMeasure
+import androidx.compose.testutils.benchmark.benchmarkLayoutPerf
+import androidx.compose.ui.Modifier
+import androidx.test.filters.LargeTest
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.Parameterized
+
+/** Benchmark that runs [RectsInColumnTestCase] and tests performance for intrinsic measurements. */
+@LargeTest
+@RunWith(Parameterized::class)
+class ColumnIntrinsicsBenchmark(
+ private val modifierDebugName: String,
+ private val modifier: Modifier
+) {
+
+ companion object {
+ @JvmStatic
+ @Parameterized.Parameters(name = "{0}")
+ fun initParameters(): Array<Array<Any>> =
+ arrayOf(
+ arrayOf("minWidth", Modifier.requiredWidth(IntrinsicSize.Min)),
+ arrayOf("maxWidth", Modifier.requiredWidth(IntrinsicSize.Max)),
+ arrayOf("minHeight", Modifier.requiredHeight(IntrinsicSize.Min)),
+ arrayOf("maxHeight", Modifier.requiredHeight(IntrinsicSize.Max)),
+ )
+ }
+
+ @get:Rule val benchmarkRule = ComposeBenchmarkRule()
+
+ private val rectsInColumnCaseFactory = { RectsInColumnTestCase(10, modifier) }
+
+ @Test
+ fun first_measure_withIntrinsicSize() {
+ benchmarkRule.benchmarkFirstMeasure(rectsInColumnCaseFactory)
+ }
+
+ @Test
+ fun layout_withIntrinsicSize() {
+ benchmarkRule.benchmarkLayoutPerf(rectsInColumnCaseFactory)
+ }
+}
diff --git a/compose/foundation/foundation-layout/benchmark/src/androidTest/java/androidx/compose/foundation/layout/benchmark/FlowColumnIntrinsicsBenchmark.kt b/compose/foundation/foundation-layout/benchmark/src/androidTest/java/androidx/compose/foundation/layout/benchmark/FlowColumnIntrinsicsBenchmark.kt
new file mode 100644
index 0000000..12e7dfe
--- /dev/null
+++ b/compose/foundation/foundation-layout/benchmark/src/androidTest/java/androidx/compose/foundation/layout/benchmark/FlowColumnIntrinsicsBenchmark.kt
@@ -0,0 +1,67 @@
+/*
+ * Copyright 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.compose.foundation.layout.benchmark
+
+import androidx.compose.foundation.layout.IntrinsicSize
+import androidx.compose.foundation.layout.requiredHeight
+import androidx.compose.foundation.layout.requiredWidth
+import androidx.compose.testutils.benchmark.ComposeBenchmarkRule
+import androidx.compose.testutils.benchmark.benchmarkFirstMeasure
+import androidx.compose.testutils.benchmark.benchmarkLayoutPerf
+import androidx.compose.ui.Modifier
+import androidx.test.filters.LargeTest
+import org.junit.Rule
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.Parameterized
+
+/**
+ * Benchmark that runs [RectsInFlowColumnTestCase] and tests performance for intrinsic measurements.
+ */
+@LargeTest
+@RunWith(Parameterized::class)
+class FlowColumnIntrinsicsBenchmark(
+ private val modifierDebugName: String,
+ private val modifier: Modifier
+) {
+
+ companion object {
+ @JvmStatic
+ @Parameterized.Parameters(name = "{0}")
+ fun initParameters(): Array<Array<Any>> =
+ arrayOf(
+ arrayOf("minWidth", Modifier.requiredWidth(IntrinsicSize.Min)),
+ arrayOf("maxWidth", Modifier.requiredWidth(IntrinsicSize.Max)),
+ arrayOf("minHeight", Modifier.requiredHeight(IntrinsicSize.Min)),
+ arrayOf("maxHeight", Modifier.requiredHeight(IntrinsicSize.Max)),
+ )
+ }
+
+ @get:Rule val benchmarkRule = ComposeBenchmarkRule()
+
+ private val rectsInFlowColumnCaseFactory = { RectsInFlowColumnTestCase(10, modifier) }
+
+ @Test
+ fun first_measure_withIntrinsicSize() {
+ benchmarkRule.benchmarkFirstMeasure(rectsInFlowColumnCaseFactory)
+ }
+
+ @Test
+ fun layout_withIntrinsicSize() {
+ benchmarkRule.benchmarkLayoutPerf(rectsInFlowColumnCaseFactory)
+ }
+}
diff --git a/compose/foundation/foundation-layout/benchmark/src/androidTest/java/androidx/compose/foundation/layout/benchmark/RectsInColumnTestCase.kt b/compose/foundation/foundation-layout/benchmark/src/androidTest/java/androidx/compose/foundation/layout/benchmark/RectsInColumnTestCase.kt
index e0c65d6..bb7c9d5d 100644
--- a/compose/foundation/foundation-layout/benchmark/src/androidTest/java/androidx/compose/foundation/layout/benchmark/RectsInColumnTestCase.kt
+++ b/compose/foundation/foundation-layout/benchmark/src/androidTest/java/androidx/compose/foundation/layout/benchmark/RectsInColumnTestCase.kt
@@ -36,14 +36,16 @@
*
* Note: Each rectangle has its own model so changes should always affect only the first one.
*/
-class RectsInColumnTestCase(private val amountOfRectangles: Int) :
- LayeredComposeTestCase(), ToggleableTestCase {
+class RectsInColumnTestCase(
+ private val amountOfRectangles: Int,
+ private val modifier: Modifier = Modifier
+) : LayeredComposeTestCase(), ToggleableTestCase {
private val states = mutableListOf<MutableState<Color>>()
@Composable
override fun MeasuredContent() {
- Column { repeat(amountOfRectangles) { ColoredRectWithModel() } }
+ Column(modifier) { repeat(amountOfRectangles) { ColoredRectWithModel() } }
}
override fun toggleState() {
diff --git a/compose/foundation/foundation-layout/benchmark/src/androidTest/java/androidx/compose/foundation/layout/benchmark/RectsInFlowColumnTestCase.kt b/compose/foundation/foundation-layout/benchmark/src/androidTest/java/androidx/compose/foundation/layout/benchmark/RectsInFlowColumnTestCase.kt
index 299a622..cf87c54 100644
--- a/compose/foundation/foundation-layout/benchmark/src/androidTest/java/androidx/compose/foundation/layout/benchmark/RectsInFlowColumnTestCase.kt
+++ b/compose/foundation/foundation-layout/benchmark/src/androidTest/java/androidx/compose/foundation/layout/benchmark/RectsInFlowColumnTestCase.kt
@@ -38,14 +38,16 @@
* Note: Each rectangle has its own model so changes should always affect only the first one.
*/
@OptIn(ExperimentalLayoutApi::class)
-class RectsInFlowColumnTestCase(private val amountOfRectangles: Int) :
- LayeredComposeTestCase(), ToggleableTestCase {
+class RectsInFlowColumnTestCase(
+ private val amountOfRectangles: Int,
+ private val modifier: Modifier = Modifier
+) : LayeredComposeTestCase(), ToggleableTestCase {
private val states = mutableListOf<MutableState<Color>>()
@Composable
override fun MeasuredContent() {
- FlowColumn(maxItemsInEachColumn = 3) {
+ FlowColumn(modifier, maxItemsInEachColumn = 3) {
repeat(amountOfRectangles) { ColoredRectWithModel() }
}
}
diff --git a/compose/foundation/foundation-layout/src/commonMain/kotlin/androidx/compose/foundation/layout/AlignmentLine.kt b/compose/foundation/foundation-layout/src/commonMain/kotlin/androidx/compose/foundation/layout/AlignmentLine.kt
index fb9ac8c05..99d2381 100644
--- a/compose/foundation/foundation-layout/src/commonMain/kotlin/androidx/compose/foundation/layout/AlignmentLine.kt
+++ b/compose/foundation/foundation-layout/src/commonMain/kotlin/androidx/compose/foundation/layout/AlignmentLine.kt
@@ -33,6 +33,7 @@
import androidx.compose.ui.unit.Constraints
import androidx.compose.ui.unit.Dp
import androidx.compose.ui.unit.TextUnit
+import androidx.compose.ui.unit.isSpecified
import androidx.compose.ui.unit.isUnspecified
import kotlin.math.max
@@ -142,14 +143,14 @@
@Stable
fun Modifier.paddingFromBaseline(top: Dp = Dp.Unspecified, bottom: Dp = Dp.Unspecified) =
this.then(
- if (top != Dp.Unspecified) {
+ if (top.isSpecified) {
Modifier.paddingFrom(FirstBaseline, before = top)
} else {
Modifier
}
)
.then(
- if (bottom != Dp.Unspecified) {
+ if (bottom.isSpecified) {
Modifier.paddingFrom(LastBaseline, after = bottom)
} else {
Modifier
@@ -192,8 +193,8 @@
) : ModifierNodeElement<AlignmentLineOffsetDpNode>() {
init {
requirePrecondition(
- (before.value >= 0f || before == Dp.Unspecified) &&
- (after.value >= 0f || after == Dp.Unspecified)
+ (before.value >= 0f || before.isUnspecified) and
+ (after.value >= 0f || after.isUnspecified)
) {
"Padding from alignment line must be a non-negative number"
}
@@ -319,12 +320,12 @@
val axisMax = if (alignmentLine.horizontal) constraints.maxHeight else constraints.maxWidth
// Compute padding required to satisfy the total before and after offsets.
val paddingBefore =
- ((if (before != Dp.Unspecified) before.roundToPx() else 0) - linePosition).coerceIn(
+ ((if (before.isSpecified) before.roundToPx() else 0) - linePosition).coerceIn(
0,
axisMax - axis
)
val paddingAfter =
- ((if (after != Dp.Unspecified) after.roundToPx() else 0) - axis + linePosition).coerceIn(
+ ((if (after.isSpecified) after.roundToPx() else 0) - axis + linePosition).coerceIn(
0,
axisMax - axis - paddingBefore
)
diff --git a/compose/foundation/foundation-layout/src/commonMain/kotlin/androidx/compose/foundation/layout/FlowLayout.kt b/compose/foundation/foundation-layout/src/commonMain/kotlin/androidx/compose/foundation/layout/FlowLayout.kt
index 05f1276..8417dd1 100644
--- a/compose/foundation/foundation-layout/src/commonMain/kotlin/androidx/compose/foundation/layout/FlowLayout.kt
+++ b/compose/foundation/foundation-layout/src/commonMain/kotlin/androidx/compose/foundation/layout/FlowLayout.kt
@@ -788,8 +788,8 @@
) =
minIntrinsicMainAxisSize(
measurables,
- mainAxisSize = minMainAxisIntrinsicItemSize,
- crossAxisSize = minCrossAxisIntrinsicItemSize,
+ mainAxisSize = { _, size -> minMainAxisIntrinsicItemSize(size) },
+ crossAxisSize = { _, size -> minCrossAxisIntrinsicItemSize(size) },
crossAxisAvailable,
mainAxisSpacing,
crossAxisSpacing,
@@ -805,7 +805,7 @@
) =
maxIntrinsicMainAxisSize(
measurables,
- maxMainAxisIntrinsicItemSize,
+ { _, size -> maxMainAxisIntrinsicItemSize(size) },
height,
arrangementSpacing,
maxItemsInMainAxis
@@ -822,8 +822,8 @@
) =
intrinsicCrossAxisSize(
measurables,
- mainAxisSize = minMainAxisIntrinsicItemSize,
- crossAxisSize = minCrossAxisIntrinsicItemSize,
+ mainAxisSize = { _, size -> minMainAxisIntrinsicItemSize(size) },
+ crossAxisSize = { _, size -> minCrossAxisIntrinsicItemSize(size) },
mainAxisAvailable,
mainAxisSpacing,
crossAxisSpacing,
@@ -833,20 +833,17 @@
)
.first
- val maxMainAxisIntrinsicItemSize: IntrinsicMeasurable.(Int, Int) -> Int =
- if (isHorizontal) { _, h -> maxIntrinsicWidth(h) } else { _, w -> maxIntrinsicHeight(w) }
+ fun IntrinsicMeasurable.maxMainAxisIntrinsicItemSize(size: Int): Int =
+ if (isHorizontal) maxIntrinsicWidth(size) else maxIntrinsicHeight(size)
- val maxCrossAxisIntrinsicItemSize: IntrinsicMeasurable.(Int, Int) -> Int =
- if (isHorizontal) { _, w -> maxIntrinsicHeight(w) } else { _, h -> maxIntrinsicWidth(h) }
+ fun IntrinsicMeasurable.minCrossAxisIntrinsicItemSize(size: Int): Int =
+ if (isHorizontal) minIntrinsicHeight(size) else minIntrinsicWidth(size)
- val minCrossAxisIntrinsicItemSize: IntrinsicMeasurable.(Int, Int) -> Int =
- if (isHorizontal) { _, w -> minIntrinsicHeight(w) } else { _, h -> minIntrinsicWidth(h) }
-
- val minMainAxisIntrinsicItemSize: IntrinsicMeasurable.(Int, Int) -> Int =
- if (isHorizontal) { _, h -> minIntrinsicWidth(h) } else { _, w -> minIntrinsicHeight(w) }
+ fun IntrinsicMeasurable.minMainAxisIntrinsicItemSize(size: Int): Int =
+ if (isHorizontal) minIntrinsicWidth(size) else minIntrinsicHeight(size)
}
-private fun maxIntrinsicMainAxisSize(
+private inline fun maxIntrinsicMainAxisSize(
children: List<IntrinsicMeasurable>,
mainAxisSize: IntrinsicMeasurable.(Int, Int) -> Int,
crossAxisAvailable: Int,
@@ -875,8 +872,9 @@
* Slower algorithm but needed to determine the minimum main axis size Uses a binary search to
* search different scenarios to see the minimum main axis size
*/
+@Suppress("BanInlineOptIn")
@OptIn(ExperimentalLayoutApi::class)
-private fun minIntrinsicMainAxisSize(
+private inline fun minIntrinsicMainAxisSize(
children: List<IntrinsicMeasurable>,
mainAxisSize: IntrinsicMeasurable.(Int, Int) -> Int,
crossAxisSize: IntrinsicMeasurable.(Int, Int) -> Int,
@@ -994,7 +992,7 @@
* FlowRow: Intrinsic height (cross Axis) is based on a specified width
* * FlowColumn: Intrinsic width (crossAxis) based on a specified height
*/
-private fun intrinsicCrossAxisSize(
+private inline fun intrinsicCrossAxisSize(
children: List<IntrinsicMeasurable>,
mainAxisSize: IntrinsicMeasurable.(Int, Int) -> Int,
crossAxisSize: IntrinsicMeasurable.(Int, Int) -> Int,
diff --git a/compose/foundation/foundation-layout/src/commonMain/kotlin/androidx/compose/foundation/layout/Padding.kt b/compose/foundation/foundation-layout/src/commonMain/kotlin/androidx/compose/foundation/layout/Padding.kt
index 24ac686..c038279 100644
--- a/compose/foundation/foundation-layout/src/commonMain/kotlin/androidx/compose/foundation/layout/Padding.kt
+++ b/compose/foundation/foundation-layout/src/commonMain/kotlin/androidx/compose/foundation/layout/Padding.kt
@@ -33,6 +33,7 @@
import androidx.compose.ui.unit.constrainHeight
import androidx.compose.ui.unit.constrainWidth
import androidx.compose.ui.unit.dp
+import androidx.compose.ui.unit.isUnspecified
import androidx.compose.ui.unit.offset
/**
@@ -203,10 +204,14 @@
) : PaddingValues {
init {
- requirePrecondition(left.value >= 0) { "Left padding must be non-negative" }
- requirePrecondition(top.value >= 0) { "Top padding must be non-negative" }
- requirePrecondition(right.value >= 0) { "Right padding must be non-negative" }
- requirePrecondition(bottom.value >= 0) { "Bottom padding must be non-negative" }
+ requirePrecondition(
+ (left.value >= 0f) and
+ (top.value >= 0f) and
+ (right.value >= 0f) and
+ (bottom.value >= 0f)
+ ) {
+ "Padding must be non-negative"
+ }
}
override fun calculateLeftPadding(layoutDirection: LayoutDirection) = left
@@ -291,10 +296,11 @@
) : PaddingValues {
init {
- requirePrecondition(start.value >= 0) { "Start padding must be non-negative" }
- requirePrecondition(top.value >= 0) { "Top padding must be non-negative" }
- requirePrecondition(end.value >= 0) { "End padding must be non-negative" }
- requirePrecondition(bottom.value >= 0) { "Bottom padding must be non-negative" }
+ requirePrecondition(
+ (start.value >= 0f) and (top.value >= 0f) and (end.value >= 0f) and (bottom.value >= 0f)
+ ) {
+ "Padding must be non-negative"
+ }
}
override fun calculateLeftPadding(layoutDirection: LayoutDirection) =
@@ -332,10 +338,10 @@
init {
requirePrecondition(
- (start.value >= 0f || start == Dp.Unspecified) &&
- (top.value >= 0f || top == Dp.Unspecified) &&
- (end.value >= 0f || end == Dp.Unspecified) &&
- (bottom.value >= 0f || bottom == Dp.Unspecified)
+ (start.value >= 0f || start.isUnspecified) and
+ (top.value >= 0f || top.isUnspecified) and
+ (end.value >= 0f || end.isUnspecified) and
+ (bottom.value >= 0f || bottom.isUnspecified)
) {
"Padding must be non-negative"
}
@@ -436,30 +442,30 @@
measurable: Measurable,
constraints: Constraints
): MeasureResult {
+ val leftPadding = paddingValues.calculateLeftPadding(layoutDirection)
+ val topPadding = paddingValues.calculateTopPadding()
+ val rightPadding = paddingValues.calculateRightPadding(layoutDirection)
+ val bottomPadding = paddingValues.calculateBottomPadding()
+
requirePrecondition(
- paddingValues.calculateLeftPadding(layoutDirection) >= 0.dp &&
- paddingValues.calculateTopPadding() >= 0.dp &&
- paddingValues.calculateRightPadding(layoutDirection) >= 0.dp &&
- paddingValues.calculateBottomPadding() >= 0.dp
+ (leftPadding >= 0.dp) and
+ (topPadding >= 0.dp) and
+ (rightPadding >= 0.dp) and
+ (bottomPadding >= 0.dp)
) {
"Padding must be non-negative"
}
- val horizontal =
- paddingValues.calculateLeftPadding(layoutDirection).roundToPx() +
- paddingValues.calculateRightPadding(layoutDirection).roundToPx()
- val vertical =
- paddingValues.calculateTopPadding().roundToPx() +
- paddingValues.calculateBottomPadding().roundToPx()
+
+ val roundedLeftPadding = leftPadding.roundToPx()
+ val horizontal = roundedLeftPadding + rightPadding.roundToPx()
+
+ val roundedTopPadding = topPadding.roundToPx()
+ val vertical = roundedTopPadding + bottomPadding.roundToPx()
val placeable = measurable.measure(constraints.offset(-horizontal, -vertical))
val width = constraints.constrainWidth(placeable.width + horizontal)
val height = constraints.constrainHeight(placeable.height + vertical)
- return layout(width, height) {
- placeable.place(
- paddingValues.calculateLeftPadding(layoutDirection).roundToPx(),
- paddingValues.calculateTopPadding().roundToPx()
- )
- }
+ return layout(width, height) { placeable.place(roundedLeftPadding, roundedTopPadding) }
}
}
diff --git a/compose/foundation/foundation-layout/src/commonMain/kotlin/androidx/compose/foundation/layout/Size.kt b/compose/foundation/foundation-layout/src/commonMain/kotlin/androidx/compose/foundation/layout/Size.kt
index b221c8b..52e00de 100644
--- a/compose/foundation/foundation-layout/src/commonMain/kotlin/androidx/compose/foundation/layout/Size.kt
+++ b/compose/foundation/foundation-layout/src/commonMain/kotlin/androidx/compose/foundation/layout/Size.kt
@@ -39,6 +39,10 @@
import androidx.compose.ui.unit.constrain
import androidx.compose.ui.unit.constrainHeight
import androidx.compose.ui.unit.constrainWidth
+import androidx.compose.ui.unit.isSpecified
+import androidx.compose.ui.util.fastCoerceAtLeast
+import androidx.compose.ui.util.fastCoerceAtMost
+import androidx.compose.ui.util.fastCoerceIn
import androidx.compose.ui.util.fastRoundToInt
/**
@@ -694,7 +698,7 @@
val width =
(constraints.maxWidth * fraction)
.fastRoundToInt()
- .coerceIn(constraints.minWidth, constraints.maxWidth)
+ .fastCoerceIn(constraints.minWidth, constraints.maxWidth)
minWidth = width
maxWidth = width
} else {
@@ -707,7 +711,7 @@
val height =
(constraints.maxHeight * fraction)
.fastRoundToInt()
- .coerceIn(constraints.minHeight, constraints.maxHeight)
+ .fastCoerceIn(constraints.minHeight, constraints.maxHeight)
minHeight = height
maxHeight = height
} else {
@@ -782,28 +786,28 @@
private val Density.targetConstraints: Constraints
get() {
val maxWidth =
- if (maxWidth != Dp.Unspecified) {
- maxWidth.roundToPx().coerceAtLeast(0)
+ if (maxWidth.isSpecified) {
+ maxWidth.roundToPx().fastCoerceAtLeast(0)
} else {
Constraints.Infinity
}
val maxHeight =
- if (maxHeight != Dp.Unspecified) {
- maxHeight.roundToPx().coerceAtLeast(0)
+ if (maxHeight.isSpecified) {
+ maxHeight.roundToPx().fastCoerceAtLeast(0)
} else {
Constraints.Infinity
}
val minWidth =
- if (minWidth != Dp.Unspecified) {
- minWidth.roundToPx().coerceAtMost(maxWidth).coerceAtLeast(0).let {
+ if (minWidth.isSpecified) {
+ minWidth.roundToPx().fastCoerceIn(0, maxWidth).let {
if (it != Constraints.Infinity) it else 0
}
} else {
0
}
val minHeight =
- if (minHeight != Dp.Unspecified) {
- minHeight.roundToPx().coerceAtMost(maxHeight).coerceAtLeast(0).let {
+ if (minHeight.isSpecified) {
+ minHeight.roundToPx().fastCoerceIn(0, maxHeight).let {
if (it != Constraints.Infinity) it else 0
}
} else {
@@ -827,28 +831,28 @@
constraints.constrain(targetConstraints)
} else {
val resolvedMinWidth =
- if (minWidth != Dp.Unspecified) {
+ if (minWidth.isSpecified) {
targetConstraints.minWidth
} else {
- constraints.minWidth.coerceAtMost(targetConstraints.maxWidth)
+ constraints.minWidth.fastCoerceAtMost(targetConstraints.maxWidth)
}
val resolvedMaxWidth =
- if (maxWidth != Dp.Unspecified) {
+ if (maxWidth.isSpecified) {
targetConstraints.maxWidth
} else {
- constraints.maxWidth.coerceAtLeast(targetConstraints.minWidth)
+ constraints.maxWidth.fastCoerceAtLeast(targetConstraints.minWidth)
}
val resolvedMinHeight =
- if (minHeight != Dp.Unspecified) {
+ if (minHeight.isSpecified) {
targetConstraints.minHeight
} else {
- constraints.minHeight.coerceAtMost(targetConstraints.maxHeight)
+ constraints.minHeight.fastCoerceAtMost(targetConstraints.maxHeight)
}
val resolvedMaxHeight =
- if (maxHeight != Dp.Unspecified) {
+ if (maxHeight.isSpecified) {
targetConstraints.maxHeight
} else {
- constraints.maxHeight.coerceAtLeast(targetConstraints.minHeight)
+ constraints.maxHeight.fastCoerceAtLeast(targetConstraints.minHeight)
}
Constraints(
resolvedMinWidth,
@@ -1072,14 +1076,14 @@
): MeasureResult {
val wrappedConstraints =
Constraints(
- if (minWidth != Dp.Unspecified && constraints.minWidth == 0) {
- minWidth.roundToPx().coerceAtMost(constraints.maxWidth).coerceAtLeast(0)
+ if (minWidth.isSpecified && constraints.minWidth == 0) {
+ minWidth.roundToPx().fastCoerceIn(0, constraints.maxWidth)
} else {
constraints.minWidth
},
constraints.maxWidth,
- if (minHeight != Dp.Unspecified && constraints.minHeight == 0) {
- minHeight.roundToPx().coerceAtMost(constraints.maxHeight).coerceAtLeast(0)
+ if (minHeight.isSpecified && constraints.minHeight == 0) {
+ minHeight.roundToPx().fastCoerceIn(0, constraints.maxHeight)
} else {
constraints.minHeight
},
@@ -1095,7 +1099,7 @@
) =
measurable
.minIntrinsicWidth(height)
- .coerceAtLeast(if (minWidth != Dp.Unspecified) minWidth.roundToPx() else 0)
+ .fastCoerceAtLeast(if (minWidth.isSpecified) minWidth.roundToPx() else 0)
override fun IntrinsicMeasureScope.maxIntrinsicWidth(
measurable: IntrinsicMeasurable,
@@ -1103,7 +1107,7 @@
) =
measurable
.maxIntrinsicWidth(height)
- .coerceAtLeast(if (minWidth != Dp.Unspecified) minWidth.roundToPx() else 0)
+ .fastCoerceAtLeast(if (minWidth.isSpecified) minWidth.roundToPx() else 0)
override fun IntrinsicMeasureScope.minIntrinsicHeight(
measurable: IntrinsicMeasurable,
@@ -1111,7 +1115,7 @@
) =
measurable
.minIntrinsicHeight(width)
- .coerceAtLeast(if (minHeight != Dp.Unspecified) minHeight.roundToPx() else 0)
+ .fastCoerceAtLeast(if (minHeight.isSpecified) minHeight.roundToPx() else 0)
override fun IntrinsicMeasureScope.maxIntrinsicHeight(
measurable: IntrinsicMeasurable,
@@ -1119,7 +1123,7 @@
) =
measurable
.maxIntrinsicHeight(width)
- .coerceAtLeast(if (minHeight != Dp.Unspecified) minHeight.roundToPx() else 0)
+ .fastCoerceAtLeast(if (minHeight.isSpecified) minHeight.roundToPx() else 0)
}
internal enum class Direction {
diff --git a/compose/foundation/foundation/build.gradle b/compose/foundation/foundation/build.gradle
index 0d84d31..91a0069 100644
--- a/compose/foundation/foundation/build.gradle
+++ b/compose/foundation/foundation/build.gradle
@@ -50,6 +50,7 @@
implementation(project(":compose:ui:ui-text"))
implementation(project(":compose:ui:ui-util"))
implementation(project(":compose:foundation:foundation-layout"))
+ implementation(project(":performance:performance-annotation"))
}
}
@@ -80,12 +81,16 @@
dependsOn(commonMain)
}
- jvmStubsMain {
+ nonAndroidStubsMain {
dependsOn(commonStubsMain)
}
+ jvmStubsMain {
+ dependsOn(nonAndroidStubsMain)
+ }
+
linuxx64StubsMain {
- dependsOn(commonStubsMain)
+ dependsOn(nonAndroidStubsMain)
}
androidInstrumentedTest {
diff --git a/compose/foundation/foundation/proguard-rules.pro b/compose/foundation/foundation/proguard-rules.pro
index 4039ea4..2d14261 100644
--- a/compose/foundation/foundation/proguard-rules.pro
+++ b/compose/foundation/foundation/proguard-rules.pro
@@ -20,3 +20,7 @@
# For methods returning Nothing
static java.lang.Void throw*Exception(...);
}
+
+-keepclassmembers class * {
+ @dalvik.annotation.optimization.NeverInline *;
+}
diff --git a/compose/foundation/foundation/src/commonMain/kotlin/androidx/compose/foundation/Scroll.kt b/compose/foundation/foundation/src/commonMain/kotlin/androidx/compose/foundation/Scroll.kt
index 7a034224..7c73fa8 100644
--- a/compose/foundation/foundation/src/commonMain/kotlin/androidx/compose/foundation/Scroll.kt
+++ b/compose/foundation/foundation/src/commonMain/kotlin/androidx/compose/foundation/Scroll.kt
@@ -443,44 +443,28 @@
measurable: IntrinsicMeasurable,
height: Int
): Int {
- return if (isVertical) {
- measurable.minIntrinsicWidth(Constraints.Infinity)
- } else {
- measurable.minIntrinsicWidth(height)
- }
+ return measurable.minIntrinsicWidth(if (isVertical) Constraints.Infinity else height)
}
override fun IntrinsicMeasureScope.minIntrinsicHeight(
measurable: IntrinsicMeasurable,
width: Int
): Int {
- return if (isVertical) {
- measurable.minIntrinsicHeight(width)
- } else {
- measurable.minIntrinsicHeight(Constraints.Infinity)
- }
+ return measurable.minIntrinsicHeight(if (isVertical) width else Constraints.Infinity)
}
override fun IntrinsicMeasureScope.maxIntrinsicWidth(
measurable: IntrinsicMeasurable,
height: Int
): Int {
- return if (isVertical) {
- measurable.maxIntrinsicWidth(Constraints.Infinity)
- } else {
- measurable.maxIntrinsicWidth(height)
- }
+ return measurable.maxIntrinsicWidth(if (isVertical) Constraints.Infinity else height)
}
override fun IntrinsicMeasureScope.maxIntrinsicHeight(
measurable: IntrinsicMeasurable,
width: Int
): Int {
- return if (isVertical) {
- measurable.maxIntrinsicHeight(width)
- } else {
- measurable.maxIntrinsicHeight(Constraints.Infinity)
- }
+ return measurable.maxIntrinsicHeight(if (isVertical) width else Constraints.Infinity)
}
override fun SemanticsPropertyReceiver.applySemantics() {
diff --git a/compose/foundation/foundation/src/commonMain/kotlin/androidx/compose/foundation/gestures/AnchoredDraggable.kt b/compose/foundation/foundation/src/commonMain/kotlin/androidx/compose/foundation/gestures/AnchoredDraggable.kt
index dd3ef0b..db0c790 100644
--- a/compose/foundation/foundation/src/commonMain/kotlin/androidx/compose/foundation/gestures/AnchoredDraggable.kt
+++ b/compose/foundation/foundation/src/commonMain/kotlin/androidx/compose/foundation/gestures/AnchoredDraggable.kt
@@ -62,6 +62,7 @@
import androidx.compose.ui.unit.LayoutDirection
import androidx.compose.ui.unit.Velocity
import androidx.compose.ui.unit.dp
+import dalvik.annotation.optimization.NeverInline
import kotlin.math.abs
import kotlin.math.max
import kotlin.math.min
@@ -632,6 +633,7 @@
positions[keys.size - 1] = position
}
+ @NeverInline
internal fun buildPositions(): FloatArray {
// We might have expanded more than we actually need, so trim the array
return positions.copyOfRange(
@@ -643,6 +645,7 @@
internal fun buildKeys(): List<T> = keys
+ @NeverInline
private fun expandPositions() {
positions = positions.copyOf(keys.size + 2)
}
@@ -1650,7 +1653,7 @@
}
}
-internal expect inline fun assertOnJvm(statement: Boolean, message: () -> String): Unit
+internal expect inline fun assertOnJvm(statement: Boolean, message: () -> String)
internal val AnchoredDraggableMinFlingVelocity = 125.dp
diff --git a/compose/foundation/foundation/src/commonMain/kotlin/androidx/compose/foundation/internal/InlineClassHelper.kt b/compose/foundation/foundation/src/commonMain/kotlin/androidx/compose/foundation/internal/InlineClassHelper.kt
index 4af862a..686d885 100644
--- a/compose/foundation/foundation/src/commonMain/kotlin/androidx/compose/foundation/internal/InlineClassHelper.kt
+++ b/compose/foundation/foundation/src/commonMain/kotlin/androidx/compose/foundation/internal/InlineClassHelper.kt
@@ -53,7 +53,7 @@
}
}
-@Suppress("NOTHING_TO_INLINE", "BanInlineOptIn")
+@Suppress("NOTHING_TO_INLINE", "BanInlineOptIn", "KotlinRedundantDiagnosticSuppress")
@OptIn(ExperimentalContracts::class)
internal inline fun checkPrecondition(value: Boolean) {
contract { returns() implies value }
diff --git a/compose/foundation/foundation/src/commonMain/kotlin/androidx/compose/foundation/text/input/internal/OffsetMappingCalculator.kt b/compose/foundation/foundation/src/commonMain/kotlin/androidx/compose/foundation/text/input/internal/OffsetMappingCalculator.kt
index b6fb607..eaa2856 100644
--- a/compose/foundation/foundation/src/commonMain/kotlin/androidx/compose/foundation/text/input/internal/OffsetMappingCalculator.kt
+++ b/compose/foundation/foundation/src/commonMain/kotlin/androidx/compose/foundation/text/input/internal/OffsetMappingCalculator.kt
@@ -370,18 +370,18 @@
*/
@kotlin.jvm.JvmInline
private value class OpArray private constructor(private val values: IntArray) {
- constructor(size: Int) : this(IntArray(size * ElementSize))
+ constructor(size: Int) : this(IntArray(size * OpArrayElementSize))
val size: Int
- get() = values.size / ElementSize
+ get() = values.size / OpArrayElementSize
fun set(index: Int, offset: Int, srcLen: Int, destLen: Int) {
- values[index * ElementSize] = offset
- values[index * ElementSize + 1] = srcLen
- values[index * ElementSize + 2] = destLen
+ values[index * OpArrayElementSize] = offset
+ values[index * OpArrayElementSize + 1] = srcLen
+ values[index * OpArrayElementSize + 2] = destLen
}
- fun copyOf(newSize: Int) = OpArray(values.copyOf(newSize * ElementSize))
+ fun copyOf(newSize: Int) = OpArray(values.copyOf(newSize * OpArrayElementSize))
/**
* Loops through the array between 0 and [max] (exclusive). If [reversed] is false (the
@@ -399,22 +399,20 @@
// duplication here keeps the more complicated logic at the callsite more readable.
if (reversed) {
for (i in max - 1 downTo 0) {
- val offset = values[i * ElementSize]
- val srcLen = values[i * ElementSize + 1]
- val destLen = values[i * ElementSize + 2]
+ val offset = values[i * OpArrayElementSize]
+ val srcLen = values[i * OpArrayElementSize + 1]
+ val destLen = values[i * OpArrayElementSize + 2]
block(offset, srcLen, destLen)
}
} else {
for (i in 0 until max) {
- val offset = values[i * ElementSize]
- val srcLen = values[i * ElementSize + 1]
- val destLen = values[i * ElementSize + 2]
+ val offset = values[i * OpArrayElementSize]
+ val srcLen = values[i * OpArrayElementSize + 1]
+ val destLen = values[i * OpArrayElementSize + 2]
block(offset, srcLen, destLen)
}
}
}
-
- private companion object {
- const val ElementSize = 3
- }
}
+
+private const val OpArrayElementSize = 3
diff --git a/compose/lint/common/src/main/java/androidx/compose/lint/Names.kt b/compose/lint/common/src/main/java/androidx/compose/lint/Names.kt
index 81b56b6..c6894c5 100644
--- a/compose/lint/common/src/main/java/androidx/compose/lint/Names.kt
+++ b/compose/lint/common/src/main/java/androidx/compose/lint/Names.kt
@@ -68,6 +68,11 @@
val ParentDataModifier = Name(PackageName, "ParentDataModifier")
}
+ object Platform {
+ val PackageName = Package(Ui.PackageName, "platform")
+ val LocalConfiguration = Name(PackageName, "LocalConfiguration")
+ }
+
object Pointer {
val PackageName = Package(Ui.PackageName, "input.pointer")
val PointerInputScope = Name(PackageName, "PointerInputScope")
diff --git a/compose/material/material-navigation/build.gradle b/compose/material/material-navigation/build.gradle
index 7f8be4a..a80dfb7 100644
--- a/compose/material/material-navigation/build.gradle
+++ b/compose/material/material-navigation/build.gradle
@@ -34,6 +34,7 @@
androidTestImplementation(project(":compose:test-utils"))
androidTestImplementation("androidx.navigation:navigation-testing:2.7.7")
androidTestImplementation(project(":compose:ui:ui-test-junit4"))
+ androidTestImplementation(project(":compose:ui:ui-test-manifest"))
androidTestImplementation(libs.testRunner)
androidTestImplementation(libs.junit)
androidTestImplementation(libs.truth)
diff --git a/compose/material/material/src/commonMain/kotlin/androidx/compose/material/SnackbarHost.kt b/compose/material/material/src/commonMain/kotlin/androidx/compose/material/SnackbarHost.kt
index 36afe64..864ea49 100644
--- a/compose/material/material/src/commonMain/kotlin/androidx/compose/material/SnackbarHost.kt
+++ b/compose/material/material/src/commonMain/kotlin/androidx/compose/material/SnackbarHost.kt
@@ -298,7 +298,9 @@
alpha = opacity.value
)
.semantics {
- liveRegion = LiveRegionMode.Polite
+ if (isVisible) {
+ liveRegion = LiveRegionMode.Polite
+ }
paneTitle = a11yPaneTitle
dismiss {
key.dismiss()
diff --git a/compose/material3/material3/src/androidInstrumentedTest/kotlin/androidx/compose/material3/BadgeTest.kt b/compose/material3/material3/src/androidInstrumentedTest/kotlin/androidx/compose/material3/BadgeTest.kt
index b8c527d..43717c5 100644
--- a/compose/material3/material3/src/androidInstrumentedTest/kotlin/androidx/compose/material3/BadgeTest.kt
+++ b/compose/material3/material3/src/androidInstrumentedTest/kotlin/androidx/compose/material3/BadgeTest.kt
@@ -133,6 +133,7 @@
}
@Test
+ @SdkSuppress(maxSdkVersion = 34) // b/384973010: Failing on SDK 35
fun badgeBox_shortContent_position() {
rule.setMaterialContent(lightColorScheme()) {
BadgedBox(badge = { Badge { Text("8") } }) {
diff --git a/compose/material3/material3/src/commonMain/kotlin/androidx/compose/material3/SnackbarHost.kt b/compose/material3/material3/src/commonMain/kotlin/androidx/compose/material3/SnackbarHost.kt
index 38b6762..dd8b7ad 100644
--- a/compose/material3/material3/src/commonMain/kotlin/androidx/compose/material3/SnackbarHost.kt
+++ b/compose/material3/material3/src/commonMain/kotlin/androidx/compose/material3/SnackbarHost.kt
@@ -363,7 +363,9 @@
alpha = opacity.value
)
.semantics {
- liveRegion = LiveRegionMode.Polite
+ if (isVisible) {
+ liveRegion = LiveRegionMode.Polite
+ }
dismiss {
key.dismiss()
true
diff --git a/compose/runtime/runtime/build.gradle b/compose/runtime/runtime/build.gradle
index bbff188..1406001 100644
--- a/compose/runtime/runtime/build.gradle
+++ b/compose/runtime/runtime/build.gradle
@@ -46,6 +46,7 @@
implementation(libs.kotlinStdlibCommon)
implementation(libs.kotlinCoroutinesCore)
implementation(project(":collection:collection"))
+ implementation(project(":performance:performance-annotation"))
}
}
diff --git a/compose/runtime/runtime/proguard-rules.pro b/compose/runtime/runtime/proguard-rules.pro
index 8e1c21e..400440d 100644
--- a/compose/runtime/runtime/proguard-rules.pro
+++ b/compose/runtime/runtime/proguard-rules.pro
@@ -31,3 +31,7 @@
static void compose*RuntimeError(...);
static java.lang.Void compose*RuntimeError(...);
}
+
+-keepclassmembers class * {
+ @dalvik.annotation.optimization.NeverInline *;
+}
diff --git a/compose/runtime/runtime/src/androidMain/kotlin/androidx/compose/runtime/collection/ArrayUtils.android.kt b/compose/runtime/runtime/src/androidMain/kotlin/androidx/compose/runtime/collection/ArrayUtils.android.kt
new file mode 100644
index 0000000..c487bdc
--- /dev/null
+++ b/compose/runtime/runtime/src/androidMain/kotlin/androidx/compose/runtime/collection/ArrayUtils.android.kt
@@ -0,0 +1,29 @@
+/*
+ * Copyright 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@file:Suppress("NOTHING_TO_INLINE", "KotlinRedundantDiagnosticSuppress")
+
+package androidx.compose.runtime.collection
+
+internal actual inline fun <T> Array<out T>.fastCopyInto(
+ destination: Array<T>,
+ destinationOffset: Int,
+ startIndex: Int,
+ endIndex: Int
+): Array<T> {
+ System.arraycopy(this, startIndex, destination, destinationOffset, endIndex - startIndex)
+ return destination
+}
diff --git a/compose/runtime/runtime/src/commonMain/kotlin/androidx/compose/runtime/SlotTable.kt b/compose/runtime/runtime/src/commonMain/kotlin/androidx/compose/runtime/SlotTable.kt
index a295937..afd4db85 100644
--- a/compose/runtime/runtime/src/commonMain/kotlin/androidx/compose/runtime/SlotTable.kt
+++ b/compose/runtime/runtime/src/commonMain/kotlin/androidx/compose/runtime/SlotTable.kt
@@ -23,6 +23,7 @@
import androidx.collection.MutableIntSet
import androidx.collection.MutableObjectList
import androidx.collection.mutableIntListOf
+import androidx.compose.runtime.collection.fastCopyInto
import androidx.compose.runtime.platform.makeSynchronizedObject
import androidx.compose.runtime.platform.synchronized
import androidx.compose.runtime.snapshots.fastAny
@@ -2122,7 +2123,7 @@
// 4) copy the slots to their new location
if (moveDataLen > 0) {
val slots = slots
- slots.copyInto(
+ slots.fastCopyInto(
destination = slots,
destinationOffset = destinationSlot,
startIndex = dataIndexToDataAddress(dataStart + moveDataLen),
@@ -2206,7 +2207,7 @@
)
val slots = toWriter.slots
val currentSlot = toWriter.currentSlot
- fromWriter.slots.copyInto(
+ fromWriter.slots.fastCopyInto(
destination = slots,
destinationOffset = currentSlot,
startIndex = sourceSlotsStart,
@@ -2676,7 +2677,7 @@
val slots = slots
if (index < gapStart) {
// move the gap down to index by shifting the data up.
- slots.copyInto(
+ slots.fastCopyInto(
destination = slots,
destinationOffset = index + gapLen,
startIndex = index,
@@ -2684,7 +2685,7 @@
)
} else {
// Shift the data down, leaving the gap at index
- slots.copyInto(
+ slots.fastCopyInto(
destination = slots,
destinationOffset = gapStart,
startIndex = gapStart + gapLen,
@@ -2830,13 +2831,13 @@
val newGapEndAddress = gapStart + newGapLen
// Copy the old arrays into the new arrays
- slots.copyInto(
+ slots.fastCopyInto(
destination = newData,
destinationOffset = 0,
startIndex = 0,
endIndex = gapStart
)
- slots.copyInto(
+ slots.fastCopyInto(
destination = newData,
destinationOffset = newGapEndAddress,
startIndex = oldGapEndAddress,
diff --git a/compose/runtime/runtime/src/commonMain/kotlin/androidx/compose/runtime/Stack.kt b/compose/runtime/runtime/src/commonMain/kotlin/androidx/compose/runtime/Stack.kt
index 03989dd..c2e25cd 100644
--- a/compose/runtime/runtime/src/commonMain/kotlin/androidx/compose/runtime/Stack.kt
+++ b/compose/runtime/runtime/src/commonMain/kotlin/androidx/compose/runtime/Stack.kt
@@ -14,9 +14,13 @@
* limitations under the License.
*/
+@file:Suppress("NOTHING_TO_INLINE", "KotlinRedundantDiagnosticSuppress")
+
package androidx.compose.runtime
+import kotlin.jvm.JvmField
import kotlin.jvm.JvmInline
+import kotlin.math.min
@JvmInline
internal value class Stack<T>(private val backing: ArrayList<T> = ArrayList()) {
@@ -42,22 +46,33 @@
}
internal class IntStack {
- private var slots = IntArray(10)
- private var tos = 0
+ @JvmField internal var slots = IntArray(10)
+ @JvmField internal var tos = 0
- val size: Int
+ inline val size: Int
get() = tos
+ @dalvik.annotation.optimization.NeverInline
+ private fun resize(): IntArray {
+ val copy = slots.copyOf(slots.size * 2)
+ slots = copy
+ return copy
+ }
+
fun push(value: Int) {
+ var slots = slots
if (tos >= slots.size) {
- slots = slots.copyOf(slots.size * 2)
+ slots = resize()
}
slots[tos++] = value
}
fun pop(): Int = slots[--tos]
- fun peekOr(default: Int): Int = if (tos > 0) peek() else default
+ fun peekOr(default: Int): Int {
+ val index = tos - 1
+ return if (index >= 0) slots[index] else default
+ }
fun peek() = slots[tos - 1]
@@ -65,16 +80,20 @@
fun peek(index: Int) = slots[index]
- fun isEmpty() = tos == 0
+ inline fun isEmpty() = tos == 0
- fun isNotEmpty() = tos != 0
+ inline fun isNotEmpty() = tos != 0
fun clear() {
tos = 0
}
fun indexOf(value: Int): Int {
- for (i in 0 until tos) if (slots[i] == value) return i
+ val slots = slots
+ val end = min(slots.size, tos)
+ for (i in 0 until end) {
+ if (slots[i] == value) return i
+ }
return -1
}
}
diff --git a/compose/runtime/runtime/src/commonMain/kotlin/androidx/compose/runtime/changelist/Operations.kt b/compose/runtime/runtime/src/commonMain/kotlin/androidx/compose/runtime/changelist/Operations.kt
index f250bc8..6a1339b 100644
--- a/compose/runtime/runtime/src/commonMain/kotlin/androidx/compose/runtime/changelist/Operations.kt
+++ b/compose/runtime/runtime/src/commonMain/kotlin/androidx/compose/runtime/changelist/Operations.kt
@@ -24,8 +24,10 @@
import androidx.compose.runtime.RememberManager
import androidx.compose.runtime.SlotWriter
import androidx.compose.runtime.changelist.Operation.ObjectParameter
+import androidx.compose.runtime.collection.fastCopyInto
import androidx.compose.runtime.debugRuntimeCheck
import androidx.compose.runtime.requirePrecondition
+import dalvik.annotation.optimization.NeverInline
import kotlin.contracts.ExperimentalContracts
import kotlin.contracts.InvocationKind.EXACTLY_ONCE
import kotlin.contracts.contract
@@ -133,11 +135,12 @@
return (currentSize + resizeAmount).coerceAtLeast(requiredSize)
}
+ @NeverInline
private fun resizeOpCodes() {
val resizeAmount = opCodesSize.coerceAtMost(OperationsMaxResizeAmount)
@Suppress("UNCHECKED_CAST")
val newOpCodes = arrayOfNulls<Operation>(opCodesSize + resizeAmount) as Array<Operation>
- opCodes = opCodes.copyInto(newOpCodes, 0, 0, opCodesSize)
+ opCodes = opCodes.fastCopyInto(newOpCodes, 0, 0, opCodesSize)
}
private inline fun ensureIntArgsSizeAtLeast(requiredSize: Int) {
@@ -147,6 +150,7 @@
}
}
+ @NeverInline
private fun resizeIntArgs(currentSize: Int, requiredSize: Int) {
val newIntArgs = IntArray(determineNewSize(currentSize, requiredSize))
intArgs.copyInto(newIntArgs, 0, 0, currentSize)
@@ -160,9 +164,10 @@
}
}
+ @NeverInline
private fun resizeObjectArgs(currentSize: Int, requiredSize: Int) {
val newObjectArgs = arrayOfNulls<Any>(determineNewSize(currentSize, requiredSize))
- objectArgs.copyInto(newObjectArgs, 0, 0, currentSize)
+ objectArgs.fastCopyInto(newObjectArgs, 0, 0, currentSize)
objectArgs = newObjectArgs
}
@@ -291,7 +296,7 @@
other.pushOp(op)
// Move the objects then null out our contents
- objectArgs.copyInto(
+ objectArgs.fastCopyInto(
destination = other.objectArgs,
destinationOffset = other.objectArgsSize - op.objects,
startIndex = objectArgsSize - op.objects,
diff --git a/compose/runtime/runtime/src/commonMain/kotlin/androidx/compose/runtime/collection/ArrayUtils.kt b/compose/runtime/runtime/src/commonMain/kotlin/androidx/compose/runtime/collection/ArrayUtils.kt
new file mode 100644
index 0000000..03c2546
--- /dev/null
+++ b/compose/runtime/runtime/src/commonMain/kotlin/androidx/compose/runtime/collection/ArrayUtils.kt
@@ -0,0 +1,28 @@
+/*
+ * Copyright 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.compose.runtime.collection
+
+/**
+ * Equivalent of Array.copyInto() with an implementation designed to avoid unnecessary null checks
+ * and exception throws on Android after inlining.
+ */
+internal expect fun <T> Array<out T>.fastCopyInto(
+ destination: Array<T>,
+ destinationOffset: Int,
+ startIndex: Int,
+ endIndex: Int
+): Array<T>
diff --git a/compose/runtime/runtime/src/commonMain/kotlin/androidx/compose/runtime/collection/MutableVector.kt b/compose/runtime/runtime/src/commonMain/kotlin/androidx/compose/runtime/collection/MutableVector.kt
index 1315b32..8144a7b 100644
--- a/compose/runtime/runtime/src/commonMain/kotlin/androidx/compose/runtime/collection/MutableVector.kt
+++ b/compose/runtime/runtime/src/commonMain/kotlin/androidx/compose/runtime/collection/MutableVector.kt
@@ -18,6 +18,7 @@
package androidx.compose.runtime.collection
+import dalvik.annotation.optimization.NeverInline
import kotlin.contracts.ExperimentalContracts
import kotlin.contracts.contract
import kotlin.jvm.JvmField
@@ -66,7 +67,7 @@
ensureCapacity(size + 1)
val content = content
if (index != size) {
- content.copyInto(
+ content.fastCopyInto(
destination = content,
destinationOffset = index + 1,
startIndex = index,
@@ -83,12 +84,13 @@
*/
fun addAll(index: Int, elements: List<T>): Boolean {
if (elements.isEmpty()) return false
- ensureCapacity(size + elements.size)
+ val elementsSize = elements.size
+ ensureCapacity(size + elementsSize)
val content = content
if (index != size) {
- content.copyInto(
+ content.fastCopyInto(
destination = content,
- destinationOffset = index + elements.size,
+ destinationOffset = index + elementsSize,
startIndex = index,
endIndex = size
)
@@ -96,7 +98,7 @@
for (i in elements.indices) {
content[index + i] = elements[i]
}
- size += elements.size
+ size += elementsSize
return true
}
@@ -105,24 +107,25 @@
* that are in the way.
*/
fun addAll(index: Int, elements: MutableVector<T>): Boolean {
- if (elements.isEmpty()) return false
- ensureCapacity(size + elements.size)
+ val elementsSize = elements.size
+ if (elementsSize == 0) return false
+ ensureCapacity(size + elementsSize)
val content = content
if (index != size) {
- content.copyInto(
+ content.fastCopyInto(
destination = content,
- destinationOffset = index + elements.size,
+ destinationOffset = index + elementsSize,
startIndex = index,
endIndex = size
)
}
- elements.content.copyInto(
+ elements.content.fastCopyInto(
destination = content,
destinationOffset = index,
startIndex = 0,
- endIndex = elements.size
+ endIndex = elementsSize
)
- size += elements.size
+ size += elementsSize
return true
}
@@ -147,12 +150,13 @@
* [MutableVector] was changed.
*/
fun addAll(@Suppress("ArrayReturn") elements: Array<T>): Boolean {
- if (elements.isEmpty()) {
+ val elementsSize = elements.size
+ if (elementsSize == 0) {
return false
}
- ensureCapacity(size + elements.size)
- elements.copyInto(destination = content, destinationOffset = size)
- size += elements.size
+ ensureCapacity(size + elementsSize)
+ elements.fastCopyInto(destination = content, destinationOffset = size, 0, elementsSize)
+ size += elementsSize
return true
}
@@ -162,18 +166,19 @@
*/
fun addAll(index: Int, elements: Collection<T>): Boolean {
if (elements.isEmpty()) return false
- ensureCapacity(size + elements.size)
+ val elementsSize = elements.size
+ ensureCapacity(size + elementsSize)
val content = content
if (index != size) {
- content.copyInto(
+ content.fastCopyInto(
destination = content,
- destinationOffset = index + elements.size,
+ destinationOffset = index + elementsSize,
startIndex = index,
endIndex = size
)
}
elements.forEachIndexed { i, item -> content[index + i] = item }
- size += elements.size
+ size += elementsSize
return true
}
@@ -287,13 +292,14 @@
}
}
+ @NeverInline
@PublishedApi
internal fun resizeStorage(capacity: Int) {
val oldContent = content
val oldSize = oldContent.size
val newSize = max(capacity, oldSize * 2)
val newContent = arrayOfNulls<Any?>(newSize) as Array<T?>
- oldContent.copyInto(newContent, 0, 0, oldSize)
+ oldContent.fastCopyInto(newContent, 0, 0, oldSize)
content = newContent
}
@@ -694,7 +700,7 @@
val content = content
val item = content[index] as T
if (index != lastIndex) {
- content.copyInto(
+ content.fastCopyInto(
destination = content,
destinationOffset = index,
startIndex = index + 1,
@@ -710,7 +716,7 @@
fun removeRange(start: Int, end: Int) {
if (end > start) {
if (end < size) {
- content.copyInto(
+ content.fastCopyInto(
destination = content,
destinationOffset = start,
startIndex = end,
diff --git a/compose/runtime/runtime/src/commonMain/kotlin/androidx/compose/runtime/snapshots/SnapshotWeakSet.kt b/compose/runtime/runtime/src/commonMain/kotlin/androidx/compose/runtime/snapshots/SnapshotWeakSet.kt
index 66075f0a..e70d6fd 100644
--- a/compose/runtime/runtime/src/commonMain/kotlin/androidx/compose/runtime/snapshots/SnapshotWeakSet.kt
+++ b/compose/runtime/runtime/src/commonMain/kotlin/androidx/compose/runtime/snapshots/SnapshotWeakSet.kt
@@ -17,6 +17,7 @@
package androidx.compose.runtime.snapshots
import androidx.compose.runtime.TestOnly
+import androidx.compose.runtime.collection.fastCopyInto
import androidx.compose.runtime.internal.WeakReference
import androidx.compose.runtime.internal.identityHashCode
@@ -70,13 +71,18 @@
val newCapacity = capacity * 2
val newValues = arrayOfNulls<WeakReference<T>?>(newCapacity)
val newHashes = IntArray(newCapacity)
- values.copyInto(
+ values.fastCopyInto(
destination = newValues,
destinationOffset = insertIndex + 1,
startIndex = insertIndex,
endIndex = size
)
- values.copyInto(destination = newValues, endIndex = insertIndex)
+ values.fastCopyInto(
+ destination = newValues,
+ destinationOffset = 0,
+ startIndex = 0,
+ endIndex = insertIndex
+ )
hashes.copyInto(
destination = newHashes,
destinationOffset = insertIndex + 1,
@@ -87,7 +93,7 @@
values = newValues
hashes = newHashes
} else {
- values.copyInto(
+ values.fastCopyInto(
destination = values,
destinationOffset = insertIndex + 1,
startIndex = insertIndex,
diff --git a/compose/runtime/runtime/src/nonAndroidMain/kotlin/androidx/compose/runtime/collection/ArrayUtils.nonAndroid.kt b/compose/runtime/runtime/src/nonAndroidMain/kotlin/androidx/compose/runtime/collection/ArrayUtils.nonAndroid.kt
new file mode 100644
index 0000000..2e2c834
--- /dev/null
+++ b/compose/runtime/runtime/src/nonAndroidMain/kotlin/androidx/compose/runtime/collection/ArrayUtils.nonAndroid.kt
@@ -0,0 +1,26 @@
+/*
+ * Copyright 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@file:Suppress("NOTHING_TO_INLINE", "KotlinRedundantDiagnosticSuppress")
+
+package androidx.compose.runtime.collection
+
+internal actual inline fun <T> Array<out T>.fastCopyInto(
+ destination: Array<T>,
+ destinationOffset: Int,
+ startIndex: Int,
+ endIndex: Int
+): Array<T> = this.copyInto(destination, destinationOffset, startIndex, endIndex)
diff --git a/compose/ui/ui-graphics/lint-baseline.xml b/compose/ui/ui-graphics/lint-baseline.xml
index 3255d39..862a7fe 100644
--- a/compose/ui/ui-graphics/lint-baseline.xml
+++ b/compose/ui/ui-graphics/lint-baseline.xml
@@ -1,13 +1,13 @@
<?xml version="1.0" encoding="UTF-8"?>
-<issues format="6" by="lint 8.7.0-alpha02" type="baseline" client="gradle" dependencies="false" name="AGP (8.7.0-alpha02)" variant="all" version="8.7.0-alpha02">
+<issues format="6" by="lint 8.9.0-alpha06" type="baseline" client="gradle" dependencies="false" name="AGP (8.9.0-alpha06)" variant="all" version="8.9.0-alpha06">
<issue
id="NewApi"
- message="This Kotlin extension function will be hidden by `java.util.SequencedCollection` starting in API 35"
- errorLine1=" val node = s.removeLastKt()"
- errorLine2=" ~~~~~~~~~~~~~~~~">
+ message="Call requires API level 23 (current min is 21): `android.view.View#setForeground`"
+ errorLine1=" foreground = GraphicsContextHostDrawable(graphicsContext, block)"
+ errorLine2=" ~">
<location
- file="src/commonMain/kotlin/androidx/compose/ui/graphics/IntervalTree.kt"/>
+ file="src/androidInstrumentedTest/kotlin/androidx/compose/ui/graphics/layer/AndroidGraphicsLayerTest.kt"/>
</issue>
<issue
diff --git a/compose/ui/ui-graphics/src/commonMain/kotlin/androidx/compose/ui/graphics/IntervalTree.kt b/compose/ui/ui-graphics/src/commonMain/kotlin/androidx/compose/ui/graphics/IntervalTree.kt
index 1d3b503..8a2ff33 100644
--- a/compose/ui/ui-graphics/src/commonMain/kotlin/androidx/compose/ui/graphics/IntervalTree.kt
+++ b/compose/ui/ui-graphics/src/commonMain/kotlin/androidx/compose/ui/graphics/IntervalTree.kt
@@ -82,8 +82,7 @@
// structure beyond what can be found in various descriptions of binary search
// trees and red/black trees
- @JvmField
- internal val terminator = Node(Float.MAX_VALUE, Float.MIN_VALUE, null, TreeColor.Black)
+ @JvmField internal val terminator = Node(Float.MAX_VALUE, Float.MIN_VALUE, null, TreeColorBlack)
@JvmField internal var root = terminator
@JvmField internal val stack = ArrayList<Node>()
@@ -203,7 +202,7 @@
* @param data Data to associate with the interval
*/
fun addInterval(start: Float, end: Float, data: T?) {
- val node = Node(start, end, data, TreeColor.Red)
+ val node = Node(start, end, data, TreeColorRed)
// Update the tree without doing any balancing
var current = root
@@ -239,44 +238,44 @@
private fun rebalance(target: Node) {
var node = target
- while (node !== root && node.parent.color == TreeColor.Red) {
+ while (node !== root && node.parent.color == TreeColorRed) {
val ancestor = node.parent.parent
if (node.parent === ancestor.left) {
val right = ancestor.right
- if (right.color == TreeColor.Red) {
- right.color = TreeColor.Black
- node.parent.color = TreeColor.Black
- ancestor.color = TreeColor.Red
+ if (right.color == TreeColorRed) {
+ right.color = TreeColorBlack
+ node.parent.color = TreeColorBlack
+ ancestor.color = TreeColorRed
node = ancestor
} else {
if (node === node.parent.right) {
node = node.parent
rotateLeft(node)
}
- node.parent.color = TreeColor.Black
- ancestor.color = TreeColor.Red
+ node.parent.color = TreeColorBlack
+ ancestor.color = TreeColorRed
rotateRight(ancestor)
}
} else {
val left = ancestor.left
- if (left.color == TreeColor.Red) {
- left.color = TreeColor.Black
- node.parent.color = TreeColor.Black
- ancestor.color = TreeColor.Red
+ if (left.color == TreeColorRed) {
+ left.color = TreeColorBlack
+ node.parent.color = TreeColorBlack
+ ancestor.color = TreeColorRed
node = ancestor
} else {
if (node === node.parent.left) {
node = node.parent
rotateRight(node)
}
- node.parent.color = TreeColor.Black
- ancestor.color = TreeColor.Red
+ node.parent.color = TreeColorBlack
+ ancestor.color = TreeColorRed
rotateLeft(ancestor)
}
}
}
- root.color = TreeColor.Black
+ root.color = TreeColorBlack
}
private fun rotateLeft(node: Node) {
@@ -340,11 +339,6 @@
}
}
- internal enum class TreeColor {
- Red,
- Black
- }
-
internal inner class Node(start: Float, end: Float, data: T?, var color: TreeColor) :
Interval<T>(start, end, data) {
var min: Float = start
@@ -378,3 +372,8 @@
}
}
}
+
+private typealias TreeColor = Int
+
+private const val TreeColorRed = 0
+private const val TreeColorBlack = 1
diff --git a/compose/ui/ui-graphics/src/commonMain/kotlin/androidx/compose/ui/graphics/PathGeometry.kt b/compose/ui/ui-graphics/src/commonMain/kotlin/androidx/compose/ui/graphics/PathGeometry.kt
index 53b0d54..4c96e1e 100644
--- a/compose/ui/ui-graphics/src/commonMain/kotlin/androidx/compose/ui/graphics/PathGeometry.kt
+++ b/compose/ui/ui-graphics/src/commonMain/kotlin/androidx/compose/ui/graphics/PathGeometry.kt
@@ -58,7 +58,7 @@
// segments.
var type = iterator.next(points)
while (type != PathSegment.Type.Done) {
- @Suppress("KotlinConstantConditions")
+ @Suppress("KotlinConstantConditions", "RedundantSuppression")
when (type) {
PathSegment.Type.Move -> {
if (!first) {
@@ -175,7 +175,7 @@
var type = iterator.next(points)
while (type != PathSegment.Type.Done) {
- @Suppress("KotlinConstantConditions")
+ @Suppress("KotlinConstantConditions", "RedundantSuppression")
when (type) {
PathSegment.Type.Move -> {
if (!first && !isEmpty) {
diff --git a/compose/ui/ui-graphics/src/commonMain/kotlin/androidx/compose/ui/graphics/colorspace/ColorSpace.kt b/compose/ui/ui-graphics/src/commonMain/kotlin/androidx/compose/ui/graphics/colorspace/ColorSpace.kt
index 3905cff..ec0cc69 100644
--- a/compose/ui/ui-graphics/src/commonMain/kotlin/androidx/compose/ui/graphics/colorspace/ColorSpace.kt
+++ b/compose/ui/ui-graphics/src/commonMain/kotlin/androidx/compose/ui/graphics/colorspace/ColorSpace.kt
@@ -633,7 +633,7 @@
* @param r2: The third element of the vector
* @return The first element of the resulting multiplication.
*/
-@Suppress("NOTHING_TO_INLINE")
+@Suppress("NOTHING_TO_INLINE", "KotlinRedundantDiagnosticSuppress")
internal inline fun mul3x3Float3_0(lhs: FloatArray, r0: Float, r1: Float, r2: Float): Float {
return lhs[0] * r0 + lhs[3] * r1 + lhs[6] * r2
}
@@ -648,7 +648,7 @@
* @param r2: The third element of the vector
* @return The second element of the resulting multiplication.
*/
-@Suppress("NOTHING_TO_INLINE")
+@Suppress("NOTHING_TO_INLINE", "KotlinRedundantDiagnosticSuppress")
internal inline fun mul3x3Float3_1(lhs: FloatArray, r0: Float, r1: Float, r2: Float): Float {
return lhs[1] * r0 + lhs[4] * r1 + lhs[7] * r2
}
@@ -663,7 +663,7 @@
* @param r2: The third element of the vector
* @return The third element of the resulting multiplication.
*/
-@Suppress("NOTHING_TO_INLINE")
+@Suppress("NOTHING_TO_INLINE", "KotlinRedundantDiagnosticSuppress")
internal inline fun mul3x3Float3_2(lhs: FloatArray, r0: Float, r1: Float, r2: Float): Float {
return lhs[2] * r0 + lhs[5] * r1 + lhs[8] * r2
}
diff --git a/compose/ui/ui-graphics/src/commonMain/kotlin/androidx/compose/ui/graphics/colorspace/Connector.kt b/compose/ui/ui-graphics/src/commonMain/kotlin/androidx/compose/ui/graphics/colorspace/Connector.kt
index 7a47484..2a81bac 100644
--- a/compose/ui/ui-graphics/src/commonMain/kotlin/androidx/compose/ui/graphics/colorspace/Connector.kt
+++ b/compose/ui/ui-graphics/src/commonMain/kotlin/androidx/compose/ui/graphics/colorspace/Connector.kt
@@ -230,7 +230,7 @@
chromaticAdaptation(
Adaptation.Bradford.transform,
srcXYZ,
- Illuminant.D50Xyz.copyOf()
+ Illuminant.newD50Xyz()
)
transform = mul3x3(srcAdaptation, source.transform)
}
@@ -240,7 +240,7 @@
chromaticAdaptation(
Adaptation.Bradford.transform,
dstXYZ,
- Illuminant.D50Xyz.copyOf()
+ Illuminant.newD50Xyz()
)
inverseTransform = inverse3x3(mul3x3(dstAdaptation, destination.transform))
}
diff --git a/compose/ui/ui-graphics/src/commonMain/kotlin/androidx/compose/ui/graphics/colorspace/Illuminant.kt b/compose/ui/ui-graphics/src/commonMain/kotlin/androidx/compose/ui/graphics/colorspace/Illuminant.kt
index b3598c3..0bf3461 100644
--- a/compose/ui/ui-graphics/src/commonMain/kotlin/androidx/compose/ui/graphics/colorspace/Illuminant.kt
+++ b/compose/ui/ui-graphics/src/commonMain/kotlin/androidx/compose/ui/graphics/colorspace/Illuminant.kt
@@ -73,4 +73,6 @@
val E = WhitePoint(0.33333f, 0.33333f)
internal val D50Xyz = floatArrayOf(0.964212f, 1.0f, 0.825188f)
+
+ internal fun newD50Xyz() = floatArrayOf(0.964212f, 1.0f, 0.825188f)
}
diff --git a/compose/ui/ui-graphics/src/commonMain/kotlin/androidx/compose/ui/graphics/colorspace/Rgb.kt b/compose/ui/ui-graphics/src/commonMain/kotlin/androidx/compose/ui/graphics/colorspace/Rgb.kt
index 06f2891..e9d3032 100644
--- a/compose/ui/ui-graphics/src/commonMain/kotlin/androidx/compose/ui/graphics/colorspace/Rgb.kt
+++ b/compose/ui/ui-graphics/src/commonMain/kotlin/androidx/compose/ui/graphics/colorspace/Rgb.kt
@@ -14,7 +14,7 @@
* limitations under the License.
*/
-@file:Suppress("NOTHING_TO_INLINE")
+@file:Suppress("NOTHING_TO_INLINE", "KotlinRedundantDiagnosticSuppress")
package androidx.compose.ui.graphics.colorspace
@@ -853,10 +853,9 @@
var result = super.hashCode()
result = 31 * result + whitePoint.hashCode()
result = 31 * result + primaries.contentHashCode()
- result = 31 * result + (if (min != +0.0f) min.toBits() else 0)
- result = 31 * result + (if (max != +0.0f) max.toBits() else 0)
- result =
- (31 * result + if (transferParameters != null) transferParameters.hashCode() else 0)
+ result = 31 * result + (if (min != 0.0f) min.toBits() else 0)
+ result = 31 * result + (if (max != 0.0f) max.toBits() else 0)
+ result = (31 * result + (transferParameters?.hashCode() ?: 0))
if (transferParameters == null) {
result = 31 * result + oetfOrig.hashCode()
result = 31 * result + eotfOrig.hashCode()
diff --git a/compose/ui/ui-lint/src/main/java/androidx/compose/ui/lint/LocalContextConfigurationReadDetector.kt b/compose/ui/ui-lint/src/main/java/androidx/compose/ui/lint/LocalContextConfigurationReadDetector.kt
new file mode 100644
index 0000000..257cf98
--- /dev/null
+++ b/compose/ui/ui-lint/src/main/java/androidx/compose/ui/lint/LocalContextConfigurationReadDetector.kt
@@ -0,0 +1,180 @@
+/*
+ * Copyright 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.compose.ui.lint
+
+import androidx.compose.lint.Names.Ui.Platform.LocalConfiguration
+import androidx.compose.lint.Package
+import androidx.compose.lint.isInPackageName
+import com.android.tools.lint.client.api.UElementHandler
+import com.android.tools.lint.detector.api.Category
+import com.android.tools.lint.detector.api.Detector
+import com.android.tools.lint.detector.api.Implementation
+import com.android.tools.lint.detector.api.Issue
+import com.android.tools.lint.detector.api.JavaContext
+import com.android.tools.lint.detector.api.LintFix
+import com.android.tools.lint.detector.api.Scope
+import com.android.tools.lint.detector.api.Severity
+import com.android.tools.lint.detector.api.SourceCodeScanner
+import com.android.tools.lint.detector.api.UastLintUtils.Companion.tryResolveUDeclaration
+import com.intellij.psi.PsiMethod
+import java.util.EnumSet
+import org.jetbrains.uast.UElement
+import org.jetbrains.uast.UExpression
+import org.jetbrains.uast.UQualifiedReferenceExpression
+import org.jetbrains.uast.USimpleNameReferenceExpression
+import org.jetbrains.uast.UVariable
+import org.jetbrains.uast.matchesQualified
+import org.jetbrains.uast.skipParenthesizedExprDown
+import org.jetbrains.uast.tryResolve
+
+/**
+ * Detector that warns for calls to LocalContext.current.resources.configuration - changes to the
+ * configuration object will not cause this to recompose, so callers of this API will not be
+ * notified of the new configuration. LocalConfiguration.current should be used instead.
+ */
+class LocalContextConfigurationReadDetector : Detector(), SourceCodeScanner {
+ override fun getApplicableUastTypes() = listOf(UQualifiedReferenceExpression::class.java)
+
+ override fun createUastHandler(context: JavaContext): UElementHandler =
+ object : UElementHandler() {
+ override fun visitQualifiedReferenceExpression(node: UQualifiedReferenceExpression) {
+ // Fast path for whole string - note the logic below would catch this (and variants
+ // that use method calls such as getResources() instead), but we want a fast path
+ // so we can suggest a replacement.
+ if (node.matchesQualified(LocalContextCurrentResourcesConfiguration)) {
+ context.report(
+ LocalContextConfigurationRead,
+ node,
+ context.getNameLocation(node),
+ "Reading Configuration using $LocalContextCurrentResourcesConfiguration",
+ LintFix.create()
+ .replace()
+ .name("Replace with $LocalConfigurationCurrent")
+ .all()
+ .with(LocalConfigurationCurrent)
+ .imports(LocalConfiguration.javaFqn)
+ .autoFix()
+ .build()
+ )
+ return
+ }
+ // Simple logic to try and match a few specific cases (there are many cases that
+ // this won't warn for) where the chain is split up
+ // E.g. val context = LocalContext.current, val resources = context.resources,
+ // val configuration = resources.configuration
+ // A future improvement would be to catch receiver scope cases, such as
+ // `with(LocalContext.current.resources) { configuration... }`, but this is more
+ // complicated and error prone
+
+ // See if this is a resources.configuration call
+ val selector = node.selector.skipParenthesizedExprDown()
+ if (!selector.isCallToGetConfiguration()) return
+ // Try and find out where this resources came from.
+ val resources = node.receiver.skipParenthesizedExprDown()
+ val contextExpression: UExpression? =
+ when (resources) {
+ // Still part of a qualified expression, e.g. context.resources
+ is UQualifiedReferenceExpression -> {
+ if (!resources.isCallToGetResources()) return
+ // Return the receiver, e.g. `context` in the case of
+ // `context.resources`
+ resources.receiver.skipParenthesizedExprDown()
+ }
+ // Possible reference to a variable, e.g. val resources = context.resources,
+ // and this USimpleNameReferenceExpression is `resources`
+ is USimpleNameReferenceExpression -> {
+ // If it is a property such as val resources = context.resources, find
+ // the initializer
+ val initializer =
+ (resources.tryResolveUDeclaration() as? UVariable)?.uastInitializer
+ ?: return
+ if (initializer !is UQualifiedReferenceExpression) return
+ if (!initializer.isCallToGetResources()) return
+ // Return the receiver, e.g. `context` in the case of
+ // `context.resources`
+ initializer.receiver.skipParenthesizedExprDown()
+ }
+ else -> return
+ }
+
+ // Try and find out where this context came from
+ val contextSource =
+ when (contextExpression) {
+ // Still part of a qualified expression, e.g. LocalContext.current
+ is UQualifiedReferenceExpression -> contextExpression
+ // Possible reference to a variable, e.g. val context =
+ // LocalContext.current,
+ // and this USimpleNameReferenceExpression is `context`
+ is USimpleNameReferenceExpression -> {
+ // If it is a property such as val context = LocalContext.current, find
+ // the initializer
+ val initializer =
+ (contextExpression.tryResolveUDeclaration() as? UVariable)
+ ?.uastInitializer ?: return
+ if (initializer !is UQualifiedReferenceExpression) return
+ initializer
+ }
+ else -> return
+ }
+
+ if (contextSource.matchesQualified("LocalContext.current")) {
+ context.report(
+ LocalContextConfigurationRead,
+ node,
+ context.getNameLocation(node),
+ "Reading Configuration using $LocalContextCurrentResourcesConfiguration"
+ )
+ }
+ }
+ }
+
+ private fun UElement.isCallToGetConfiguration(): Boolean {
+ val resolved = tryResolve() as? PsiMethod ?: return false
+ return resolved.name == "getConfiguration" && resolved.isInPackageName(ResPackage)
+ }
+
+ private fun UElement.isCallToGetResources(): Boolean {
+ val resolved = tryResolve() as? PsiMethod ?: return false
+ return resolved.name == "getResources" && resolved.isInPackageName(ContentPackage)
+ }
+
+ companion object {
+ private const val LocalContextCurrentResourcesConfiguration =
+ "LocalContext.current.resources.configuration"
+ private const val LocalConfigurationCurrent = "LocalConfiguration.current"
+ private val ContentPackage = Package("android.content")
+ private val ResPackage = Package("android.content.res")
+
+ val LocalContextConfigurationRead =
+ Issue.create(
+ "LocalContextConfigurationRead",
+ "Reading Configuration using $LocalContextCurrentResourcesConfiguration",
+ "Changes to the Configuration object will not cause LocalContext reads to be " +
+ "invalidated, so you may end up with stale values when the Configuration " +
+ "changes. Instead, use $LocalConfigurationCurrent to retrieve the " +
+ "Configuration - this will recompose callers when the Configuration object " +
+ "changes.",
+ Category.CORRECTNESS,
+ 3,
+ Severity.ERROR,
+ Implementation(
+ LocalContextConfigurationReadDetector::class.java,
+ EnumSet.of(Scope.JAVA_FILE, Scope.TEST_SOURCES)
+ )
+ )
+ }
+}
diff --git a/compose/ui/ui-lint/src/main/java/androidx/compose/ui/lint/UiIssueRegistry.kt b/compose/ui/ui-lint/src/main/java/androidx/compose/ui/lint/UiIssueRegistry.kt
index deb81a3..636de46 100644
--- a/compose/ui/ui-lint/src/main/java/androidx/compose/ui/lint/UiIssueRegistry.kt
+++ b/compose/ui/ui-lint/src/main/java/androidx/compose/ui/lint/UiIssueRegistry.kt
@@ -31,6 +31,7 @@
get() =
listOf(
ComposedModifierDetector.UnnecessaryComposedModifier,
+ LocalContextConfigurationReadDetector.LocalContextConfigurationRead,
ModifierDeclarationDetector.ModifierFactoryExtensionFunction,
ModifierDeclarationDetector.ModifierFactoryReturnType,
ModifierDeclarationDetector.ModifierFactoryUnreferencedReceiver,
diff --git a/compose/ui/ui-lint/src/test/java/androidx/compose/ui/lint/AndroidStubs.kt b/compose/ui/ui-lint/src/test/java/androidx/compose/ui/lint/AndroidStubs.kt
new file mode 100644
index 0000000..ca900f9
--- /dev/null
+++ b/compose/ui/ui-lint/src/test/java/androidx/compose/ui/lint/AndroidStubs.kt
@@ -0,0 +1,103 @@
+/*
+ * Copyright 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.compose.ui.lint
+
+import com.android.tools.lint.checks.infrastructure.LintDetectorTest.bytecode
+import com.android.tools.lint.checks.infrastructure.LintDetectorTest.java
+
+object AndroidStubs {
+
+ val Context =
+ bytecode(
+ "libs/android.jar",
+ java(
+ """
+package android.content;
+
+import android.content.res.Resources;
+
+public class Context {
+ public Resources getResources() {
+ return null;
+ }
+}
+ """
+ ),
+ 0xc2b7484b,
+ """
+ android/content/Context.class:
+ H4sIAAAAAAAA/zv1b9c+BgYGRwZ+LgYmBmZ2BhYeBlYGNkYGgazEskT9nMS8
+ dH3/pKzU5BJGBjabzLzMEjtGBmYNzTB2Bg5GBvHEvJSi/MwU/eT8vJLUvBJ9
+ ZxBdAVTL4pyfksrIwO+TmZfqV5qblFoUkpiUAxThSU8tCUotzi8tSk4tZmRQ
+ 1ND0QTekKLVYH67EmpGBKxjMdMsE64daoQdyH4MiAzvQ2SDAxMAIcjiQ5ATy
+ ZIE0I5Bm1drOwLgRyACaAiTZwIIgkpuBB6pUCqqUiXEDmjoOIMkLNpoPAIc3
+ ZUAnAQAA
+ """
+ )
+
+ val Resources =
+ bytecode(
+ "libs/android.jar",
+ java(
+ """
+package android.content.res;
+
+public class Resources {
+ public Configuration getConfiguration() {
+ return null;
+ }
+}
+ """
+ ),
+ 0xf1ea767d,
+ """
+ android/content/res/Resources.class:
+ H4sIAAAAAAAA/22Pz0rDQBDGv0nTRGttexZ68CC0HtwHUAQpeCoWqnjfJGPY
+ Undhs/G59CR48AF8KOlsKILiHL75w8dvZr6+Pz4B3GA8QIJejnSIPjLCZKNf
+ tNpqW6tVseEyELIrY024JvRm88ccB4SptpV3plKls4FtUJ4btebGtb7khpAu
+ XMWE8dJYvmufC/YPutjKZFJzWDj7ZOrW62CcJZzN5sv/cL9sl4TBfUe/NZEz
+ +ll2Ee/FKXJ5I0YCio+IHko3lUyS++fvoDcphCOadcNU9AjDvfVkb03o9Y8v
+ 6nGHHu0AlRLTZjcBAAA=
+ """
+ )
+
+ val Configuration =
+ bytecode(
+ "libs/android.jar",
+ java(
+ """
+package android.content.res;
+
+public class Configuration {
+ public int screenWidthDp;
+ public int screenHeightDp;
+}
+
+ """
+ ),
+ 0xbb67f264,
+ """
+ android/content/res/Configuration.class:
+ H4sIAAAAAAAA/1WPTU7DQAyFn2ma0NA/se+iu8KCuQBCQkUIJAQLUFlPEpO6
+ Kh40nXAvVkgsOACHQkwCGxZ+9vssPdlf3x+fAM4xzbGHXoZkiD5SwnRjX63Z
+ Wq3NXbHhMhDSU1EJZ4Te4miVYZ8wt1p5J5UpnQbWYDzvzNLpk9SNt0GcEka7
+ 0jPro1RhffFCoGvC+JddsdTr0MJk6SomTG5E+bZ5Ltg/2GIbSX7vGl/ypbTm
+ 8F/0SXsh5sji4YhFGCCPE+Hgr1P7StRhdLPOA/3jd9Bbtx5FTTuYRB13IZMf
+ blk3qhEBAAA=
+ """
+ )
+}
diff --git a/compose/ui/ui-lint/src/test/java/androidx/compose/ui/lint/LocalContextConfigurationReadDetectorTest.kt b/compose/ui/ui-lint/src/test/java/androidx/compose/ui/lint/LocalContextConfigurationReadDetectorTest.kt
new file mode 100644
index 0000000..9e9c017
--- /dev/null
+++ b/compose/ui/ui-lint/src/test/java/androidx/compose/ui/lint/LocalContextConfigurationReadDetectorTest.kt
@@ -0,0 +1,181 @@
+/*
+ * Copyright 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+@file:Suppress("UnstableApiUsage")
+
+package androidx.compose.ui.lint
+
+import androidx.compose.lint.test.Stubs
+import androidx.compose.lint.test.bytecodeStub
+import com.android.tools.lint.checks.infrastructure.LintDetectorTest
+import com.android.tools.lint.detector.api.Detector
+import com.android.tools.lint.detector.api.Issue
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.junit.runners.JUnit4
+
+/** Test for [LocalContextConfigurationReadDetector]. */
+@RunWith(JUnit4::class)
+class LocalContextConfigurationReadDetectorTest : LintDetectorTest() {
+ override fun getDetector(): Detector = LocalContextConfigurationReadDetector()
+
+ override fun getIssues(): MutableList<Issue> =
+ mutableListOf(LocalContextConfigurationReadDetector.LocalContextConfigurationRead)
+
+ val LocalContextStub =
+ bytecodeStub(
+ "AndroidCompositionLocals.kt",
+ "androidx/compose/ui/platform",
+ 0xe66eae21,
+ """
+ package androidx.compose.ui.platform
+
+ import android.content.Context
+ import androidx.compose.runtime.staticCompositionLocalOf
+
+ val LocalContext = staticCompositionLocalOf<Context>()
+ """,
+ """
+ META-INF/main.kotlin_module:
+ H4sIAAAAAAAA/2NgYGBmYGBgAmJGBijg0uOSSMxLKcrPTKnQS87PLcgvTtUr
+ Ks0rycxNFRJyBgtklmTm5/nkJyfmeJdwWXHJYKgvzdQryEksScsvyhWScoTI
+ omstBurl42IpSS0uEWILAZLeJUoMWgwAohQbypQAAAA=
+ """,
+ """
+ androidx/compose/ui/platform/AndroidCompositionLocalsKt.class:
+ H4sIAAAAAAAA/61TW0sbQRT+ZrPqZpuamF40alsbbRspuLG0FBoRRBBCUxUt
+ vvg02d2EiZsZ2Z0NPvpb+gt6eSl9KNLH/qjSM5tIMeKLdGFnzjlzvu9c5szv
+ Pz9+AniNVYa3XAaxEsGZ56v+qUpCLxXeacR1R8V9b2t4uJ0dCS2UbCmfR8l7
+ PQXGUOrxAfciLrveXrsX+mTNMRS7oc7ctpXU4ZmmILXV1rU4cSq16IfefqwG
+ IuDtKBwP02A4uB1y4xJEGMpBam+US2OTSJdbKu56vVC3Yy5k4nEpleYGnHi7
+ Su+mkQlduFrDm1tVUEAebh4W7jA4G34kpNCbDLna6hHDyxsZx3lMv4sMS4lJ
+ 0x8/3eusBGGHpxGl2au1TpSmOF5v0Pc6qfSHde2MpHqj2Rq/tcbtbqeAGZRd
+ lHCPYf//39LMZSEfQs0DrjnZrP4gR5NrmYWZBQzshOxnwmh1koJ1hrWL82n3
+ 4ty15qzh71jV2dLF+bxTtstW3aqzX58mHfKYt51cyTaoVwyVG9NhWLjpJayd
+ UNPzh6IruU7jkDwPhnU35UAkgqre+jddDPa2Csip2BIy3E377TD+aDrD4B6q
+ NPbDHWGUyojj6BoD1mmW7KzueTNapC2bhuABVmifJLuT6RVMkJbDM9IWyWo+
+ +ysKnzPs85EvMDXCT13BO7iLaZINuoqs0XCZzb7j/jcUvlzjsPAiY6miRvs7
+ sj6k+LPHyDUx10SlSdkukIjFJh7h8TFYgidYOsZEgnwCN8HTxMiTfwE44RI/
+ mwQAAA==
+ """
+ )
+
+ @Test
+ fun error() {
+ lint()
+ .files(
+ kotlin(
+ """
+ package test
+
+ import androidx.compose.runtime.Composable
+ import androidx.compose.ui.platform.LocalContext
+
+ @Composable
+ fun Test() {
+ LocalContext.current.resources.configuration
+ LocalContext.current.getResources().getConfiguration()
+ }
+ """
+ ),
+ LocalContextStub,
+ Stubs.Composable,
+ Stubs.CompositionLocal,
+ AndroidStubs.Context,
+ AndroidStubs.Resources,
+ AndroidStubs.Configuration
+ )
+ .run()
+ .expect(
+ """
+src/test/test.kt:9: Error: Reading Configuration using LocalContext.current.resources.configuration [LocalContextConfigurationRead]
+ LocalContext.current.resources.configuration
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+src/test/test.kt:10: Error: Reading Configuration using LocalContext.current.resources.configuration [LocalContextConfigurationRead]
+ LocalContext.current.getResources().getConfiguration()
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+2 errors, 0 warnings
+ """
+ )
+ .expectFixDiffs(
+ """
+Autofix for src/test/test.kt line 9: Replace with LocalConfiguration.current:
+@@ -5 +5
+- import androidx.compose.ui.platform.LocalContext
++ import androidx.compose.ui.platform.LocalConfiguration
++ import androidx.compose.ui.platform.LocalContext
+@@ -9 +10
+- LocalContext.current.resources.configuration
++ LocalConfiguration.current
+ """
+ )
+ }
+
+ @Test
+ fun errors_splitReferences() {
+ lint()
+ .files(
+ kotlin(
+ """
+ package test
+
+ import androidx.compose.runtime.Composable
+ import androidx.compose.ui.platform.LocalContext
+
+ @Composable
+ fun Test1() {
+ val resources = LocalContext.current.resources
+ resources.configuration
+ }
+
+ @Composable
+ fun Test2() {
+ val context = LocalContext.current
+ context.resources.configuration
+ }
+
+ @Composable
+ fun Test3() {
+ val context = LocalContext.current
+ val res = context.resources
+ res.configuration
+ }
+ """
+ ),
+ LocalContextStub,
+ Stubs.Composable,
+ Stubs.CompositionLocal,
+ AndroidStubs.Context,
+ AndroidStubs.Resources,
+ AndroidStubs.Configuration
+ )
+ .run()
+ .expect(
+ """
+src/test/test.kt:10: Error: Reading Configuration using LocalContext.current.resources.configuration [LocalContextConfigurationRead]
+ resources.configuration
+ ~~~~~~~~~~~~~~~~~~~~~~~
+src/test/test.kt:16: Error: Reading Configuration using LocalContext.current.resources.configuration [LocalContextConfigurationRead]
+ context.resources.configuration
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+src/test/test.kt:23: Error: Reading Configuration using LocalContext.current.resources.configuration [LocalContextConfigurationRead]
+ res.configuration
+ ~~~~~~~~~~~~~~~~~
+3 errors, 0 warnings
+ """
+ )
+ }
+}
diff --git a/compose/ui/ui-test-manifest/integration-tests/testapp/build.gradle b/compose/ui/ui-test-manifest/integration-tests/testapp/build.gradle
index 1997776..a0957a4 100644
--- a/compose/ui/ui-test-manifest/integration-tests/testapp/build.gradle
+++ b/compose/ui/ui-test-manifest/integration-tests/testapp/build.gradle
@@ -22,10 +22,10 @@
}
dependencies {
+
debugImplementation(project(":compose:ui:ui-test-manifest"))
implementation(project(":compose:ui:ui"))
- implementation(project(":compose:foundation:foundation"))
implementation("androidx.tracing:tracing:1.1.0")
androidTestImplementation(project(":compose:ui:ui-test-junit4"))
androidTestImplementation(libs.testRunner)
@@ -35,8 +35,4 @@
android {
compileSdk = 35
namespace = "androidx.compose.ui.test.manifest.integration.testapp"
-
- defaultConfig {
- targetSdkVersion 35
- }
}
diff --git a/compose/ui/ui-test-manifest/integration-tests/testapp/src/androidTest/java/androidx/compose/ui/test/manifest/integration/testapp/ComponentActivityLaunchesTest.kt b/compose/ui/ui-test-manifest/integration-tests/testapp/src/androidTest/java/androidx/compose/ui/test/manifest/integration/testapp/ComponentActivityLaunchesTest.kt
index 1ddeb53..6895df0 100644
--- a/compose/ui/ui-test-manifest/integration-tests/testapp/src/androidTest/java/androidx/compose/ui/test/manifest/integration/testapp/ComponentActivityLaunchesTest.kt
+++ b/compose/ui/ui-test-manifest/integration-tests/testapp/src/androidTest/java/androidx/compose/ui/test/manifest/integration/testapp/ComponentActivityLaunchesTest.kt
@@ -16,22 +16,9 @@
package androidx.compose.ui.test.manifest.integration.testapp
-import android.os.Build
-import androidx.activity.ComponentActivity
-import androidx.compose.foundation.background
-import androidx.compose.foundation.layout.Box
-import androidx.compose.foundation.layout.size
-import androidx.compose.ui.Modifier
-import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.graphics.toPixelMap
-import androidx.compose.ui.platform.LocalDensity
-import androidx.compose.ui.platform.testTag
-import androidx.compose.ui.test.captureToImage
-import androidx.compose.ui.test.junit4.createAndroidComposeRule
-import androidx.compose.ui.test.onNodeWithTag
+import androidx.compose.ui.test.junit4.createComposeRule
import androidx.test.ext.junit.runners.AndroidJUnit4
import androidx.test.filters.LargeTest
-import androidx.test.filters.SdkSuppress
import org.junit.Rule
import org.junit.Test
import org.junit.runner.RunWith
@@ -39,42 +26,11 @@
@LargeTest
@RunWith(AndroidJUnit4::class)
class ComponentActivityLaunchesTest {
- @get:Rule val rule = createAndroidComposeRule<ComponentActivity>()
+ @get:Rule val rule = createComposeRule()
@Test
- fun activity_launches() {
+ fun test() {
rule.setContent {}
// Test does not crash and does not time out
}
-
- // Regression test for b/383368165
- // When targeting SDK 35, an activity is edge-to-edge by default and the action bar will overlap
- // the content. We can only detect this by taking a screenshot, assertIsDisplayed() doesn't work
- // due to b/383368165#comment2.
- @Test
- @SdkSuppress(minSdkVersion = Build.VERSION_CODES.O)
- fun activity_notCoveredByActionBar() {
- val color = Color.Red
- val size = 10
- rule.setContent {
- with(LocalDensity.current) {
- Box(Modifier.size(size.toDp()).background(color).testTag("box"))
- }
- }
-
- rule.onNodeWithTag("box").captureToImage().let {
- assert(it.width == size && it.height == size) {
- // We don't really need to test this, but better be safe then sorry
- "Screenshot size should be 10x10, but was ${it.width}x${it.height}"
- }
- val map = it.toPixelMap()
- for (y in 0 until map.height) {
- for (x in 0 until map.width) {
- assert(map[x, y] == color) {
- "Pixel at ($x, $y) is ${map[x, y]} instead of $color"
- }
- }
- }
- }
- }
}
diff --git a/compose/ui/ui-test-manifest/src/main/AndroidManifest.xml b/compose/ui/ui-test-manifest/src/main/AndroidManifest.xml
index 620129d..d96a063 100644
--- a/compose/ui/ui-test-manifest/src/main/AndroidManifest.xml
+++ b/compose/ui/ui-test-manifest/src/main/AndroidManifest.xml
@@ -16,7 +16,6 @@
-->
<manifest xmlns:android="http://schemas.android.com/apk/res/android">
<application>
- <activity android:theme="@android:style/Theme.Material.Light.NoActionBar"
- android:name="androidx.activity.ComponentActivity" android:exported="true" />
+ <activity android:name="androidx.activity.ComponentActivity" android:exported="true" />
</application>
</manifest>
diff --git a/compose/ui/ui-test/src/androidInstrumentedTest/AndroidManifest.xml b/compose/ui/ui-test/src/androidInstrumentedTest/AndroidManifest.xml
index 5ceffbc..d70ca0d 100644
--- a/compose/ui/ui-test/src/androidInstrumentedTest/AndroidManifest.xml
+++ b/compose/ui/ui-test/src/androidInstrumentedTest/AndroidManifest.xml
@@ -16,7 +16,7 @@
-->
<manifest xmlns:android="http://schemas.android.com/apk/res/android">
<application>
- <activity android:name="androidx.compose.ui.test.CustomComposeHostActivity" />
+ <activity android:name="androidx.compose.ui.test.ActivityWithActionBar" />
<activity android:name="androidx.compose.ui.test.ClickCounterActivity" />
<activity android:name="androidx.compose.ui.test.EmptyActivity" />
diff --git a/compose/ui/ui-test/src/androidInstrumentedTest/kotlin/androidx/compose/ui/test/CustomComposeHostActivity.kt b/compose/ui/ui-test/src/androidInstrumentedTest/kotlin/androidx/compose/ui/test/ActivityWithActionBar.kt
similarity index 96%
rename from compose/ui/ui-test/src/androidInstrumentedTest/kotlin/androidx/compose/ui/test/CustomComposeHostActivity.kt
rename to compose/ui/ui-test/src/androidInstrumentedTest/kotlin/androidx/compose/ui/test/ActivityWithActionBar.kt
index f40f330..4fc309f 100644
--- a/compose/ui/ui-test/src/androidInstrumentedTest/kotlin/androidx/compose/ui/test/CustomComposeHostActivity.kt
+++ b/compose/ui/ui-test/src/androidInstrumentedTest/kotlin/androidx/compose/ui/test/ActivityWithActionBar.kt
@@ -25,7 +25,7 @@
import androidx.compose.ui.platform.ComposeView
// The presence of an ActionBar follows from the theme set in AndroidManifest.xml
-class CustomComposeHostActivity : ComponentActivity() {
+class ActivityWithActionBar : ComponentActivity() {
private lateinit var composeHolder: ComposeView
override fun onCreate(savedInstanceState: Bundle?) {
diff --git a/compose/ui/ui-test/src/androidInstrumentedTest/kotlin/androidx/compose/ui/test/BitmapCapturingTest.kt b/compose/ui/ui-test/src/androidInstrumentedTest/kotlin/androidx/compose/ui/test/BitmapCapturingTest.kt
index aaa5e16..2120a4c 100644
--- a/compose/ui/ui-test/src/androidInstrumentedTest/kotlin/androidx/compose/ui/test/BitmapCapturingTest.kt
+++ b/compose/ui/ui-test/src/androidInstrumentedTest/kotlin/androidx/compose/ui/test/BitmapCapturingTest.kt
@@ -63,7 +63,7 @@
fun createTestSet(): List<TestConfig> =
listOf(
TestConfig(ComponentActivity::class.java),
- TestConfig(CustomComposeHostActivity::class.java)
+ TestConfig(ActivityWithActionBar::class.java)
)
}
@@ -239,7 +239,7 @@
private fun setContent(content: @Composable () -> Unit) {
when (val activity = rule.activity) {
- is CustomComposeHostActivity -> activity.setContent(content)
+ is ActivityWithActionBar -> activity.setContent(content)
else -> rule.setContent(content)
}
}
diff --git a/compose/ui/ui-test/src/androidInstrumentedTest/kotlin/androidx/compose/ui/test/IsDisplayedTest.kt b/compose/ui/ui-test/src/androidInstrumentedTest/kotlin/androidx/compose/ui/test/IsDisplayedTest.kt
index a05ce4c..4311d59 100644
--- a/compose/ui/ui-test/src/androidInstrumentedTest/kotlin/androidx/compose/ui/test/IsDisplayedTest.kt
+++ b/compose/ui/ui-test/src/androidInstrumentedTest/kotlin/androidx/compose/ui/test/IsDisplayedTest.kt
@@ -70,7 +70,7 @@
fun createTestSet(): List<TestConfig> =
listOf(
TestConfig(ComponentActivity::class.java),
- TestConfig(CustomComposeHostActivity::class.java)
+ TestConfig(ActivityWithActionBar::class.java)
)
}
@@ -314,7 +314,7 @@
private fun setContent(content: @Composable () -> Unit) {
when (val activity = rule.activity) {
- is CustomComposeHostActivity -> activity.setContent(content)
+ is ActivityWithActionBar -> activity.setContent(content)
else -> rule.setContent(content)
}
}
diff --git a/compose/ui/ui-test/src/androidInstrumentedTest/kotlin/androidx/compose/ui/test/gesturescope/SendClickTest.kt b/compose/ui/ui-test/src/androidInstrumentedTest/kotlin/androidx/compose/ui/test/gesturescope/SendClickTest.kt
index 736a3a9..c38fbc1 100644
--- a/compose/ui/ui-test/src/androidInstrumentedTest/kotlin/androidx/compose/ui/test/gesturescope/SendClickTest.kt
+++ b/compose/ui/ui-test/src/androidInstrumentedTest/kotlin/androidx/compose/ui/test/gesturescope/SendClickTest.kt
@@ -24,7 +24,7 @@
import androidx.compose.ui.input.pointer.PointerInputFilter
import androidx.compose.ui.input.pointer.PointerInputModifier
import androidx.compose.ui.input.pointer.changedToUp
-import androidx.compose.ui.test.CustomComposeHostActivity
+import androidx.compose.ui.test.ActivityWithActionBar
import androidx.compose.ui.test.click
import androidx.compose.ui.test.junit4.ComposeTestRule
import androidx.compose.ui.test.junit4.createAndroidComposeRule
@@ -55,11 +55,11 @@
for (x in listOf(0.0f, squareSize - 1.0f)) {
for (y in listOf(0.0f, squareSize - 1.0f)) {
add(TestConfig(Offset(x, y), ComponentActivity::class.java))
- add(TestConfig(Offset(x, y), CustomComposeHostActivity::class.java))
+ add(TestConfig(Offset(x, y), ActivityWithActionBar::class.java))
}
}
add(TestConfig(null, ComponentActivity::class.java))
- add(TestConfig(null, CustomComposeHostActivity::class.java))
+ add(TestConfig(null, ActivityWithActionBar::class.java))
}
}
}
@@ -89,7 +89,7 @@
// Given a column of 5 small components
var contentSet = false
rule.activityRule.scenario.onActivity {
- if (it is CustomComposeHostActivity) {
+ if (it is ActivityWithActionBar) {
it.setContent { ColumnOfSquares(5) }
contentSet = true
}
diff --git a/compose/ui/ui-tooling-preview/api/current.ignore b/compose/ui/ui-tooling-preview/api/current.ignore
index bb613a9..0c2a99c 100644
--- a/compose/ui/ui-tooling-preview/api/current.ignore
+++ b/compose/ui/ui-tooling-preview/api/current.ignore
@@ -1,4 +1,8 @@
// Baseline format: 1.0
+ChangedType: androidx.compose.ui.tooling.preview.PreviewParameter#provider():
+ Method androidx.compose.ui.tooling.preview.PreviewParameter.provider has changed return type from kotlin.reflect.KClass<? extends androidx.compose.ui.tooling.preview.PreviewParameterProvider<?>> to java.lang.Class<? extends androidx.compose.ui.tooling.preview.PreviewParameterProvider<?>>
+
+
ChangedValue: androidx.compose.ui.tooling.preview.Devices#DESKTOP:
Field androidx.compose.ui.tooling.preview.Devices.DESKTOP has changed value from spec:id=reference_desktop,shape=Normal,width=1920,height=1080,unit=dp,dpi=160 to spec:width=1920dp,height=1080dp,dpi=160
ChangedValue: androidx.compose.ui.tooling.preview.Devices#FOLDABLE:
diff --git a/compose/ui/ui-tooling-preview/api/current.txt b/compose/ui/ui-tooling-preview/api/current.txt
index b431232..d6b5c19 100644
--- a/compose/ui/ui-tooling-preview/api/current.txt
+++ b/compose/ui/ui-tooling-preview/api/current.txt
@@ -148,9 +148,9 @@
@java.lang.annotation.Retention(java.lang.annotation.RetentionPolicy.RUNTIME) public @interface PreviewParameter {
method public abstract int limit() default kotlin.jvm.internal.IntCompanionObject.MAX_VALUE;
- method public abstract kotlin.reflect.KClass<? extends androidx.compose.ui.tooling.preview.PreviewParameterProvider<? extends java.lang.Object?>> provider();
+ method public abstract Class<? extends androidx.compose.ui.tooling.preview.PreviewParameterProvider<? extends java.lang.Object?>> provider();
property public abstract int limit;
- property public abstract kotlin.reflect.KClass<? extends androidx.compose.ui.tooling.preview.PreviewParameterProvider<? extends java.lang.Object?>> provider;
+ property public abstract Class<? extends androidx.compose.ui.tooling.preview.PreviewParameterProvider<? extends java.lang.Object?>> provider;
}
@kotlin.jvm.JvmDefaultWithCompatibility public interface PreviewParameterProvider<T> {
diff --git a/compose/ui/ui-tooling-preview/api/restricted_current.ignore b/compose/ui/ui-tooling-preview/api/restricted_current.ignore
index bb613a9..0c2a99c 100644
--- a/compose/ui/ui-tooling-preview/api/restricted_current.ignore
+++ b/compose/ui/ui-tooling-preview/api/restricted_current.ignore
@@ -1,4 +1,8 @@
// Baseline format: 1.0
+ChangedType: androidx.compose.ui.tooling.preview.PreviewParameter#provider():
+ Method androidx.compose.ui.tooling.preview.PreviewParameter.provider has changed return type from kotlin.reflect.KClass<? extends androidx.compose.ui.tooling.preview.PreviewParameterProvider<?>> to java.lang.Class<? extends androidx.compose.ui.tooling.preview.PreviewParameterProvider<?>>
+
+
ChangedValue: androidx.compose.ui.tooling.preview.Devices#DESKTOP:
Field androidx.compose.ui.tooling.preview.Devices.DESKTOP has changed value from spec:id=reference_desktop,shape=Normal,width=1920,height=1080,unit=dp,dpi=160 to spec:width=1920dp,height=1080dp,dpi=160
ChangedValue: androidx.compose.ui.tooling.preview.Devices#FOLDABLE:
diff --git a/compose/ui/ui-tooling-preview/api/restricted_current.txt b/compose/ui/ui-tooling-preview/api/restricted_current.txt
index b431232..d6b5c19 100644
--- a/compose/ui/ui-tooling-preview/api/restricted_current.txt
+++ b/compose/ui/ui-tooling-preview/api/restricted_current.txt
@@ -148,9 +148,9 @@
@java.lang.annotation.Retention(java.lang.annotation.RetentionPolicy.RUNTIME) public @interface PreviewParameter {
method public abstract int limit() default kotlin.jvm.internal.IntCompanionObject.MAX_VALUE;
- method public abstract kotlin.reflect.KClass<? extends androidx.compose.ui.tooling.preview.PreviewParameterProvider<? extends java.lang.Object?>> provider();
+ method public abstract Class<? extends androidx.compose.ui.tooling.preview.PreviewParameterProvider<? extends java.lang.Object?>> provider();
property public abstract int limit;
- property public abstract kotlin.reflect.KClass<? extends androidx.compose.ui.tooling.preview.PreviewParameterProvider<? extends java.lang.Object?>> provider;
+ property public abstract Class<? extends androidx.compose.ui.tooling.preview.PreviewParameterProvider<? extends java.lang.Object?>> provider;
}
@kotlin.jvm.JvmDefaultWithCompatibility public interface PreviewParameterProvider<T> {
diff --git a/compose/ui/ui-tooling-preview/build.gradle b/compose/ui/ui-tooling-preview/build.gradle
index 2ea5618..59a92e2 100644
--- a/compose/ui/ui-tooling-preview/build.gradle
+++ b/compose/ui/ui-tooling-preview/build.gradle
@@ -99,6 +99,5 @@
description = "Compose tooling library API. This library provides the API required to declare" +
" @Preview composables in user apps."
legacyDisableKotlinStrictApiMode = true
- metalavaK2UastEnabled = false
}
diff --git a/compose/ui/ui-unit/src/commonMain/kotlin/androidx/compose/ui/unit/Constraints.kt b/compose/ui/ui-unit/src/commonMain/kotlin/androidx/compose/ui/unit/Constraints.kt
index 79ba2da..80e1938 100644
--- a/compose/ui/ui-unit/src/commonMain/kotlin/androidx/compose/ui/unit/Constraints.kt
+++ b/compose/ui/ui-unit/src/commonMain/kotlin/androidx/compose/ui/unit/Constraints.kt
@@ -368,10 +368,16 @@
private const val MinFocusBits = 16
private const val MaxAllowedForMinFocusBits = (1 shl (31 - MinFocusBits)) - 2
+/** The mask to use for the focused dimension when there is minimal focus. */
+private const val MinFocusMask = 0xFFFF // 64K (16 bits)
+
/** The number of bits used for the non-focused dimension when there is minimal focus. */
private const val MinNonFocusBits = 15
private const val MaxAllowedForMinNonFocusBits = (1 shl (31 - MinNonFocusBits)) - 2
+/** The mask to use for the non-focused dimension when there is minimal focus. */
+private const val MinNonFocusMask = 0x7FFF // 32K (15 bits)
+
/** The number of bits to use for the focused dimension when there is maximal focus. */
private const val MaxFocusBits = 18
private const val MaxAllowedForMaxFocusBits = (1 shl (31 - MaxFocusBits)) - 2
@@ -383,6 +389,9 @@
private const val MaxNonFocusBits = 13
private const val MaxAllowedForMaxNonFocusBits = (1 shl (31 - MaxNonFocusBits)) - 2
+/** The mask to use for the non-focused dimension when there is maximal focus. */
+private const val MaxNonFocusMask = 0x1FFF // 8K (13 bits)
+
// 0xFFFFFFFE_00000003UL.toLong(), written as a signed value to declare it const
@PublishedApi internal const val MaxDimensionsAndFocusMask = -0x00000001_FFFFFFFDL
@@ -443,35 +452,22 @@
}
internal fun bitsNeedForSizeUnchecked(size: Int): Int {
- // We could look at the value of size itself, for instance by doing:
- // when {
- // size < MaxNonFocusMask -> MaxNonFocusBits
- // ...
- // }
- // but the following solution saves a few instructions by avoiding
- // multiple moves to load large constants
- val bits = (size + 1).countLeadingZeroBits()
return when {
- bits >= 32 - MaxNonFocusBits -> MaxNonFocusBits
- bits >= 32 - MinNonFocusBits -> MinNonFocusBits
- bits >= 32 - MinFocusBits -> MinFocusBits
- bits >= 32 - MaxFocusBits -> MaxFocusBits
+ size < MaxNonFocusMask -> MaxNonFocusBits
+ size < MinNonFocusMask -> MinNonFocusBits
+ size < MinFocusMask -> MinFocusBits
+ size < MaxFocusMask -> MaxFocusBits
else -> 255
}
}
private inline fun maxAllowedForSize(size: Int): Int {
- // See comment in bitsNeedForSizeUnchecked()
- // Note: the return value in every case is `1 shl (31 - bits) - 2`
- // However, computing the value instead of using constants uses more
- // instructions, so not worth it
- val bits = (size + 1).countLeadingZeroBits()
- if (bits <= 13) throwInvalidConstraintsSizeException(size)
return when {
- bits >= 32 - MaxNonFocusBits -> MaxAllowedForMaxNonFocusBits
- bits >= 32 - MinNonFocusBits -> MaxAllowedForMinNonFocusBits
- bits >= 32 - MinFocusBits -> MaxAllowedForMinFocusBits
- else -> MaxAllowedForMaxFocusBits
+ size < MaxNonFocusMask -> MaxAllowedForMaxNonFocusBits
+ size < MinNonFocusMask -> MaxAllowedForMinNonFocusBits
+ size < MinFocusMask -> MaxAllowedForMinFocusBits
+ size < MaxFocusMask -> MaxAllowedForMaxFocusBits
+ else -> throwInvalidConstraintsSizeException(size)
}
}
diff --git a/compose/ui/ui-unit/src/commonMain/kotlin/androidx/compose/ui/unit/Density.kt b/compose/ui/ui-unit/src/commonMain/kotlin/androidx/compose/ui/unit/Density.kt
index 5b3e3c5..cbefe8a 100644
--- a/compose/ui/ui-unit/src/commonMain/kotlin/androidx/compose/ui/unit/Density.kt
+++ b/compose/ui/ui-unit/src/commonMain/kotlin/androidx/compose/ui/unit/Density.kt
@@ -65,7 +65,7 @@
*/
@Stable
fun TextUnit.toPx(): Float {
- check(type == TextUnitType.Sp) { "Only Sp can convert to Px" }
+ checkPrecondition(type == TextUnitType.Sp) { "Only Sp can convert to Px" }
return toDp().toPx()
}
diff --git a/compose/ui/ui-unit/src/commonMain/kotlin/androidx/compose/ui/unit/Dp.kt b/compose/ui/ui-unit/src/commonMain/kotlin/androidx/compose/ui/unit/Dp.kt
index a88b3c0..e5cac56 100644
--- a/compose/ui/ui-unit/src/commonMain/kotlin/androidx/compose/ui/unit/Dp.kt
+++ b/compose/ui/ui-unit/src/commonMain/kotlin/androidx/compose/ui/unit/Dp.kt
@@ -83,7 +83,10 @@
/** Infinite dp dimension. */
@Stable val Infinity = Dp(Float.POSITIVE_INFINITY)
- /** Constant that means unspecified Dp */
+ /**
+ * Constant that means unspecified Dp. Instead of comparing a [Dp] value to this constant,
+ * consider using [isSpecified] and [isUnspecified] instead.
+ */
@Stable val Unspecified = Dp(Float.NaN)
}
}
diff --git a/compose/ui/ui/benchmark/src/androidTest/java/androidx/compose/ui/benchmark/input/pointer/TapIntegrationBenchmarkValues.kt b/compose/ui/ui/benchmark/src/androidTest/java/androidx/compose/ui/benchmark/input/pointer/TapIntegrationBenchmarkValues.kt
index 8ef603f..0649fe7 100644
--- a/compose/ui/ui/benchmark/src/androidTest/java/androidx/compose/ui/benchmark/input/pointer/TapIntegrationBenchmarkValues.kt
+++ b/compose/ui/ui/benchmark/src/androidTest/java/androidx/compose/ui/benchmark/input/pointer/TapIntegrationBenchmarkValues.kt
@@ -1,5 +1,5 @@
/*
- * Copyright 20201 The Android Open Source Project
+ * Copyright 2021 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
diff --git a/compose/ui/ui/build.gradle b/compose/ui/ui/build.gradle
index 73d3551..3a1ada1 100644
--- a/compose/ui/ui/build.gradle
+++ b/compose/ui/ui/build.gradle
@@ -24,7 +24,6 @@
import androidx.build.KotlinTarget
import androidx.build.LibraryType
-import androidx.build.KmpPlatformsKt
import androidx.build.PlatformIdentifier
import static androidx.inspection.gradle.InspectionPluginKt.packageInspector
@@ -60,6 +59,8 @@
api(project(":compose:ui:ui-util"))
api("androidx.lifecycle:lifecycle-runtime-compose:2.8.7")
+
+ implementation(project(":performance:performance-annotation"))
}
}
diff --git a/compose/ui/ui/proguard-rules.pro b/compose/ui/ui/proguard-rules.pro
index d6f21c4..1f592ff3 100644
--- a/compose/ui/ui/proguard-rules.pro
+++ b/compose/ui/ui/proguard-rules.pro
@@ -52,3 +52,7 @@
-keepnames class androidx.compose.ui.input.pointer.PointerInputEventHandler {
*;
}
+
+-keepclassmembers class * {
+ @dalvik.annotation.optimization.NeverInline *;
+}
diff --git a/compose/ui/ui/src/androidInstrumentedTest/kotlin/androidx/compose/ui/input/pointer/AndroidPointerInputTest.kt b/compose/ui/ui/src/androidInstrumentedTest/kotlin/androidx/compose/ui/input/pointer/AndroidPointerInputTest.kt
index c9d13ac..67dcaf4 100644
--- a/compose/ui/ui/src/androidInstrumentedTest/kotlin/androidx/compose/ui/input/pointer/AndroidPointerInputTest.kt
+++ b/compose/ui/ui/src/androidInstrumentedTest/kotlin/androidx/compose/ui/input/pointer/AndroidPointerInputTest.kt
@@ -206,6 +206,7 @@
}
@Test
+ @SdkSuppress(maxSdkVersion = 34) // b/384972397: Failing on SDK 35
fun dispatchTouchEvent_noPointerInputModifiers_returnsFalse() {
// Arrange
diff --git a/compose/ui/ui/src/commonMain/kotlin/androidx/compose/ui/input/pointer/util/PointerIdArray.kt b/compose/ui/ui/src/commonMain/kotlin/androidx/compose/ui/input/pointer/util/PointerIdArray.kt
index d96d294..f295af3 100644
--- a/compose/ui/ui/src/commonMain/kotlin/androidx/compose/ui/input/pointer/util/PointerIdArray.kt
+++ b/compose/ui/ui/src/commonMain/kotlin/androidx/compose/ui/input/pointer/util/PointerIdArray.kt
@@ -19,6 +19,7 @@
package androidx.compose.ui.input.pointer.util
import androidx.compose.ui.input.pointer.PointerId
+import dalvik.annotation.optimization.NeverInline
/**
* This collection is specifically for dealing with [PointerId] values. We know that they contain
@@ -144,6 +145,7 @@
if (index >= size) size = index + 1
}
+ @NeverInline
private fun resizeStorage(minSize: Int): LongArray {
return internalArray.copyOf(maxOf(minSize, internalArray.size * 2)).apply {
internalArray = this
diff --git a/compose/ui/ui/src/commonMain/kotlin/androidx/compose/ui/node/MyersDiff.kt b/compose/ui/ui/src/commonMain/kotlin/androidx/compose/ui/node/MyersDiff.kt
index acc7620..1d84d69 100644
--- a/compose/ui/ui/src/commonMain/kotlin/androidx/compose/ui/node/MyersDiff.kt
+++ b/compose/ui/ui/src/commonMain/kotlin/androidx/compose/ui/node/MyersDiff.kt
@@ -18,6 +18,7 @@
package androidx.compose.ui.node
import androidx.compose.ui.internal.checkPrecondition
+import dalvik.annotation.optimization.NeverInline
import kotlin.jvm.JvmInline
import kotlin.math.abs
import kotlin.math.min
@@ -417,6 +418,7 @@
val size: Int
get() = lastIndex
+ @NeverInline
private fun resizeStack(stack: IntArray): IntArray {
val copy = stack.copyOf(stack.size * 2)
this.stack = copy
diff --git a/compose/ui/ui/src/commonMain/kotlin/androidx/compose/ui/spatial/RectList.kt b/compose/ui/ui/src/commonMain/kotlin/androidx/compose/ui/spatial/RectList.kt
index 259ae65..ab2eb07 100644
--- a/compose/ui/ui/src/commonMain/kotlin/androidx/compose/ui/spatial/RectList.kt
+++ b/compose/ui/ui/src/commonMain/kotlin/androidx/compose/ui/spatial/RectList.kt
@@ -14,10 +14,11 @@
* limitations under the License.
*/
-@file:Suppress("NOTHING_TO_INLINE")
+@file:Suppress("NOTHING_TO_INLINE", "KotlinRedundantDiagnosticSuppress")
package androidx.compose.ui.spatial
+import dalvik.annotation.optimization.NeverInline
import kotlin.jvm.JvmField
import kotlin.math.max
import kotlin.math.min
@@ -98,19 +99,24 @@
* keep this in mind if you call this method and have cached any of those values in a local
* variable, you may need to refresh them.
*/
- internal fun allocateItemsIndex(): Int {
+ private inline fun allocateItemsIndex(): Int {
val currentItems = items
val currentSize = itemsSize
itemsSize = currentSize + LongsPerItem
val actualSize = currentItems.size
if (actualSize <= currentSize + LongsPerItem) {
- val newSize = max(actualSize * 2, currentSize + LongsPerItem)
- items = currentItems.copyOf(newSize)
- stack = stack.copyOf(newSize)
+ resizeStorage(actualSize, currentSize, currentItems)
}
return currentSize
}
+ @NeverInline
+ private fun resizeStorage(actualSize: Int, currentSize: Int, currentItems: LongArray) {
+ val newSize = max(actualSize * 2, currentSize + LongsPerItem)
+ items = currentItems.copyOf(newSize)
+ stack = stack.copyOf(newSize)
+ }
+
/**
* Insert a value and corresponding bounding rectangle into the RectList. This method does not
* check to see that [value] doesn't already exist somewhere in the list.
diff --git a/constraintlayout/constraintlayout-compose/build.gradle b/constraintlayout/constraintlayout-compose/build.gradle
index 970db03..333e65d 100644
--- a/constraintlayout/constraintlayout-compose/build.gradle
+++ b/constraintlayout/constraintlayout-compose/build.gradle
@@ -83,6 +83,7 @@
implementation(project(":compose:material:material"))
implementation("androidx.compose.material:material-icons-core:1.6.7")
implementation(project(":compose:ui:ui-test-junit4"))
+ implementation(project(":compose:ui:ui-test-manifest"))
implementation(project(":compose:test-utils"))
}
}
diff --git a/coordinatorlayout/coordinatorlayout/src/androidTest/java/androidx/coordinatorlayout/widget/CoordinatorLayoutTest.java b/coordinatorlayout/coordinatorlayout/src/androidTest/java/androidx/coordinatorlayout/widget/CoordinatorLayoutTest.java
index 8a1c752..0611df9 100644
--- a/coordinatorlayout/coordinatorlayout/src/androidTest/java/androidx/coordinatorlayout/widget/CoordinatorLayoutTest.java
+++ b/coordinatorlayout/coordinatorlayout/src/androidTest/java/androidx/coordinatorlayout/widget/CoordinatorLayoutTest.java
@@ -91,7 +91,7 @@
}
@Test
- @SdkSuppress(minSdkVersion = 21)
+ @SdkSuppress(minSdkVersion = 21, maxSdkVersion = 34) // b/384972523: Failing on SDK 35
public void testSetFitSystemWindows() throws Throwable {
// Skip this test on Android TV
PackageManager manager = mActivityTestRule.getActivity().getPackageManager();
diff --git a/core/core-ktx/src/main/java/androidx/core/graphics/Picture.kt b/core/core-ktx/src/main/java/androidx/core/graphics/Picture.kt
index 47a4c8e..a0fec99 100644
--- a/core/core-ktx/src/main/java/androidx/core/graphics/Picture.kt
+++ b/core/core-ktx/src/main/java/androidx/core/graphics/Picture.kt
@@ -1,5 +1,5 @@
/*
- * Copyright (C) 20188 The Android Open Source Project
+ * Copyright (C) 2018 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
diff --git a/core/core-telecom/src/androidTest/AndroidManifest.xml b/core/core-telecom/src/androidTest/AndroidManifest.xml
index 897f4cb..8e9ed4d 100644
--- a/core/core-telecom/src/androidTest/AndroidManifest.xml
+++ b/core/core-telecom/src/androidTest/AndroidManifest.xml
@@ -18,6 +18,7 @@
<uses-permission android:name="android.permission.MANAGE_OWN_CALLS" />
<uses-permission android:name="android.permission.READ_PHONE_NUMBERS"/>
<uses-permission android:name="android.permission.MODIFY_AUDIO_SETTINGS" />
+ <uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />
<application>
<service
diff --git a/core/core-telecom/src/androidTest/java/androidx/core/telecom/test/PreCallEndpointsTest.kt b/core/core-telecom/src/androidTest/java/androidx/core/telecom/test/PreCallEndpointsTest.kt
index 8b65769..f1bcaff 100644
--- a/core/core-telecom/src/androidTest/java/androidx/core/telecom/test/PreCallEndpointsTest.kt
+++ b/core/core-telecom/src/androidTest/java/androidx/core/telecom/test/PreCallEndpointsTest.kt
@@ -24,7 +24,7 @@
import androidx.core.telecom.CallEndpointCompat.Companion.TYPE_EARPIECE
import androidx.core.telecom.CallEndpointCompat.Companion.TYPE_SPEAKER
import androidx.core.telecom.internal.CallEndpointUuidTracker
-import androidx.core.telecom.internal.PreCallEndpoints
+import androidx.core.telecom.internal.PreCallEndpointsUpdater
import androidx.test.filters.SdkSuppress
import androidx.test.filters.SmallTest
import kotlinx.coroutines.channels.Channel
@@ -52,7 +52,7 @@
@Test
fun testInitialValues() {
val initEndpoints = mutableListOf(defaultEarpiece, defaultSpeaker, defaultBluetooth)
- val currentPreCallEndpoints = PreCallEndpoints(initEndpoints, Channel())
+ val currentPreCallEndpoints = PreCallEndpointsUpdater(initEndpoints, Channel())
assertTrue(currentPreCallEndpoints.isCallEndpointBeingTracked(defaultEarpiece))
assertTrue(currentPreCallEndpoints.isCallEndpointBeingTracked(defaultSpeaker))
assertTrue(currentPreCallEndpoints.isCallEndpointBeingTracked(defaultBluetooth))
@@ -65,51 +65,51 @@
@Test
fun testEndpointsAddedWithNewEndpoint() {
val initEndpoints = mutableListOf(defaultEarpiece)
- val currentPreCallEndpoints = PreCallEndpoints(initEndpoints, Channel())
+ val currentPreCallEndpoints = PreCallEndpointsUpdater(initEndpoints, Channel())
assertTrue(currentPreCallEndpoints.isCallEndpointBeingTracked(defaultEarpiece))
assertFalse(currentPreCallEndpoints.isCallEndpointBeingTracked(defaultSpeaker))
val res = currentPreCallEndpoints.maybeAddCallEndpoint(defaultSpeaker)
- assertEquals(PreCallEndpoints.START_TRACKING_NEW_ENDPOINT, res)
+ assertEquals(PreCallEndpointsUpdater.START_TRACKING_NEW_ENDPOINT, res)
}
@SmallTest
@Test
fun testEndpointsAddedWithNoNewEndpoints() {
val initEndpoints = mutableListOf(defaultEarpiece, defaultSpeaker)
- val currentPreCallEndpoints = PreCallEndpoints(initEndpoints, Channel())
+ val currentPreCallEndpoints = PreCallEndpointsUpdater(initEndpoints, Channel())
assertTrue(currentPreCallEndpoints.isCallEndpointBeingTracked(defaultEarpiece))
assertTrue(currentPreCallEndpoints.isCallEndpointBeingTracked(defaultSpeaker))
val res = currentPreCallEndpoints.maybeAddCallEndpoint(defaultSpeaker)
- assertEquals(PreCallEndpoints.ALREADY_TRACKING_ENDPOINT, res)
+ assertEquals(PreCallEndpointsUpdater.ALREADY_TRACKING_ENDPOINT, res)
}
@SmallTest
@Test
fun testEndpointsRemovedWithUntrackedEndpoint() {
val initEndpoints = mutableListOf(defaultEarpiece)
- val currentPreCallEndpoints = PreCallEndpoints(initEndpoints, Channel())
+ val currentPreCallEndpoints = PreCallEndpointsUpdater(initEndpoints, Channel())
assertTrue(currentPreCallEndpoints.isCallEndpointBeingTracked(defaultEarpiece))
assertFalse(currentPreCallEndpoints.isCallEndpointBeingTracked(defaultSpeaker))
val res = currentPreCallEndpoints.maybeRemoveCallEndpoint(defaultSpeaker)
- assertEquals(PreCallEndpoints.NOT_TRACKING_REMOVED_ENDPOINT, res)
+ assertEquals(PreCallEndpointsUpdater.NOT_TRACKING_REMOVED_ENDPOINT, res)
}
@SmallTest
@Test
fun testEndpointsRemovedWithTrackedEndpoint() {
val initEndpoints = mutableListOf(defaultEarpiece, defaultSpeaker)
- val currentPreCallEndpoints = PreCallEndpoints(initEndpoints, Channel())
+ val currentPreCallEndpoints = PreCallEndpointsUpdater(initEndpoints, Channel())
assertTrue(currentPreCallEndpoints.isCallEndpointBeingTracked(defaultEarpiece))
assertTrue(currentPreCallEndpoints.isCallEndpointBeingTracked(defaultSpeaker))
val res = currentPreCallEndpoints.maybeRemoveCallEndpoint(defaultSpeaker)
- assertEquals(PreCallEndpoints.STOP_TRACKING_REMOVED_ENDPOINT, res)
+ assertEquals(PreCallEndpointsUpdater.STOP_TRACKING_REMOVED_ENDPOINT, res)
}
}
diff --git a/core/core-telecom/src/main/java/androidx/core/telecom/CallsManager.kt b/core/core-telecom/src/main/java/androidx/core/telecom/CallsManager.kt
index 94ecba9..f84b88d 100644
--- a/core/core-telecom/src/main/java/androidx/core/telecom/CallsManager.kt
+++ b/core/core-telecom/src/main/java/androidx/core/telecom/CallsManager.kt
@@ -18,9 +18,6 @@
import android.content.ComponentName
import android.content.Context
-import android.media.AudioDeviceCallback
-import android.media.AudioDeviceInfo
-import android.media.AudioManager
import android.os.Build.VERSION_CODES
import android.os.Bundle
import android.os.OutcomeReceiver
@@ -44,15 +41,15 @@
import androidx.core.telecom.extensions.ExtensionInitializationScope
import androidx.core.telecom.extensions.ExtensionInitializationScopeImpl
import androidx.core.telecom.internal.AddCallResult
+import androidx.core.telecom.internal.AudioDeviceListener
+import androidx.core.telecom.internal.BluetoothProfileListener
import androidx.core.telecom.internal.CallChannels
import androidx.core.telecom.internal.CallEndpointUuidTracker
import androidx.core.telecom.internal.CallSession
import androidx.core.telecom.internal.CallSessionLegacy
import androidx.core.telecom.internal.CallStateEvent
import androidx.core.telecom.internal.JetpackConnectionService
-import androidx.core.telecom.internal.PreCallEndpoints
-import androidx.core.telecom.internal.utils.AudioManagerUtil.Companion.getAvailableAudioDevices
-import androidx.core.telecom.internal.utils.EndpointUtils.Companion.getEndpointsFromAudioDeviceInfo
+import androidx.core.telecom.internal.PreCallEndpointsUpdater
import androidx.core.telecom.internal.utils.Utils
import androidx.core.telecom.internal.utils.Utils.Companion.remapJetpackCapsToPlatformCaps
import androidx.core.telecom.util.ExperimentalAppActions
@@ -356,56 +353,38 @@
}
/**
- * Continuously stream the available call audio endpoints that can be used for a new call
- * session. The [callbackFlow] should be cleaned up client-side by calling cancel() from the
- * same [kotlinx.coroutines.CoroutineScope] the [callbackFlow] is collecting in.
+ * Continuously streams available call audio endpoints that can be used for a new call session.
+ * This API leverages [callbackFlow] to emit updates as the available audio endpoints change.
*
- * Note: The endpoints emitted will be sorted by the [CallEndpointCompat.type] . See
- * [CallEndpointCompat.compareTo] for the ordering. The first element in the list will be the
- * recommended call endpoint to default to for the user.
+ * **Bluetooth Permissions:** The [android.Manifest.permission.BLUETOOTH_CONNECT] runtime
+ * permission is essential when multiple bluetooth devices are connected. Granting this
+ * permission allows the API to display the names of multiple connected Bluetooth devices.
+ * Without this permission, only the active Bluetooth device will be surfaced.
*
- * @return a flow of [CallEndpointCompat]s that can be used for a new call session
+ * **Coroutine Usage and Cleanup:** The returned [Flow] from this [callbackFlow] should be
+ * collected within a [kotlinx.coroutines.CoroutineScope]. To properly manage resources and
+ * prevent leaks, ensure that the [Flow] is cancelled when it's no longer needed. This can be
+ * achieved by calling `cancel()` on the [kotlinx.coroutines.Job] of the collecting
+ * [kotlinx.coroutines.CoroutineScope]. Ideally, this cleanup should occur within the same scope
+ * where the [Flow] is being collected.
+ *
+ * @return A [Flow] that continuously emits a list of available [CallEndpointCompat]s.
*/
public fun getAvailableStartingCallEndpoints(): Flow<List<CallEndpointCompat>> = callbackFlow {
val id: Int = CallEndpointUuidTracker.startSession()
- val audioManager = mContext.getSystemService(Context.AUDIO_SERVICE) as AudioManager
- // [AudioDeviceInfo] <-- AudioManager / platform
- val initialAudioDevices = getAvailableAudioDevices(audioManager)
- // [CallEndpoints] <-- [AudioDeviceInfo]
- val initialEndpoints = getEndpointsFromAudioDeviceInfo(mContext, id, initialAudioDevices)
// The emitted endpoints need to be tracked so that when the device list changes,
// the added or removed endpoints can be re-emitted as a whole list. Otherwise, only
// the added or removed endpoints will be emitted.
- val preCallEndpoints = PreCallEndpoints(initialEndpoints.toMutableList(), this.channel)
+ val callEndpointsUpdater = PreCallEndpointsUpdater(mSendChannel = this.channel)
// register an audio callback that will listen for updates
- val audioDeviceCallback =
- object : AudioDeviceCallback() {
- override fun onAudioDevicesAdded(addedDevices: Array<out AudioDeviceInfo>?) {
- if (addedDevices != null) {
- preCallEndpoints.endpointsAddedUpdate(
- getEndpointsFromAudioDeviceInfo(mContext, id, addedDevices.toList())
- )
- }
- }
-
- override fun onAudioDevicesRemoved(removedDevices: Array<out AudioDeviceInfo>?) {
- if (removedDevices != null) {
- preCallEndpoints.endpointsRemovedUpdate(
- getEndpointsFromAudioDeviceInfo(mContext, id, removedDevices.toList())
- )
- }
- }
- }
- // The following callback is needed in the event the user connects or disconnects
- // and audio device after this API is called.
- audioManager.registerAudioDeviceCallback(audioDeviceCallback, null /*handler*/)
- // Send the initial list of pre-call [CallEndpointCompat]s out to the client. They
- // will be emitted and cached in the Flow & only consumed once the client has
- // collected it.
- trySend(initialEndpoints)
+ val audioDeviceListener = AudioDeviceListener(mContext, callEndpointsUpdater, id)
+ // register a bluetooth listener to surface connected bluetooth devices instead of just
+ // the active bluetooth device
+ val bluetoothProfileListener = BluetoothProfileListener(mContext, callEndpointsUpdater, id)
awaitClose {
Log.i(TAG, "getAvailableStartingCallEndpoints: awaitClose")
- audioManager.unregisterAudioDeviceCallback(audioDeviceCallback)
+ bluetoothProfileListener.close()
+ audioDeviceListener.close()
CallEndpointUuidTracker.endSession(id)
}
}
diff --git a/core/core-telecom/src/main/java/androidx/core/telecom/internal/AudioDeviceListener.kt b/core/core-telecom/src/main/java/androidx/core/telecom/internal/AudioDeviceListener.kt
new file mode 100644
index 0000000..aab87a6
--- /dev/null
+++ b/core/core-telecom/src/main/java/androidx/core/telecom/internal/AudioDeviceListener.kt
@@ -0,0 +1,72 @@
+/*
+ * Copyright 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package androidx.core.telecom.internal
+
+import android.content.Context
+import android.media.AudioDeviceCallback
+import android.media.AudioDeviceInfo
+import android.media.AudioManager
+import android.os.Build
+import androidx.annotation.RequiresApi
+import androidx.core.telecom.internal.utils.AudioManagerUtil.Companion.getAvailableAudioDevices
+import androidx.core.telecom.internal.utils.EndpointUtils.Companion.getEndpointsFromAudioDeviceInfo
+
+/**
+ * This class is responsible for getting [AudioDeviceInfo]s from the [AudioManager] pre-call and
+ * emitting them to the [PreCallEndpointsUpdater] as [androidx.core.telecom.CallEndpointCompat]s
+ */
+@RequiresApi(Build.VERSION_CODES.O)
+internal class AudioDeviceListener(
+ val mContext: Context,
+ val mPreCallEndpoints: PreCallEndpointsUpdater,
+ private val mUuidSessionId: Int
+) : AutoCloseable, AudioDeviceCallback() {
+ val mAudioManager = mContext.getSystemService(Context.AUDIO_SERVICE) as AudioManager
+
+ init {
+ // [AudioDeviceInfo] <-- AudioManager / platform
+ val initialAudioDevices = getAvailableAudioDevices(mAudioManager)
+ // [CallEndpoints] <-- [AudioDeviceInfo]
+ val initialEndpoints =
+ getEndpointsFromAudioDeviceInfo(mContext, mUuidSessionId, initialAudioDevices)
+ mAudioManager.registerAudioDeviceCallback(this, null /*handler*/)
+ // Send the initial list of pre-call [CallEndpointCompat]s out to the client. They
+ // will be emitted and cached in the Flow & only consumed once the client has
+ // collected it.
+ mPreCallEndpoints.endpointsAddedUpdate(initialEndpoints)
+ }
+
+ override fun close() {
+ mAudioManager.unregisterAudioDeviceCallback(this)
+ }
+
+ override fun onAudioDevicesAdded(addedDevices: Array<out AudioDeviceInfo>?) {
+ if (addedDevices != null) {
+ mPreCallEndpoints.endpointsAddedUpdate(
+ getEndpointsFromAudioDeviceInfo(mContext, mUuidSessionId, addedDevices.toList())
+ )
+ }
+ }
+
+ override fun onAudioDevicesRemoved(removedDevices: Array<out AudioDeviceInfo>?) {
+ if (removedDevices != null) {
+ mPreCallEndpoints.endpointsRemovedUpdate(
+ getEndpointsFromAudioDeviceInfo(mContext, mUuidSessionId, removedDevices.toList())
+ )
+ }
+ }
+}
diff --git a/core/core-telecom/src/main/java/androidx/core/telecom/internal/BluetoothProfileListener.kt b/core/core-telecom/src/main/java/androidx/core/telecom/internal/BluetoothProfileListener.kt
new file mode 100644
index 0000000..529d205
--- /dev/null
+++ b/core/core-telecom/src/main/java/androidx/core/telecom/internal/BluetoothProfileListener.kt
@@ -0,0 +1,170 @@
+/*
+ * Copyright 2024 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package androidx.core.telecom.internal
+
+import android.bluetooth.BluetoothAdapter
+import android.bluetooth.BluetoothDevice
+import android.bluetooth.BluetoothManager
+import android.bluetooth.BluetoothProfile
+import android.content.Context
+import android.os.Build
+import android.util.Log
+import androidx.annotation.RequiresApi
+import androidx.core.telecom.CallEndpointCompat
+import androidx.core.telecom.internal.utils.EndpointUtils
+
+/**
+ * This class is responsible for getting [BluetoothProfile]s from the [BluetoothManager] pre-call
+ * and emitting them to the [PreCallEndpointsUpdater] as [androidx.core.telecom.CallEndpointCompat]s
+ */
+@RequiresApi(Build.VERSION_CODES.O)
+internal class BluetoothProfileListener(
+ context: Context,
+ private val mPreCallEndpointsUpdater: PreCallEndpointsUpdater,
+ private val mUuidSessionId: Int,
+) : BluetoothProfile.ServiceListener, AutoCloseable {
+ /** Constants used for this class */
+ companion object {
+ private val TAG: String = BluetoothProfileListener::class.java.simpleName
+ private val BLUETOOTH_PROFILES =
+ listOf(
+ BluetoothProfile.HEADSET,
+ BluetoothProfile.LE_AUDIO,
+ BluetoothProfile.HEARING_AID
+ )
+ }
+
+ /** Managers used for this class */
+ private val mBluetoothManager: BluetoothManager? =
+ context.getSystemService(Context.BLUETOOTH_SERVICE) as BluetoothManager
+ private val mBluetoothAdapter: BluetoothAdapter? = mBluetoothManager?.adapter
+
+ /**
+ * Internal class tracking. Need to track the endpoints so that when a profile is disconnected,
+ * the client can be informed. Also, for cleanup purposes, the proxy should be tracked to close
+ * when the pre-call endpoints API job is cancelled.
+ */
+ private data class ProfileData(
+ val endpoints: MutableList<CallEndpointCompat>?,
+ val proxy: BluetoothProfile?
+ )
+
+ private val mProfileToData: HashMap<Int, ProfileData> = HashMap()
+
+ /** On class init, get the proxies in order for the profile service connection to establish */
+ init {
+ getBluetoothProfileProxies(context)
+ }
+
+ /** When the listener is destroyed, close the proxies that were connected */
+ override fun close() {
+ Log.i(TAG, "close: uuidSessionId=[$mUuidSessionId]")
+ closeBluetoothProfileProxies()
+ }
+
+ private fun getBluetoothProfileProxies(context: Context) {
+ BLUETOOTH_PROFILES.forEach { profile ->
+ runCatching {
+ val hasProxy = mBluetoothAdapter?.getProfileProxy(context, this, profile)
+ Log.d(TAG, "gBPP: btProfile=[$profile] isConnect=[$hasProxy]")
+ }
+ .onFailure { e ->
+ Log.e(TAG, "gBPP: hit exception while getting bluetooth profile=[$profile]", e)
+ }
+ }
+ }
+
+ private fun closeBluetoothProfileProxies() {
+ mProfileToData.entries
+ .filter { (_, profileData) -> profileData.proxy != null }
+ .forEach { (profile, profileData) ->
+ runCatching { mBluetoothAdapter?.closeProfileProxy(profile, profileData.proxy) }
+ .onFailure { e ->
+ Log.e(
+ TAG,
+ "cBPP: hit exception when closing proxy for profile=[$profile]",
+ e
+ )
+ }
+ }
+ }
+
+ override fun onServiceConnected(profile: Int, proxy: BluetoothProfile?) {
+ Log.i(TAG, "onServiceConnected: profile=[$profile], proxy=[$proxy]")
+ val endpoints: MutableList<CallEndpointCompat> = ArrayList()
+ if (proxy != null) {
+ for (device in proxy.connectedDevices) {
+ endpoints.add(makeEndpoint(device))
+ }
+ }
+ // populate internal map for profile
+ mProfileToData[profile] = ProfileData(endpoints.toMutableList(), proxy)
+ // update client
+ mPreCallEndpointsUpdater.endpointsAddedUpdate(endpoints)
+ }
+
+ override fun onServiceDisconnected(profile: Int) {
+ Log.i(TAG, "onServiceDisconnected: profile=[$profile]")
+ val endpointsToRemove = mProfileToData[profile]?.endpoints ?: mutableListOf()
+ // clear internal map for profile
+ mProfileToData[profile] = ProfileData(mutableListOf(), null)
+ // update the client
+ mPreCallEndpointsUpdater.endpointsRemovedUpdate(endpointsToRemove.toList())
+ }
+
+ /**
+ * ============================================================================================
+ * Helpers
+ * ============================================================================================
+ */
+ private fun getBluetoothDeviceName(device: BluetoothDevice): String {
+ var name: String = EndpointUtils.BLUETOOTH_DEVICE_DEFAULT_NAME
+ try {
+ name = device.name
+ } catch (e: SecurityException) {
+ Log.e(TAG, "getBluetoothDeviceName: hit SecurityException while getting device name", e)
+ }
+ return name
+ }
+
+ private fun getBluetoothDeviceAddress(device: BluetoothDevice): String {
+ var address: String = CallEndpointCompat.UNKNOWN_MAC_ADDRESS
+ try {
+ address = device.address
+ } catch (e: Exception) {
+ Log.e(TAG, "getBluetoothDeviceAddress: hit exception while getting device address", e)
+ }
+ return address
+ }
+
+ private fun makeEndpoint(device: BluetoothDevice): CallEndpointCompat {
+ val bluetoothDeviceName = getBluetoothDeviceName(device)
+ val uuidForBluetoothDevice =
+ CallEndpointUuidTracker.getUuid(
+ mUuidSessionId,
+ CallEndpointCompat.TYPE_BLUETOOTH,
+ bluetoothDeviceName
+ )
+ val callEndpoint =
+ CallEndpointCompat(
+ bluetoothDeviceName,
+ CallEndpointCompat.TYPE_BLUETOOTH,
+ uuidForBluetoothDevice
+ )
+ callEndpoint.mMackAddress = getBluetoothDeviceAddress(device)
+ return callEndpoint
+ }
+}
diff --git a/core/core-telecom/src/main/java/androidx/core/telecom/internal/CallSession.kt b/core/core-telecom/src/main/java/androidx/core/telecom/internal/CallSession.kt
index a96b470..9bbd6eb 100644
--- a/core/core-telecom/src/main/java/androidx/core/telecom/internal/CallSession.kt
+++ b/core/core-telecom/src/main/java/androidx/core/telecom/internal/CallSession.kt
@@ -134,7 +134,7 @@
platformEndpoint.endpointType,
jetpackUuid
)
- Log.d(TAG, " n=[${platformEndpoint.endpointName}] plat=[${platformEndpoint}] --> jet=[$j]")
+ Log.i(TAG, " n=[${platformEndpoint.endpointName}] plat=[${platformEndpoint}] --> jet=[$j]")
return j
}
diff --git a/core/core-telecom/src/main/java/androidx/core/telecom/internal/PreCallEndpoints.kt b/core/core-telecom/src/main/java/androidx/core/telecom/internal/PreCallEndpointsUpdater.kt
similarity index 95%
rename from core/core-telecom/src/main/java/androidx/core/telecom/internal/PreCallEndpoints.kt
rename to core/core-telecom/src/main/java/androidx/core/telecom/internal/PreCallEndpointsUpdater.kt
index d04b339..837d51c 100644
--- a/core/core-telecom/src/main/java/androidx/core/telecom/internal/PreCallEndpoints.kt
+++ b/core/core-telecom/src/main/java/androidx/core/telecom/internal/PreCallEndpointsUpdater.kt
@@ -24,18 +24,17 @@
import kotlinx.coroutines.channels.SendChannel
@RequiresApi(Build.VERSION_CODES.O)
-internal class PreCallEndpoints(
- var mCurrentDevices: MutableList<CallEndpointCompat>,
+internal class PreCallEndpointsUpdater(
+ var mCurrentDevices: MutableList<CallEndpointCompat> = mutableListOf(),
var mSendChannel: SendChannel<List<CallEndpointCompat>>
) {
// earpiece, speaker, unknown, wired_headset
val mNonBluetoothEndpoints: HashMap<Int, CallEndpointCompat> = HashMap()
-
// all bt endpoints
val mBluetoothEndpoints: HashMap<String, CallEndpointCompat> = HashMap()
companion object {
- private val TAG: String = PreCallEndpoints::class.java.simpleName.toString()
+ private val TAG: String = PreCallEndpointsUpdater::class.java.simpleName.toString()
// endpoints added constants
const val ALREADY_TRACKING_ENDPOINT: Int = 0
diff --git a/development/importMaven/src/main/kotlin/androidx/build/importMaven/ArtifactResolver.kt b/development/importMaven/src/main/kotlin/androidx/build/importMaven/ArtifactResolver.kt
index 185d6ac..d4c4c46 100644
--- a/development/importMaven/src/main/kotlin/androidx/build/importMaven/ArtifactResolver.kt
+++ b/development/importMaven/src/main/kotlin/androidx/build/importMaven/ArtifactResolver.kt
@@ -213,9 +213,9 @@
val artifacts = resolutionList.flatMap { resolution ->
resolution.artifacts
}
- val dependenciesPassedVerification = resolutionList.map { resolution ->
+ val dependenciesPassedVerification = resolutionList.all { resolution ->
resolution.dependenciesPassedVerification
- }.all { it == true }
+ }
return ArtifactsResolutionResult(artifacts, dependenciesPassedVerification)
}
diff --git a/development/importMaven/src/main/kotlin/androidx/build/importMaven/MavenRepositoryProxy.kt b/development/importMaven/src/main/kotlin/androidx/build/importMaven/MavenRepositoryProxy.kt
index 85568ab..7318bc3 100644
--- a/development/importMaven/src/main/kotlin/androidx/build/importMaven/MavenRepositoryProxy.kt
+++ b/development/importMaven/src/main/kotlin/androidx/build/importMaven/MavenRepositoryProxy.kt
@@ -102,11 +102,13 @@
server.resolvedConnectors().first().let {
URL(
it.type.name.lowercase(),
- it.host,
+ // Always use `localhost` for local loopback given this is secure for `http` URLs.
+ "localhost",
it.port,
""
)
- URI("${it.type.name.lowercase()}://${it.host}:${it.port}")
+ // Always use `localhost` for local loopback given this is secure for `http` URIs.
+ URI("${it.type.name.lowercase()}://localhost:${it.port}")
}
}
block(url)
diff --git a/development/importMaven/src/test/kotlin/androidx/build/importMaven/ImportVersionCatalogTest.kt b/development/importMaven/src/test/kotlin/androidx/build/importMaven/ImportVersionCatalogTest.kt
index b80401b..a8b7238c 100644
--- a/development/importMaven/src/test/kotlin/androidx/build/importMaven/ImportVersionCatalogTest.kt
+++ b/development/importMaven/src/test/kotlin/androidx/build/importMaven/ImportVersionCatalogTest.kt
@@ -17,7 +17,6 @@
package androidx.build.importMaven
import com.google.common.truth.Truth.assertThat
-import okio.FileSystem
import org.junit.Test
class ImportVersionCatalogTest {
@@ -29,7 +28,6 @@
fun load() {
val path = EnvironmentConfig.supportRoot.resolve("gradle/libs.versions.toml")
val versions = ImportVersionCatalog.load(
- FileSystem.SYSTEM,
path
)
assertThat(
diff --git a/development/update_studio.sh b/development/update_studio.sh
index d4b0ff3..d0ff902 100755
--- a/development/update_studio.sh
+++ b/development/update_studio.sh
@@ -15,8 +15,8 @@
# Versions that the user should update when running this script
echo Getting Studio version and link
-AGP_VERSION=${1:-8.9.0-alpha01}
-STUDIO_VERSION_STRING=${2:-"Android Studio Meerkat | 2024.3.1 Canary 1"}
+AGP_VERSION=${1:-8.9.0-alpha06}
+STUDIO_VERSION_STRING=${2:-"Android Studio Meerkat | 2024.3.1 Canary 6"}
# Get studio version number from version name
STUDIO_IFRAME_LINK=`curl "https://developer.android.com/studio/archive.html" | grep "<iframe " | sed "s/.* src=\"\([^\"]*\)\".*/\1/g"`
diff --git a/gradle/libs.versions.toml b/gradle/libs.versions.toml
index 510a96e..7012d9e 100644
--- a/gradle/libs.versions.toml
+++ b/gradle/libs.versions.toml
@@ -2,13 +2,13 @@
# -----------------------------------------------------------------------------
# All of the following should be updated in sync.
# -----------------------------------------------------------------------------
-androidGradlePlugin = "8.9.0-alpha01"
+androidGradlePlugin = "8.9.0-alpha06"
# NOTE: When updating the lint version we also need to update the `api` version
# supported by `IssueRegistry`'s.' For e.g. r.android.com/1331903
-androidLint = "31.9.0-alpha01"
+androidLint = "31.9.0-alpha06"
# Once you have a chosen version of AGP to upgrade to, go to
# https://developer.android.com/studio/archive and find the matching version of Studio.
-androidStudio = "2024.3.1.1"
+androidStudio = "2024.3.1.6"
# -----------------------------------------------------------------------------
androidLintMin = "31.1.0"
diff --git a/gradle/verification-keyring.keys b/gradle/verification-keyring.keys
index 322947c..b9e6596 100644
--- a/gradle/verification-keyring.keys
+++ b/gradle/verification-keyring.keys
@@ -4081,6 +4081,40 @@
=Q+9k
-----END PGP PUBLIC KEY BLOCK-----
+pub EB095DA7D2F6AC0E
+sub 603D72C90616CD6B
+-----BEGIN PGP PUBLIC KEY BLOCK-----
+Version: BCPG v@RELEASE_NAME@
+
+mQGNBGBm/LQBDADMr/VPcTvE6k3wEYxq5kZusnDCDTsI6RK51d4oMwaRc3Z0jtZ0
+CfyWocZBok4rMbZAVnE3Q8pMyikGGUnc8ZsWoPEmJyCpw/2Orj0QqZhIgYMQ31Uq
+tiGZF/G4w9phLIkFgU9BLGYjRNM69R0oE/Tj8mjguvnKzYM3GjkY6nDsgWCM5TJX
+01k4sdLs0dVg86m4keq+SeS9uEwnINZTh6kQUKsW6aHvvPXze/UPoaZqxgXDjF+F
+JrPwW8yDllkbzpbo53ulz1TL5RsIH3daUwxXG3ciovUXG/b2ZRuWjtH7Gn/AvCNL
+0RXdHK3A2I23zCooOE+we2D45QUHm/vcmvsnbxOU7Tslm2DsnYxBjf5dAl2yZn+J
+FSrV91Bbd5ZXi1UkkGjBzAgbHDwdMvL9K6fTO9NwjXyBpiHy6ukIOObn9uIgDSSa
+xPnqgeykSv+RZEea8ML4BSif5RJYlmILEzJhH4rtX9X+t8BZv+ZoaN6p/qYg4/2+
+XfSUPmCJjlUaIUUAEQEAAbkBjQRgZvy0AQwAtuysL4l1wLjDIgva/+mD76cekxRu
+54s7zYOkh/87NIZ6tPkPlw/w+m7CEohurx2sQSPrClJoaMqxlPgRCmmj5JQVEC79
+9pkvJZb+QwslD57P84LYntiqpr+nmmR6vgDlZxaiRa6OVUllUTYwDpHcQ8MocXan
+e4iAea99acxL60zOimPeaPVK9tXZQ1nKPVIWs6RSYna54FFZn0uXfG4Qx8xEAXYd
+cUj5oEh4JFtEcP+55YVWopfi+zIQwwJ7JaO6ZZhHco4OpCwTauB/hX2SVdSijV32
+O9IhHXO3xPIi+5RC/iwHrhF3kexNLlfVWMnb/RWC7ROQXdUEK4YQGLy7+dFd7lKQ
+5gbUoAhuqWOnHyaSAyNlFGum3FR5oroad0eKS5jzk2n4UMPNDAoo7yEi1cdCrykD
+Jeb1GQD6ucQx+oqLkc1OGwqVjJU3FDQj/yvSCPKmst9lSGS3JH9l6ac033Db2qAP
+kUxnhw2xN4LHk2Ioovn5SZu1IUzH8/i+HhpfABEBAAGJAbYEGAEKACAWIQR0QPH3
+0nusEV+VPVXrCV2n0vasDgUCYGb8tAIbDAAKCRDrCV2n0vasDkSBC/91fDW0V6U8
+pRwW6HFruAnq/0uQ2gISrmDlpJzsgSO6HQQfho1T/7uuYhnBGyU4dxIF4G9A+Ehh
+2iwhB90JzCNLstTW6ueSWMK+4hvBpfx3kCbs2oxu0z8ZHroxE9I7e5XqDQOazANn
+eLRZJ5SArg1dFGYveBRlyjE55CmDQyj58aJkMbLAAJrdrMkFZHwbeBKOs3ph0zn5
+NvSBDUP8A3wlUXuSySeXYCUIj2k4Q6zJodnhP76ivfpu0eZn4UnD0sI8YdoJOsNK
+gDRO6fR9kEEh/XGY082B1Ad6tO2nea1MIVF0GIgfh3ezd3YcG4Rip0uqIPr7yxpT
+mVEA8wVvpWg8+wY2/xvLuHtZD59bK4KlQ9m+4W5WhursrdUfSI2EuXNp7xYwNRVf
+elApmsOOWqONqWg4leirxkWUMz7XDArDPuei4Qk8VF4/0yfGOVSh8VHQrIauzqrN
+p4LbYC9sii1fqxQTFVGPPhv6Wujd/eUuUeURZbKgpHIfniDXLiaTUyc=
+=aMmv
+-----END PGP PUBLIC KEY BLOCK-----
+
pub EB380DC13C39F675
uid Mark Vedder <[email protected]>
diff --git a/gradle/verification-metadata.xml b/gradle/verification-metadata.xml
index 5f5b0c8..c5a4c74 100644
--- a/gradle/verification-metadata.xml
+++ b/gradle/verification-metadata.xml
@@ -316,6 +316,7 @@
<trusted-key id="719F7C29985A8E95F58F47194D8159D6A1159B69" group="dev.zacsweers.moshix"/>
<trusted-key id="720746177725A89207A7075BFD5DEA07FCB690A8" group="org.codehaus.mojo"/>
<trusted-key id="73976C9C39C1479B84E2641A5A68A2249128E2C6" group="com.google.crypto.tink" name="tink-android"/>
+ <trusted-key id="7440F1F7D27BAC115F953D55EB095DA7D2F6AC0E" group="org.tensorflow"/>
<trusted-key id="748F15B2CF9BA8F024155E6ED7C92B70FA1C814D" group="org.apache.logging.log4j"/>
<trusted-key id="7615AD56144DF2376F49D98B1669C4BB543E0445" group="com.google.errorprone"/>
<trusted-key id="7616EB882DAF57A11477AAF559A252FB1199D873" group="com.google.code.findbugs"/>
diff --git a/health/connect/connect-client/src/main/java/androidx/health/connect/client/HealthConnectFeatures.kt b/health/connect/connect-client/src/main/java/androidx/health/connect/client/HealthConnectFeatures.kt
index 426ed81..6bb354f 100644
--- a/health/connect/connect-client/src/main/java/androidx/health/connect/client/HealthConnectFeatures.kt
+++ b/health/connect/connect-client/src/main/java/androidx/health/connect/client/HealthConnectFeatures.kt
@@ -89,14 +89,14 @@
mapOf(
FEATURE_READ_HEALTH_DATA_IN_BACKGROUND to
HealthConnectVersionInfo(
- apkVersionCode = 165072,
+ apkVersionCode = 171302,
platformVersion = SDK_EXT_13_PLATFORM_VERSION
),
FEATURE_SKIN_TEMPERATURE to
HealthConnectVersionInfo(platformVersion = SDK_EXT_13_PLATFORM_VERSION),
FEATURE_READ_HEALTH_DATA_HISTORY to
HealthConnectVersionInfo(
- apkVersionCode = 165072,
+ apkVersionCode = 171302,
platformVersion = SDK_EXT_13_PLATFORM_VERSION
),
FEATURE_PLANNED_EXERCISE to
diff --git a/libraryversions.toml b/libraryversions.toml
index 0b26c3d..ae5da12 100644
--- a/libraryversions.toml
+++ b/libraryversions.toml
@@ -19,8 +19,8 @@
CAMERA_TESTING = "1.0.0-alpha01"
CAMERA_VIEWFINDER = "1.4.0-alpha12"
CARDVIEW = "1.1.0-alpha01"
-CAR_APP = "1.7.0-beta03"
-COLLECTION = "1.5.0-beta01"
+CAR_APP = "1.7.0-rc01"
+COLLECTION = "1.5.0-beta02"
COMPOSE = "1.8.0-alpha08"
COMPOSE_MATERIAL3 = "1.4.0-alpha05"
COMPOSE_MATERIAL3_ADAPTIVE = "1.1.0-alpha08"
diff --git a/media/version-compat-tests/current/client/src/androidTest/java/android/support/mediacompat/client/AudioAttributesCompatTest.java b/media/version-compat-tests/current/client/src/androidTest/java/android/support/mediacompat/client/AudioAttributesCompatTest.java
index cfdb229..8229f75 100644
--- a/media/version-compat-tests/current/client/src/androidTest/java/android/support/mediacompat/client/AudioAttributesCompatTest.java
+++ b/media/version-compat-tests/current/client/src/androidTest/java/android/support/mediacompat/client/AudioAttributesCompatTest.java
@@ -178,6 +178,7 @@
}
@Test
+ @SdkSuppress(maxSdkVersion = 34) // b/384972088: Failing on SDK 35
public void testUsageAndContentTypeInferredFromLegacyStreamType() {
androidx.media.AudioAttributesCompat alarmAAC =
mkBuilder(AudioManager.STREAM_ALARM).build();
diff --git a/media/version-compat-tests/previous/client/src/androidTest/java/android/support/mediacompat/client/AudioAttributesCompatTest.java b/media/version-compat-tests/previous/client/src/androidTest/java/android/support/mediacompat/client/AudioAttributesCompatTest.java
index 6cc962e..03e0c38 100644
--- a/media/version-compat-tests/previous/client/src/androidTest/java/android/support/mediacompat/client/AudioAttributesCompatTest.java
+++ b/media/version-compat-tests/previous/client/src/androidTest/java/android/support/mediacompat/client/AudioAttributesCompatTest.java
@@ -165,6 +165,7 @@
}
@Test
+ @SdkSuppress(maxSdkVersion = 34) // b/384972088: Failing on SDK 35
public void testUsageAndContentTypeInferredFromLegacyStreamType() {
AudioAttributesCompat alarmAAC = mkBuilder(AudioManager.STREAM_ALARM).build();
assertThat(alarmAAC.getUsage(), equalTo(AudioAttributesCompat.USAGE_ALARM));
diff --git a/navigation/navigation-runtime/src/androidTest/java/androidx/navigation/ActivityNavigatorTest.kt b/navigation/navigation-runtime/src/androidTest/java/androidx/navigation/ActivityNavigatorTest.kt
index 98bf240..083e89c 100644
--- a/navigation/navigation-runtime/src/androidTest/java/androidx/navigation/ActivityNavigatorTest.kt
+++ b/navigation/navigation-runtime/src/androidTest/java/androidx/navigation/ActivityNavigatorTest.kt
@@ -25,6 +25,7 @@
import android.os.Bundle
import android.view.View
import androidx.core.app.ActivityOptionsCompat
+import androidx.savedstate.SavedState
import androidx.test.annotation.UiThreadTest
import androidx.test.ext.junit.runners.AndroidJUnit4
import androidx.test.filters.LargeTest
@@ -247,6 +248,47 @@
}
@Test
+ fun navigateDataPatternIntWithNavType() {
+ val navType =
+ object : NavType<Int>(false) {
+ override fun put(bundle: SavedState, key: String, value: Int) {
+ IntType.put(bundle, key, value)
+ }
+
+ override fun get(bundle: SavedState, key: String): Int? = IntType[bundle, key]
+
+ override fun parseValue(value: String): Int =
+ value.replace("Serialized", "").toInt()
+
+ override fun serializeAsValue(value: Int): String = "${value}Serialized"
+ }
+ val targetDestination =
+ activityNavigator.createDestination().apply {
+ id = TARGET_ID
+ setDataPattern(TARGET_DATA_PATTERN)
+ setComponentName(ComponentName(activityRule.activity, TargetActivity::class.java))
+ addArgument(TARGET_ARGUMENT_NAME, NavArgument.Builder().setType(navType).build())
+ }
+ val args = Bundle().apply { putInt(TARGET_ARGUMENT_NAME, TARGET_ARGUMENT_INT_VALUE) }
+ activityNavigator.navigate(targetDestination, args, null, null)
+
+ val targetActivity = waitForActivity()
+ val intent = targetActivity.intent
+ assertThat(intent).isNotNull()
+ assertWithMessage("Intent should have data set with argument filled in")
+ .that(intent.data?.toString())
+ .isEqualTo(
+ TARGET_DATA_PATTERN.replace(
+ "{$TARGET_ARGUMENT_NAME}",
+ "${TARGET_ARGUMENT_INT_VALUE}Serialized"
+ )
+ )
+ assertWithMessage("Intent should have its arguments in its extras")
+ .that(intent.getIntExtra(TARGET_ARGUMENT_NAME, -1))
+ .isEqualTo(TARGET_ARGUMENT_INT_VALUE)
+ }
+
+ @Test
fun navigateDataPatternMissingArgument() {
val targetDestination =
activityNavigator.createDestination().apply {
diff --git a/navigation/navigation-runtime/src/main/java/androidx/navigation/ActivityNavigator.kt b/navigation/navigation-runtime/src/main/java/androidx/navigation/ActivityNavigator.kt
index 3ab7bd0..4fb24ac 100644
--- a/navigation/navigation-runtime/src/main/java/androidx/navigation/ActivityNavigator.kt
+++ b/navigation/navigation-runtime/src/main/java/androidx/navigation/ActivityNavigator.kt
@@ -93,14 +93,16 @@
val matcher = fillInPattern.matcher(dataPattern)
while (matcher.find()) {
val argName = matcher.group(1)
- if (args.containsKey(argName)) {
- matcher.appendReplacement(data, "")
- data.append(Uri.encode(args[argName].toString()))
- } else {
- throw IllegalArgumentException(
- "Could not find $argName in $args to fill data pattern $dataPattern"
- )
+ require(args.containsKey(argName)) {
+ "Could not find $argName in $args to fill data pattern $dataPattern"
}
+ matcher.appendReplacement(data, "")
+ // Serialize with NavType if present, otherwise fallback to toString()
+ val navType = destination.arguments[argName!!]?.type
+ val value =
+ navType?.serializeAsValue(navType[args, argName])
+ ?: Uri.encode(args[argName].toString())
+ data.append(value)
}
matcher.appendTail(data)
intent.data = Uri.parse(data.toString())
diff --git a/performance/performance-annotation/README.md b/performance/performance-annotation/README.md
index 2ab0c3d..b37c607 100644
--- a/performance/performance-annotation/README.md
+++ b/performance/performance-annotation/README.md
@@ -1 +1 @@
-This library is a **compile-time** only dependency.
+The annotation defined in this library only affects Android.
diff --git a/performance/performance-annotation/src/androidMain/kotlin/dalvik/annotation/optimization/NeverInline.android.kt b/performance/performance-annotation/src/androidMain/kotlin/dalvik/annotation/optimization/NeverInline.android.kt
index 50e22dc..a44f0ff 100644
--- a/performance/performance-annotation/src/androidMain/kotlin/dalvik/annotation/optimization/NeverInline.android.kt
+++ b/performance/performance-annotation/src/androidMain/kotlin/dalvik/annotation/optimization/NeverInline.android.kt
@@ -14,8 +14,10 @@
* limitations under the License.
*/
+@file:Suppress("RedundantVisibilityModifier")
+
package dalvik.annotation.optimization
@Retention(AnnotationRetention.BINARY)
@Target(AnnotationTarget.CONSTRUCTOR, AnnotationTarget.FUNCTION)
-public actual annotation class NeverInline()
+public actual annotation class NeverInline
diff --git a/performance/performance-annotation/src/commonMain/kotlin/dalvik/annotation/optimization/NeverInline.kt b/performance/performance-annotation/src/commonMain/kotlin/dalvik/annotation/optimization/NeverInline.kt
index 89cbfe3..99f736b 100644
--- a/performance/performance-annotation/src/commonMain/kotlin/dalvik/annotation/optimization/NeverInline.kt
+++ b/performance/performance-annotation/src/commonMain/kotlin/dalvik/annotation/optimization/NeverInline.kt
@@ -15,6 +15,7 @@
*/
@file:OptIn(ExperimentalMultiplatform::class)
+@file:Suppress("RedundantVisibilityModifier")
package dalvik.annotation.optimization
diff --git a/performance/performance-unsafe/README.md b/performance/performance-unsafe/README.md
index 6a22e41..b69d197 100644
--- a/performance/performance-unsafe/README.md
+++ b/performance/performance-unsafe/README.md
@@ -1,2 +1,2 @@
-This library is a **compile-time** only dependency for Android.
+This library is a dependency for Android only.
It is not to be used for other targets.
diff --git a/performance/performance-unsafe/src/main/resources/META-INF/proguard/unsafe.pro b/performance/performance-unsafe/src/main/resources/META-INF/proguard/unsafe.pro
new file mode 100644
index 0000000..d908c40
--- /dev/null
+++ b/performance/performance-unsafe/src/main/resources/META-INF/proguard/unsafe.pro
@@ -0,0 +1,3 @@
+-keep class sun.misc.Unsafe {
+ *;
+}
diff --git a/room/integration-tests/kotlintestapp/src/androidTest/java/androidx/room/integration/kotlintestapp/test/SuspendingQueryTest.kt b/room/integration-tests/kotlintestapp/src/androidTest/java/androidx/room/integration/kotlintestapp/test/SuspendingQueryTest.kt
index 05d1a91..3d67b8b 100644
--- a/room/integration-tests/kotlintestapp/src/androidTest/java/androidx/room/integration/kotlintestapp/test/SuspendingQueryTest.kt
+++ b/room/integration-tests/kotlintestapp/src/androidTest/java/androidx/room/integration/kotlintestapp/test/SuspendingQueryTest.kt
@@ -223,7 +223,7 @@
@Test
@Suppress("DEPRECATION")
- fun suspendingBlock_beginEndTransaction_blockingDaoMethods() {
+ fun suspendingBlock_beginEndTransaction_blockingDaoFunctions() {
runBlocking {
try {
database.beginTransaction()
@@ -266,7 +266,7 @@
}
@Test
- fun suspendingBlock_blockingDaoMethods() {
+ fun suspendingBlock_blockingDaoFunctions() {
runBlocking {
booksDao.insertPublisherSuspend(TestUtil.PUBLISHER.publisherId, TestUtil.PUBLISHER.name)
@@ -624,7 +624,7 @@
}
@Test
- fun withTransaction_blockingDaoMethods() {
+ fun withTransaction_blockingDaoFunctions() {
runBlocking {
database.withTransaction {
booksDao.insertPublisherSuspend(
@@ -641,7 +641,7 @@
}
@Test
- fun withTransaction_blockingDaoMethods_contextSwitch() {
+ fun withTransaction_blockingDaoFunctions_contextSwitch() {
runBlocking {
database.withTransaction {
// normal query
@@ -907,7 +907,7 @@
.addCallback(
object : RoomDatabase.Callback() {
override fun onOpen(db: SupportSQLiteDatabase) {
- // this causes all transaction methods to throw, this can happen IRL
+ // this causes all transaction functions to throw, this can happen IRL
throw RuntimeException("Error opening Database.")
}
}
diff --git a/room/room-common/api/current.ignore b/room/room-common/api/current.ignore
index e328ae6..a124e8c 100644
--- a/room/room-common/api/current.ignore
+++ b/room/room-common/api/current.ignore
@@ -1,4 +1,32 @@
// Baseline format: 1.0
+ChangedType: androidx.room.AutoMigration#spec():
+ Method androidx.room.AutoMigration.spec has changed return type from kotlin.reflect.KClass<?> to java.lang.Class<?>
+ChangedType: androidx.room.Database#entities():
+ Method androidx.room.Database.entities has changed return type from kotlin.reflect.KClass<?>[] to java.lang.Class<?>[]
+ChangedType: androidx.room.Database#views():
+ Method androidx.room.Database.views has changed return type from kotlin.reflect.KClass<?>[] to java.lang.Class<?>[]
+ChangedType: androidx.room.Delete#entity():
+ Method androidx.room.Delete.entity has changed return type from kotlin.reflect.KClass<?> to java.lang.Class<?>
+ChangedType: androidx.room.ForeignKey#entity():
+ Method androidx.room.ForeignKey.entity has changed return type from kotlin.reflect.KClass<?> to java.lang.Class<?>
+ChangedType: androidx.room.Fts4#contentEntity():
+ Method androidx.room.Fts4.contentEntity has changed return type from kotlin.reflect.KClass<?> to java.lang.Class<?>
+ChangedType: androidx.room.Insert#entity():
+ Method androidx.room.Insert.entity has changed return type from kotlin.reflect.KClass<?> to java.lang.Class<?>
+ChangedType: androidx.room.Junction#value():
+ Method androidx.room.Junction.value has changed return type from kotlin.reflect.KClass<?> to java.lang.Class<?>
+ChangedType: androidx.room.RawQuery#observedEntities():
+ Method androidx.room.RawQuery.observedEntities has changed return type from kotlin.reflect.KClass<?>[] to java.lang.Class<?>[]
+ChangedType: androidx.room.Relation#entity():
+ Method androidx.room.Relation.entity has changed return type from kotlin.reflect.KClass<?> to java.lang.Class<?>
+ChangedType: androidx.room.TypeConverters#value():
+ Method androidx.room.TypeConverters.value has changed return type from kotlin.reflect.KClass<?>[] to java.lang.Class<?>[]
+ChangedType: androidx.room.Update#entity():
+ Method androidx.room.Update.entity has changed return type from kotlin.reflect.KClass<?> to java.lang.Class<?>
+ChangedType: androidx.room.Upsert#entity():
+ Method androidx.room.Upsert.entity has changed return type from kotlin.reflect.KClass<?> to java.lang.Class<?>
+
+
ChangedValue: androidx.room.AutoMigration#spec():
Method androidx.room.AutoMigration.spec has changed value from java.lang.Object to Any::class
ChangedValue: androidx.room.Delete#entity():
diff --git a/room/room-common/api/current.txt b/room/room-common/api/current.txt
index 43dd4e3..262cfab 100644
--- a/room/room-common/api/current.txt
+++ b/room/room-common/api/current.txt
@@ -3,10 +3,10 @@
@kotlin.annotation.Retention(kotlin.annotation.AnnotationRetention.BINARY) @kotlin.annotation.Target(allowedTargets=kotlin.annotation.AnnotationTarget.CLASS) public @interface AutoMigration {
method public abstract int from();
- method public abstract kotlin.reflect.KClass<? extends java.lang.Object?> spec() default Any::class;
+ method public abstract Class<? extends java.lang.Object?> spec() default Any::class;
method public abstract int to();
property public abstract int from;
- property public abstract kotlin.reflect.KClass<? extends java.lang.Object?> spec;
+ property public abstract Class<? extends java.lang.Object?> spec;
property public abstract int to;
}
@@ -88,8 +88,8 @@
}
@kotlin.annotation.Retention(kotlin.annotation.AnnotationRetention.BINARY) @kotlin.annotation.Target(allowedTargets=kotlin.annotation.AnnotationTarget.CLASS) public @interface ConstructedBy {
- method public abstract kotlin.reflect.KClass<? extends java.lang.Object?> value();
- property public abstract kotlin.reflect.KClass<? extends java.lang.Object?> value;
+ method public abstract Class<? extends java.lang.Object?> value();
+ property public abstract Class<? extends java.lang.Object?> value;
}
@kotlin.annotation.Retention(kotlin.annotation.AnnotationRetention.BINARY) @kotlin.annotation.Target(allowedTargets=kotlin.annotation.AnnotationTarget.CLASS) public @interface Dao {
@@ -97,15 +97,15 @@
@kotlin.annotation.Retention(kotlin.annotation.AnnotationRetention.BINARY) @kotlin.annotation.Target(allowedTargets=kotlin.annotation.AnnotationTarget.CLASS) public @interface Database {
method public abstract androidx.room.AutoMigration[] autoMigrations();
- method public abstract kotlin.reflect.KClass<? extends java.lang.Object?>[] entities();
+ method public abstract Class<? extends java.lang.Object?>[] entities();
method public abstract boolean exportSchema() default true;
method public abstract int version();
- method public abstract kotlin.reflect.KClass<? extends java.lang.Object?>[] views();
+ method public abstract Class<? extends java.lang.Object?>[] views();
property public abstract androidx.room.AutoMigration[] autoMigrations;
- property public abstract kotlin.reflect.KClass<? extends java.lang.Object?>[] entities;
+ property public abstract Class<? extends java.lang.Object?>[] entities;
property public abstract boolean exportSchema;
property public abstract int version;
- property public abstract kotlin.reflect.KClass<? extends java.lang.Object?>[] views;
+ property public abstract Class<? extends java.lang.Object?>[] views;
}
@kotlin.annotation.Retention(kotlin.annotation.AnnotationRetention.BINARY) @kotlin.annotation.Target(allowedTargets=kotlin.annotation.AnnotationTarget.CLASS) public @interface DatabaseView {
@@ -116,8 +116,8 @@
}
@kotlin.annotation.Retention(kotlin.annotation.AnnotationRetention.BINARY) @kotlin.annotation.Target(allowedTargets=kotlin.annotation.AnnotationTarget.FUNCTION) public @interface Delete {
- method public abstract kotlin.reflect.KClass<? extends java.lang.Object?> entity() default Any::class;
- property public abstract kotlin.reflect.KClass<? extends java.lang.Object?> entity;
+ method public abstract Class<? extends java.lang.Object?> entity() default Any::class;
+ property public abstract Class<? extends java.lang.Object?> entity;
}
@java.lang.annotation.Repeatable(DeleteColumn.Entries::class) @kotlin.annotation.Retention(kotlin.annotation.AnnotationRetention.BINARY) @kotlin.annotation.Target(allowedTargets=kotlin.annotation.AnnotationTarget.CLASS) public @interface DeleteColumn {
@@ -165,13 +165,13 @@
@kotlin.annotation.Retention(kotlin.annotation.AnnotationRetention.BINARY) @kotlin.annotation.Target(allowedTargets={}) public @interface ForeignKey {
method public abstract String[] childColumns();
method public abstract boolean deferred() default false;
- method public abstract kotlin.reflect.KClass<? extends java.lang.Object?> entity();
+ method public abstract Class<? extends java.lang.Object?> entity();
method @androidx.room.ForeignKey.Action public abstract int onDelete() default androidx.room.ForeignKey.NO_ACTION;
method @androidx.room.ForeignKey.Action public abstract int onUpdate() default androidx.room.ForeignKey.NO_ACTION;
method public abstract String[] parentColumns();
property public abstract String[] childColumns;
property public abstract boolean deferred;
- property public abstract kotlin.reflect.KClass<? extends java.lang.Object?> entity;
+ property public abstract Class<? extends java.lang.Object?> entity;
property @androidx.room.ForeignKey.Action public abstract int onDelete;
property @androidx.room.ForeignKey.Action public abstract int onUpdate;
property public abstract String[] parentColumns;
@@ -207,7 +207,7 @@
}
@kotlin.annotation.Retention(kotlin.annotation.AnnotationRetention.BINARY) @kotlin.annotation.Target(allowedTargets=kotlin.annotation.AnnotationTarget.CLASS) public @interface Fts4 {
- method public abstract kotlin.reflect.KClass<? extends java.lang.Object?> contentEntity() default Any::class;
+ method public abstract Class<? extends java.lang.Object?> contentEntity() default Any::class;
method public abstract String languageId() default "";
method public abstract androidx.room.FtsOptions.MatchInfo matchInfo() default androidx.room.FtsOptions.MatchInfo.FTS4;
method public abstract String[] notIndexed();
@@ -215,7 +215,7 @@
method public abstract int[] prefix();
method public abstract String tokenizer() default androidx.room.FtsOptions.TOKENIZER_SIMPLE;
method public abstract String[] tokenizerArgs();
- property public abstract kotlin.reflect.KClass<? extends java.lang.Object?> contentEntity;
+ property public abstract Class<? extends java.lang.Object?> contentEntity;
property public abstract String languageId;
property public abstract androidx.room.FtsOptions.MatchInfo matchInfo;
property public abstract String[] notIndexed;
@@ -267,19 +267,19 @@
}
@kotlin.annotation.Retention(kotlin.annotation.AnnotationRetention.BINARY) @kotlin.annotation.Target(allowedTargets=kotlin.annotation.AnnotationTarget.FUNCTION) public @interface Insert {
- method public abstract kotlin.reflect.KClass<? extends java.lang.Object?> entity() default Any::class;
+ method public abstract Class<? extends java.lang.Object?> entity() default Any::class;
method @androidx.room.OnConflictStrategy public abstract int onConflict() default androidx.room.OnConflictStrategy.ABORT;
- property public abstract kotlin.reflect.KClass<? extends java.lang.Object?> entity;
+ property public abstract Class<? extends java.lang.Object?> entity;
property @androidx.room.OnConflictStrategy public abstract int onConflict;
}
@kotlin.annotation.Retention(kotlin.annotation.AnnotationRetention.BINARY) @kotlin.annotation.Target(allowedTargets={}) public @interface Junction {
method public abstract String entityColumn() default "";
method public abstract String parentColumn() default "";
- method public abstract kotlin.reflect.KClass<? extends java.lang.Object?> value();
+ method public abstract Class<? extends java.lang.Object?> value();
property public abstract String entityColumn;
property public abstract String parentColumn;
- property public abstract kotlin.reflect.KClass<? extends java.lang.Object?> value;
+ property public abstract Class<? extends java.lang.Object?> value;
}
@kotlin.annotation.Retention(kotlin.annotation.AnnotationRetention.BINARY) @kotlin.annotation.Target(allowedTargets=kotlin.annotation.AnnotationTarget.TYPE) public @interface MapColumn {
@@ -344,18 +344,18 @@
}
@kotlin.annotation.Retention(kotlin.annotation.AnnotationRetention.BINARY) @kotlin.annotation.Target(allowedTargets=kotlin.annotation.AnnotationTarget.FUNCTION) public @interface RawQuery {
- method public abstract kotlin.reflect.KClass<? extends java.lang.Object?>[] observedEntities();
- property public abstract kotlin.reflect.KClass<? extends java.lang.Object?>[] observedEntities;
+ method public abstract Class<? extends java.lang.Object?>[] observedEntities();
+ property public abstract Class<? extends java.lang.Object?>[] observedEntities;
}
@kotlin.annotation.Retention(kotlin.annotation.AnnotationRetention.BINARY) @kotlin.annotation.Target(allowedTargets={kotlin.annotation.AnnotationTarget.FIELD, kotlin.annotation.AnnotationTarget.FUNCTION}) public @interface Relation {
method public abstract androidx.room.Junction associateBy() default androidx.room.Junction(Any::class);
- method public abstract kotlin.reflect.KClass<? extends java.lang.Object?> entity() default Any::class;
+ method public abstract Class<? extends java.lang.Object?> entity() default Any::class;
method public abstract String entityColumn();
method public abstract String parentColumn();
method public abstract String[] projection();
property public abstract androidx.room.Junction associateBy;
- property public abstract kotlin.reflect.KClass<? extends java.lang.Object?> entity;
+ property public abstract Class<? extends java.lang.Object?> entity;
property public abstract String entityColumn;
property public abstract String parentColumn;
property public abstract String[] projection;
@@ -450,21 +450,21 @@
@kotlin.annotation.Retention(kotlin.annotation.AnnotationRetention.BINARY) @kotlin.annotation.Target(allowedTargets={kotlin.annotation.AnnotationTarget.FUNCTION, kotlin.annotation.AnnotationTarget.VALUE_PARAMETER, kotlin.annotation.AnnotationTarget.FIELD, kotlin.annotation.AnnotationTarget.CLASS}) public @interface TypeConverters {
method public abstract androidx.room.BuiltInTypeConverters builtInTypeConverters() default androidx.room.BuiltInTypeConverters();
- method public abstract kotlin.reflect.KClass<? extends java.lang.Object?>[] value();
+ method public abstract Class<? extends java.lang.Object?>[] value();
property public abstract androidx.room.BuiltInTypeConverters builtInTypeConverters;
- property public abstract kotlin.reflect.KClass<? extends java.lang.Object?>[] value;
+ property public abstract Class<? extends java.lang.Object?>[] value;
}
@kotlin.annotation.Retention(kotlin.annotation.AnnotationRetention.BINARY) @kotlin.annotation.Target(allowedTargets=kotlin.annotation.AnnotationTarget.FUNCTION) public @interface Update {
- method public abstract kotlin.reflect.KClass<? extends java.lang.Object?> entity() default Any::class;
+ method public abstract Class<? extends java.lang.Object?> entity() default Any::class;
method @androidx.room.OnConflictStrategy public abstract int onConflict() default androidx.room.OnConflictStrategy.ABORT;
- property public abstract kotlin.reflect.KClass<? extends java.lang.Object?> entity;
+ property public abstract Class<? extends java.lang.Object?> entity;
property @androidx.room.OnConflictStrategy public abstract int onConflict;
}
@kotlin.annotation.Retention(kotlin.annotation.AnnotationRetention.BINARY) @kotlin.annotation.Target(allowedTargets=kotlin.annotation.AnnotationTarget.FUNCTION) public @interface Upsert {
- method public abstract kotlin.reflect.KClass<? extends java.lang.Object?> entity() default Any::class;
- property public abstract kotlin.reflect.KClass<? extends java.lang.Object?> entity;
+ method public abstract Class<? extends java.lang.Object?> entity() default Any::class;
+ property public abstract Class<? extends java.lang.Object?> entity;
}
}
diff --git a/room/room-common/api/restricted_current.ignore b/room/room-common/api/restricted_current.ignore
index e328ae6..a124e8c 100644
--- a/room/room-common/api/restricted_current.ignore
+++ b/room/room-common/api/restricted_current.ignore
@@ -1,4 +1,32 @@
// Baseline format: 1.0
+ChangedType: androidx.room.AutoMigration#spec():
+ Method androidx.room.AutoMigration.spec has changed return type from kotlin.reflect.KClass<?> to java.lang.Class<?>
+ChangedType: androidx.room.Database#entities():
+ Method androidx.room.Database.entities has changed return type from kotlin.reflect.KClass<?>[] to java.lang.Class<?>[]
+ChangedType: androidx.room.Database#views():
+ Method androidx.room.Database.views has changed return type from kotlin.reflect.KClass<?>[] to java.lang.Class<?>[]
+ChangedType: androidx.room.Delete#entity():
+ Method androidx.room.Delete.entity has changed return type from kotlin.reflect.KClass<?> to java.lang.Class<?>
+ChangedType: androidx.room.ForeignKey#entity():
+ Method androidx.room.ForeignKey.entity has changed return type from kotlin.reflect.KClass<?> to java.lang.Class<?>
+ChangedType: androidx.room.Fts4#contentEntity():
+ Method androidx.room.Fts4.contentEntity has changed return type from kotlin.reflect.KClass<?> to java.lang.Class<?>
+ChangedType: androidx.room.Insert#entity():
+ Method androidx.room.Insert.entity has changed return type from kotlin.reflect.KClass<?> to java.lang.Class<?>
+ChangedType: androidx.room.Junction#value():
+ Method androidx.room.Junction.value has changed return type from kotlin.reflect.KClass<?> to java.lang.Class<?>
+ChangedType: androidx.room.RawQuery#observedEntities():
+ Method androidx.room.RawQuery.observedEntities has changed return type from kotlin.reflect.KClass<?>[] to java.lang.Class<?>[]
+ChangedType: androidx.room.Relation#entity():
+ Method androidx.room.Relation.entity has changed return type from kotlin.reflect.KClass<?> to java.lang.Class<?>
+ChangedType: androidx.room.TypeConverters#value():
+ Method androidx.room.TypeConverters.value has changed return type from kotlin.reflect.KClass<?>[] to java.lang.Class<?>[]
+ChangedType: androidx.room.Update#entity():
+ Method androidx.room.Update.entity has changed return type from kotlin.reflect.KClass<?> to java.lang.Class<?>
+ChangedType: androidx.room.Upsert#entity():
+ Method androidx.room.Upsert.entity has changed return type from kotlin.reflect.KClass<?> to java.lang.Class<?>
+
+
ChangedValue: androidx.room.AutoMigration#spec():
Method androidx.room.AutoMigration.spec has changed value from java.lang.Object to Any::class
ChangedValue: androidx.room.Delete#entity():
diff --git a/room/room-common/api/restricted_current.txt b/room/room-common/api/restricted_current.txt
index d2326d6..6cc5969 100644
--- a/room/room-common/api/restricted_current.txt
+++ b/room/room-common/api/restricted_current.txt
@@ -9,10 +9,10 @@
@kotlin.annotation.Retention(kotlin.annotation.AnnotationRetention.BINARY) @kotlin.annotation.Target(allowedTargets=kotlin.annotation.AnnotationTarget.CLASS) public @interface AutoMigration {
method public abstract int from();
- method public abstract kotlin.reflect.KClass<? extends java.lang.Object?> spec() default Any::class;
+ method public abstract Class<? extends java.lang.Object?> spec() default Any::class;
method public abstract int to();
property public abstract int from;
- property public abstract kotlin.reflect.KClass<? extends java.lang.Object?> spec;
+ property public abstract Class<? extends java.lang.Object?> spec;
property public abstract int to;
}
@@ -94,8 +94,8 @@
}
@kotlin.annotation.Retention(kotlin.annotation.AnnotationRetention.BINARY) @kotlin.annotation.Target(allowedTargets=kotlin.annotation.AnnotationTarget.CLASS) public @interface ConstructedBy {
- method public abstract kotlin.reflect.KClass<? extends java.lang.Object?> value();
- property public abstract kotlin.reflect.KClass<? extends java.lang.Object?> value;
+ method public abstract Class<? extends java.lang.Object?> value();
+ property public abstract Class<? extends java.lang.Object?> value;
}
@kotlin.annotation.Retention(kotlin.annotation.AnnotationRetention.BINARY) @kotlin.annotation.Target(allowedTargets=kotlin.annotation.AnnotationTarget.CLASS) public @interface Dao {
@@ -103,15 +103,15 @@
@kotlin.annotation.Retention(kotlin.annotation.AnnotationRetention.BINARY) @kotlin.annotation.Target(allowedTargets=kotlin.annotation.AnnotationTarget.CLASS) public @interface Database {
method public abstract androidx.room.AutoMigration[] autoMigrations();
- method public abstract kotlin.reflect.KClass<? extends java.lang.Object?>[] entities();
+ method public abstract Class<? extends java.lang.Object?>[] entities();
method public abstract boolean exportSchema() default true;
method public abstract int version();
- method public abstract kotlin.reflect.KClass<? extends java.lang.Object?>[] views();
+ method public abstract Class<? extends java.lang.Object?>[] views();
property public abstract androidx.room.AutoMigration[] autoMigrations;
- property public abstract kotlin.reflect.KClass<? extends java.lang.Object?>[] entities;
+ property public abstract Class<? extends java.lang.Object?>[] entities;
property public abstract boolean exportSchema;
property public abstract int version;
- property public abstract kotlin.reflect.KClass<? extends java.lang.Object?>[] views;
+ property public abstract Class<? extends java.lang.Object?>[] views;
}
@kotlin.annotation.Retention(kotlin.annotation.AnnotationRetention.BINARY) @kotlin.annotation.Target(allowedTargets=kotlin.annotation.AnnotationTarget.CLASS) public @interface DatabaseView {
@@ -122,8 +122,8 @@
}
@kotlin.annotation.Retention(kotlin.annotation.AnnotationRetention.BINARY) @kotlin.annotation.Target(allowedTargets=kotlin.annotation.AnnotationTarget.FUNCTION) public @interface Delete {
- method public abstract kotlin.reflect.KClass<? extends java.lang.Object?> entity() default Any::class;
- property public abstract kotlin.reflect.KClass<? extends java.lang.Object?> entity;
+ method public abstract Class<? extends java.lang.Object?> entity() default Any::class;
+ property public abstract Class<? extends java.lang.Object?> entity;
}
@java.lang.annotation.Repeatable(DeleteColumn.Entries::class) @kotlin.annotation.Retention(kotlin.annotation.AnnotationRetention.BINARY) @kotlin.annotation.Target(allowedTargets=kotlin.annotation.AnnotationTarget.CLASS) public @interface DeleteColumn {
@@ -171,13 +171,13 @@
@kotlin.annotation.Retention(kotlin.annotation.AnnotationRetention.BINARY) @kotlin.annotation.Target(allowedTargets={}) public @interface ForeignKey {
method public abstract String[] childColumns();
method public abstract boolean deferred() default false;
- method public abstract kotlin.reflect.KClass<? extends java.lang.Object?> entity();
+ method public abstract Class<? extends java.lang.Object?> entity();
method @androidx.room.ForeignKey.Action public abstract int onDelete() default androidx.room.ForeignKey.NO_ACTION;
method @androidx.room.ForeignKey.Action public abstract int onUpdate() default androidx.room.ForeignKey.NO_ACTION;
method public abstract String[] parentColumns();
property public abstract String[] childColumns;
property public abstract boolean deferred;
- property public abstract kotlin.reflect.KClass<? extends java.lang.Object?> entity;
+ property public abstract Class<? extends java.lang.Object?> entity;
property @androidx.room.ForeignKey.Action public abstract int onDelete;
property @androidx.room.ForeignKey.Action public abstract int onUpdate;
property public abstract String[] parentColumns;
@@ -213,7 +213,7 @@
}
@kotlin.annotation.Retention(kotlin.annotation.AnnotationRetention.BINARY) @kotlin.annotation.Target(allowedTargets=kotlin.annotation.AnnotationTarget.CLASS) public @interface Fts4 {
- method public abstract kotlin.reflect.KClass<? extends java.lang.Object?> contentEntity() default Any::class;
+ method public abstract Class<? extends java.lang.Object?> contentEntity() default Any::class;
method public abstract String languageId() default "";
method public abstract androidx.room.FtsOptions.MatchInfo matchInfo() default androidx.room.FtsOptions.MatchInfo.FTS4;
method public abstract String[] notIndexed();
@@ -221,7 +221,7 @@
method public abstract int[] prefix();
method public abstract String tokenizer() default androidx.room.FtsOptions.TOKENIZER_SIMPLE;
method public abstract String[] tokenizerArgs();
- property public abstract kotlin.reflect.KClass<? extends java.lang.Object?> contentEntity;
+ property public abstract Class<? extends java.lang.Object?> contentEntity;
property public abstract String languageId;
property public abstract androidx.room.FtsOptions.MatchInfo matchInfo;
property public abstract String[] notIndexed;
@@ -273,19 +273,19 @@
}
@kotlin.annotation.Retention(kotlin.annotation.AnnotationRetention.BINARY) @kotlin.annotation.Target(allowedTargets=kotlin.annotation.AnnotationTarget.FUNCTION) public @interface Insert {
- method public abstract kotlin.reflect.KClass<? extends java.lang.Object?> entity() default Any::class;
+ method public abstract Class<? extends java.lang.Object?> entity() default Any::class;
method @androidx.room.OnConflictStrategy public abstract int onConflict() default androidx.room.OnConflictStrategy.ABORT;
- property public abstract kotlin.reflect.KClass<? extends java.lang.Object?> entity;
+ property public abstract Class<? extends java.lang.Object?> entity;
property @androidx.room.OnConflictStrategy public abstract int onConflict;
}
@kotlin.annotation.Retention(kotlin.annotation.AnnotationRetention.BINARY) @kotlin.annotation.Target(allowedTargets={}) public @interface Junction {
method public abstract String entityColumn() default "";
method public abstract String parentColumn() default "";
- method public abstract kotlin.reflect.KClass<? extends java.lang.Object?> value();
+ method public abstract Class<? extends java.lang.Object?> value();
property public abstract String entityColumn;
property public abstract String parentColumn;
- property public abstract kotlin.reflect.KClass<? extends java.lang.Object?> value;
+ property public abstract Class<? extends java.lang.Object?> value;
}
@kotlin.annotation.Retention(kotlin.annotation.AnnotationRetention.BINARY) @kotlin.annotation.Target(allowedTargets=kotlin.annotation.AnnotationTarget.TYPE) public @interface MapColumn {
@@ -350,18 +350,18 @@
}
@kotlin.annotation.Retention(kotlin.annotation.AnnotationRetention.BINARY) @kotlin.annotation.Target(allowedTargets=kotlin.annotation.AnnotationTarget.FUNCTION) public @interface RawQuery {
- method public abstract kotlin.reflect.KClass<? extends java.lang.Object?>[] observedEntities();
- property public abstract kotlin.reflect.KClass<? extends java.lang.Object?>[] observedEntities;
+ method public abstract Class<? extends java.lang.Object?>[] observedEntities();
+ property public abstract Class<? extends java.lang.Object?>[] observedEntities;
}
@kotlin.annotation.Retention(kotlin.annotation.AnnotationRetention.BINARY) @kotlin.annotation.Target(allowedTargets={kotlin.annotation.AnnotationTarget.FIELD, kotlin.annotation.AnnotationTarget.FUNCTION}) public @interface Relation {
method public abstract androidx.room.Junction associateBy() default androidx.room.Junction(Any::class);
- method public abstract kotlin.reflect.KClass<? extends java.lang.Object?> entity() default Any::class;
+ method public abstract Class<? extends java.lang.Object?> entity() default Any::class;
method public abstract String entityColumn();
method public abstract String parentColumn();
method public abstract String[] projection();
property public abstract androidx.room.Junction associateBy;
- property public abstract kotlin.reflect.KClass<? extends java.lang.Object?> entity;
+ property public abstract Class<? extends java.lang.Object?> entity;
property public abstract String entityColumn;
property public abstract String parentColumn;
property public abstract String[] projection;
@@ -471,21 +471,21 @@
@kotlin.annotation.Retention(kotlin.annotation.AnnotationRetention.BINARY) @kotlin.annotation.Target(allowedTargets={kotlin.annotation.AnnotationTarget.FUNCTION, kotlin.annotation.AnnotationTarget.VALUE_PARAMETER, kotlin.annotation.AnnotationTarget.FIELD, kotlin.annotation.AnnotationTarget.CLASS}) public @interface TypeConverters {
method public abstract androidx.room.BuiltInTypeConverters builtInTypeConverters() default androidx.room.BuiltInTypeConverters();
- method public abstract kotlin.reflect.KClass<? extends java.lang.Object?>[] value();
+ method public abstract Class<? extends java.lang.Object?>[] value();
property public abstract androidx.room.BuiltInTypeConverters builtInTypeConverters;
- property public abstract kotlin.reflect.KClass<? extends java.lang.Object?>[] value;
+ property public abstract Class<? extends java.lang.Object?>[] value;
}
@kotlin.annotation.Retention(kotlin.annotation.AnnotationRetention.BINARY) @kotlin.annotation.Target(allowedTargets=kotlin.annotation.AnnotationTarget.FUNCTION) public @interface Update {
- method public abstract kotlin.reflect.KClass<? extends java.lang.Object?> entity() default Any::class;
+ method public abstract Class<? extends java.lang.Object?> entity() default Any::class;
method @androidx.room.OnConflictStrategy public abstract int onConflict() default androidx.room.OnConflictStrategy.ABORT;
- property public abstract kotlin.reflect.KClass<? extends java.lang.Object?> entity;
+ property public abstract Class<? extends java.lang.Object?> entity;
property @androidx.room.OnConflictStrategy public abstract int onConflict;
}
@kotlin.annotation.Retention(kotlin.annotation.AnnotationRetention.BINARY) @kotlin.annotation.Target(allowedTargets=kotlin.annotation.AnnotationTarget.FUNCTION) public @interface Upsert {
- method public abstract kotlin.reflect.KClass<? extends java.lang.Object?> entity() default Any::class;
- property public abstract kotlin.reflect.KClass<? extends java.lang.Object?> entity;
+ method public abstract Class<? extends java.lang.Object?> entity() default Any::class;
+ property public abstract Class<? extends java.lang.Object?> entity;
}
}
diff --git a/room/room-common/build.gradle b/room/room-common/build.gradle
index 2e36b7e..1cf5db4 100644
--- a/room/room-common/build.gradle
+++ b/room/room-common/build.gradle
@@ -88,6 +88,5 @@
inceptionYear = "2017"
description = "Android Room-Common"
legacyDisableKotlinStrictApiMode = true
- metalavaK2UastEnabled = false
kotlinTarget = KotlinTarget.KOTLIN_2_0
}
diff --git a/room/room-compiler-processing/build.gradle b/room/room-compiler-processing/build.gradle
index 4cc1d58..c7250a8 100644
--- a/room/room-compiler-processing/build.gradle
+++ b/room/room-compiler-processing/build.gradle
@@ -29,47 +29,6 @@
plugins {
id("AndroidXPlugin")
id("kotlin")
- id("com.gradleup.shadow")
-}
-
-configurations {
- // For shadowed / jarjared deps
- shadowed
- // shadowed deps are compile only deps
- compileOnly.extendsFrom(shadowed)
- // compiler tests don't use shadowed, so include them
- testCompile.extendsFrom(shadowed)
- // for downstream tests
- shadowAndImplementation.extendsFrom(shadow)
- shadowAndImplementation.extendsFrom(implementation)
-}
-
-shadowJar {
- archiveClassifier = ""
- configurations = [project.configurations.shadowed]
- relocate("kotlin.metadata", "androidx.room.jarjarred.kotlin.metadata")
- mergeServiceFiles() // kotlin-metadata-jvm has a service descriptor that needs transformation
- // Exclude Kotlin metadata files from kotlin-metadata-jvm
- exclude 'META-INF/kotlin-metadata-jvm.kotlin_module'
- exclude 'META-INF/kotlin-metadata.kotlin_module'
- exclude 'META-INF/metadata.jvm.kotlin_module'
- exclude 'META-INF/metadata.kotlin_module'
-}
-
-jar {
- archiveClassifier = "before-jarjar"
-}
-
-configurations {
- // replace the standard jar with the one built by 'shadowJar' in both api and runtime variants
- apiElements.outgoing.artifacts.clear()
- apiElements.outgoing.artifact(shadowJar) {
- builtBy shadowJar
- }
- runtimeElements.outgoing.artifacts.clear()
- runtimeElements.outgoing.artifact(shadowJar) {
- builtBy shadowJar
- }
}
dependencies {
@@ -80,9 +39,7 @@
implementation(libs.guava)
implementation(libs.autoCommon)
implementation(libs.autoValueAnnotations)
- shadowed(libs.kotlinMetadataJvm) {
- exclude group: "org.jetbrains.kotlin", module: "kotlin-stdlib"
- }
+ implementation(libs.kotlinMetadataJvm)
implementation(libs.kspApi)
testImplementation("androidx.annotation:annotation:1.8.1")
diff --git a/room/room-compiler-processing/src/main/java/androidx/room/compiler/codegen/XClassName.kt b/room/room-compiler-processing/src/main/java/androidx/room/compiler/codegen/XClassName.kt
index 914b990..d48c5a0 100644
--- a/room/room-compiler-processing/src/main/java/androidx/room/compiler/codegen/XClassName.kt
+++ b/room/room-compiler-processing/src/main/java/androidx/room/compiler/codegen/XClassName.kt
@@ -50,6 +50,7 @@
// But a decision has to be made...
val packageName: String = java.packageName()
val simpleNames: List<String> = java.simpleNames()
+ val simpleName = simpleNames.last()
val canonicalName: String = java.canonicalName()
val reflectionName: String = java.reflectionName()
@@ -82,6 +83,20 @@
nullability = XNullability.NONNULL
)
+ fun peerClass(name: String) =
+ XClassName(
+ java = java.peerClass(name),
+ kotlin = kotlin.peerClass(name),
+ nullability = XNullability.NONNULL
+ )
+
+ fun topLevelClass() =
+ XClassName(
+ java = java.topLevelClassName(),
+ kotlin = kotlin.topLevelClassName(),
+ nullability = XNullability.NONNULL
+ )
+
override fun copy(nullable: Boolean): XClassName {
return XClassName(
java = java,
diff --git a/room/room-compiler-processing/src/main/java/androidx/room/compiler/codegen/XTypeName.kt b/room/room-compiler-processing/src/main/java/androidx/room/compiler/codegen/XTypeName.kt
index 5680e41..1feb79e 100644
--- a/room/room-compiler-processing/src/main/java/androidx/room/compiler/codegen/XTypeName.kt
+++ b/room/room-compiler-processing/src/main/java/androidx/room/compiler/codegen/XTypeName.kt
@@ -199,6 +199,7 @@
* the equivalent Kotlin and Java type names are represented, [IntArray] and `int[]`
* respectively.
*/
+ @JvmStatic
fun getArrayName(componentTypeName: XTypeName): XTypeName {
componentTypeName.java.let {
require(it !is JWildcardTypeName || it.lowerBounds.isEmpty()) {
@@ -243,6 +244,7 @@
*
* In Java: `? super <bound>` In Kotlin `in <bound>
*/
+ @JvmStatic
fun getConsumerSuperName(bound: XTypeName): XTypeName {
return XTypeName(
java = JWildcardTypeName.supertypeOf(bound.java),
@@ -260,6 +262,7 @@
*
* In Java: `? extends <bound>` In Kotlin `out <bound>
*/
+ @JvmStatic
fun getProducerExtendsName(bound: XTypeName): XTypeName {
return XTypeName(
java = JWildcardTypeName.subtypeOf(bound.java),
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/DatabaseProcessingStep.kt b/room/room-compiler/src/main/kotlin/androidx/room/DatabaseProcessingStep.kt
index 0f00fc6..82f9c6d 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/DatabaseProcessingStep.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/DatabaseProcessingStep.kt
@@ -27,7 +27,7 @@
import androidx.room.processor.Context.BooleanProcessorOptions.GENERATE_KOTLIN
import androidx.room.processor.DatabaseProcessor
import androidx.room.processor.ProcessorErrors
-import androidx.room.vo.DaoMethod
+import androidx.room.vo.DaoFunction
import androidx.room.vo.Warning
import androidx.room.writer.AutoMigrationWriter
import androidx.room.writer.DaoWriter
@@ -91,12 +91,12 @@
}
}
- val daoMethodsMap = databases?.flatMap { db -> db.daoMethods.map { it to db } }?.toMap()
- daoMethodsMap?.let {
+ val daoFunctionsMap = databases?.flatMap { db -> db.daoFunctions.map { it to db } }?.toMap()
+ daoFunctionsMap?.let {
prepareDaosForWriting(databases, it.keys.toList())
- it.forEach { (daoMethod, db) ->
+ it.forEach { (daoFunction, db) ->
DaoWriter(
- dao = daoMethod.dao,
+ dao = daoFunction.dao,
dbElement = db.element,
writerContext = TypeWriter.WriterContext.fromProcessingContext(context)
)
@@ -166,31 +166,33 @@
}
}
- /** Traverses all dao methods and assigns them suffix if they are used in multiple databases. */
+ /**
+ * Traverses all dao functions and assigns them suffix if they are used in multiple databases.
+ */
private fun prepareDaosForWriting(
databases: List<androidx.room.vo.Database>,
- daoMethods: List<DaoMethod>
+ daoFunctions: List<DaoFunction>
) {
- daoMethods
+ daoFunctions
.groupBy { it.dao.typeName }
// if used only in 1 database, nothing to do.
.filter { entry -> entry.value.size > 1 }
.forEach { entry ->
entry.value
- .groupBy { daoMethod ->
+ .groupBy { daoFunction ->
// first suffix guess: Database's simple name
- val db = databases.first { db -> db.daoMethods.contains(daoMethod) }
+ val db = databases.first { db -> db.daoFunctions.contains(daoFunction) }
db.typeName.simpleNames.last()
}
- .forEach { (dbName, methods) ->
- if (methods.size == 1) {
+ .forEach { (dbName, functions) ->
+ if (functions.size == 1) {
// good, db names do not clash, use db name as suffix
- methods.first().dao.setSuffix(dbName)
+ functions.first().dao.setSuffix(dbName)
} else {
// ok looks like a dao is used in 2 different databases both of
// which have the same name. enumerate.
- methods.forEachIndexed { index, method ->
- method.dao.setSuffix("${dbName}_$index")
+ functions.forEachIndexed { index, function ->
+ function.dao.setSuffix("${dbName}_$index")
}
}
}
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/processor/DaoProcessor.kt b/room/room-compiler/src/main/kotlin/androidx/room/processor/DaoProcessor.kt
index a52c017..ce81e10 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/processor/DaoProcessor.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/processor/DaoProcessor.kt
@@ -30,8 +30,8 @@
import androidx.room.compiler.processing.XTypeElement
import androidx.room.verifier.DatabaseVerifier
import androidx.room.vo.Dao
-import androidx.room.vo.KotlinBoxedPrimitiveMethodDelegate
-import androidx.room.vo.KotlinDefaultMethodDelegate
+import androidx.room.vo.KotlinBoxedPrimitiveFunctionDelegate
+import androidx.room.vo.KotlinDefaultFunctionDelegate
import androidx.room.vo.Warning
class DaoProcessor(
@@ -60,15 +60,15 @@
return Dao(
element = element,
type = element.type,
- queryMethods = emptyList(),
- rawQueryMethods = emptyList(),
- insertMethods = emptyList(),
- upsertMethods = emptyList(),
- deleteMethods = emptyList(),
- updateMethods = emptyList(),
- transactionMethods = emptyList(),
- kotlinBoxedPrimitiveMethodDelegates = emptyList(),
- kotlinDefaultMethodDelegates = emptyList(),
+ queryFunctions = emptyList(),
+ rawQueryFunctions = emptyList(),
+ insertFunctions = emptyList(),
+ upsertFunctions = emptyList(),
+ deleteFunctions = emptyList(),
+ updateFunctions = emptyList(),
+ transactionFunctions = emptyList(),
+ kotlinBoxedPrimitiveFunctionDelegates = emptyList(),
+ kotlinDefaultFunctionDelegates = emptyList(),
constructorParamType = null
)
}
@@ -84,43 +84,43 @@
)
val declaredType = element.type
- val allMethods = element.getAllMethods()
- val methods =
- allMethods
+ val allFunctions = element.getAllMethods()
+ val functions =
+ allFunctions
.filter { it.isAbstract() && !it.hasKotlinDefaultImpl() }
- .groupBy { method ->
- if (method.isKotlinPropertyMethod()) {
+ .groupBy { function ->
+ if (function.isKotlinPropertyMethod()) {
context.checker.check(
- predicate = method.hasAnnotation(Query::class),
- element = method,
+ predicate = function.hasAnnotation(Query::class),
+ element = function,
errorMsg = ProcessorErrors.INVALID_ANNOTATION_IN_DAO_PROPERTY
)
} else {
context.checker.check(
predicate =
- PROCESSED_ANNOTATIONS.count { method.hasAnnotation(it) } <= 1,
- element = method,
- errorMsg = ProcessorErrors.INVALID_ANNOTATION_COUNT_IN_DAO_METHOD
+ PROCESSED_ANNOTATIONS.count { function.hasAnnotation(it) } <= 1,
+ element = function,
+ errorMsg = ProcessorErrors.INVALID_ANNOTATION_COUNT_IN_DAO_FUNCTION
)
}
- if (method.hasAnnotation(JvmName::class)) {
+ if (function.hasAnnotation(JvmName::class)) {
context.logger.w(
- Warning.JVM_NAME_ON_OVERRIDDEN_METHOD,
- method,
- ProcessorErrors.JVM_NAME_ON_OVERRIDDEN_METHOD
+ Warning.JVM_NAME_ON_OVERRIDDEN_FUNCTION,
+ function,
+ ProcessorErrors.JVM_NAME_ON_OVERRIDDEN_FUNCTION
)
}
- if (method.hasAnnotation(Query::class)) {
+ if (function.hasAnnotation(Query::class)) {
Query::class
- } else if (method.hasAnnotation(Insert::class)) {
+ } else if (function.hasAnnotation(Insert::class)) {
Insert::class
- } else if (method.hasAnnotation(Delete::class)) {
+ } else if (function.hasAnnotation(Delete::class)) {
Delete::class
- } else if (method.hasAnnotation(Update::class)) {
+ } else if (function.hasAnnotation(Update::class)) {
Update::class
- } else if (method.hasAnnotation(RawQuery::class)) {
+ } else if (function.hasAnnotation(RawQuery::class)) {
RawQuery::class
- } else if (method.hasAnnotation(Upsert::class)) {
+ } else if (function.hasAnnotation(Upsert::class)) {
Upsert::class
} else {
Any::class
@@ -137,9 +137,9 @@
dbVerifier
}
- val queryMethods =
- methods[Query::class]?.map {
- QueryMethodProcessor(
+ val queryFunctions =
+ functions[Query::class]?.map {
+ QueryFunctionProcessor(
baseContext = context,
containing = declaredType,
executableElement = it,
@@ -148,9 +148,9 @@
.process()
} ?: emptyList()
- val rawQueryMethods =
- methods[RawQuery::class]?.map {
- RawQueryMethodProcessor(
+ val rawQueryFunctions =
+ functions[RawQuery::class]?.map {
+ RawQueryFunctionProcessor(
baseContext = context,
containing = declaredType,
executableElement = it
@@ -158,9 +158,9 @@
.process()
} ?: emptyList()
- val insertMethods =
- methods[Insert::class]?.map {
- InsertMethodProcessor(
+ val insertFunctions =
+ functions[Insert::class]?.map {
+ InsertFunctionProcessor(
baseContext = context,
containing = declaredType,
executableElement = it
@@ -168,9 +168,9 @@
.process()
} ?: emptyList()
- val deleteMethods =
- methods[Delete::class]?.map {
- DeleteMethodProcessor(
+ val deleteFunctions =
+ functions[Delete::class]?.map {
+ DeleteFunctionProcessor(
baseContext = context,
containing = declaredType,
executableElement = it
@@ -178,9 +178,9 @@
.process()
} ?: emptyList()
- val updateMethods =
- methods[Update::class]?.map {
- UpdateMethodProcessor(
+ val updateFunctions =
+ functions[Update::class]?.map {
+ UpdateFunctionProcessor(
baseContext = context,
containing = declaredType,
executableElement = it
@@ -188,9 +188,9 @@
.process()
} ?: emptyList()
- val upsertMethods =
- methods[Upsert::class]?.map {
- UpsertMethodProcessor(
+ val upsertFunctions =
+ functions[Upsert::class]?.map {
+ UpsertFunctionProcessor(
baseContext = context,
containing = declaredType,
executableElement = it
@@ -198,14 +198,14 @@
.process()
} ?: emptyList()
- val transactionMethods =
- allMethods
+ val transactionFunctions =
+ allFunctions
.filter { member ->
member.hasAnnotation(Transaction::class) &&
PROCESSED_ANNOTATIONS.none { member.hasAnnotation(it) }
}
.map {
- TransactionMethodProcessor(
+ TransactionFunctionProcessor(
baseContext = context,
containingElement = element,
containingType = declaredType,
@@ -214,29 +214,29 @@
.process()
}
- // Only try to find Kotlin boxed bridge methods when the dao extends a class or
- // implements an interface since otherwise there are no bridge method generated by
+ // Only try to find Kotlin boxed bridge functions when the dao extends a class or
+ // implements an interface since otherwise there are no bridge function generated by
// Kotlin.
- val unannotatedMethods = methods[Any::class] ?: emptyList()
- val kotlinBoxedPrimitiveBridgeMethods =
+ val unannotatedFunctions = functions[Any::class] ?: emptyList()
+ val kotlinBoxedPrimitiveBridgeFunctions =
if (element.superClass != null || element.getSuperInterfaceElements().isNotEmpty()) {
- matchKotlinBoxedPrimitiveMethods(
- unannotatedMethods,
- methods.values.flatten() - unannotatedMethods
+ matchKotlinBoxedPrimitiveFunctions(
+ unannotatedFunctions,
+ functions.values.flatten() - unannotatedFunctions
)
} else {
emptyList()
}
- val kotlinDefaultMethodDelegates =
+ val kotlinDefaultFunctionDelegates =
if (element.isInterface()) {
- val allProcessedMethods =
- methods.values.flatten() + transactionMethods.map { it.element }
- allMethods
- .filterNot { allProcessedMethods.contains(it) }
- .mapNotNull { method ->
- if (method.hasKotlinDefaultImpl()) {
- KotlinDefaultMethodDelegate(element = method)
+ val allProcessedFunctions =
+ functions.values.flatten() + transactionFunctions.map { it.element }
+ allFunctions
+ .filterNot { allProcessedFunctions.contains(it) }
+ .mapNotNull { function ->
+ if (function.hasKotlinDefaultImpl()) {
+ KotlinDefaultFunctionDelegate(element = function)
} else {
null
}
@@ -264,24 +264,24 @@
ProcessorErrors.CANNOT_USE_UNBOUND_GENERICS_IN_DAO_CLASSES
)
- val invalidAnnotatedMethods =
- unannotatedMethods - kotlinBoxedPrimitiveBridgeMethods.map { it.element }
- invalidAnnotatedMethods.forEach {
- context.logger.e(it, ProcessorErrors.INVALID_ANNOTATION_COUNT_IN_DAO_METHOD)
+ val invalidAnnotatedFunctions =
+ unannotatedFunctions - kotlinBoxedPrimitiveBridgeFunctions.map { it.element }
+ invalidAnnotatedFunctions.forEach {
+ context.logger.e(it, ProcessorErrors.INVALID_ANNOTATION_COUNT_IN_DAO_FUNCTION)
}
return Dao(
element = element,
type = declaredType,
- queryMethods = queryMethods,
- rawQueryMethods = rawQueryMethods,
- insertMethods = insertMethods,
- deleteMethods = deleteMethods,
- updateMethods = updateMethods,
- upsertMethods = upsertMethods,
- transactionMethods = transactionMethods.toList(),
- kotlinBoxedPrimitiveMethodDelegates = kotlinBoxedPrimitiveBridgeMethods,
- kotlinDefaultMethodDelegates = kotlinDefaultMethodDelegates.toList(),
+ queryFunctions = queryFunctions,
+ rawQueryFunctions = rawQueryFunctions,
+ insertFunctions = insertFunctions,
+ deleteFunctions = deleteFunctions,
+ updateFunctions = updateFunctions,
+ upsertFunctions = upsertFunctions,
+ transactionFunctions = transactionFunctions.toList(),
+ kotlinBoxedPrimitiveFunctionDelegates = kotlinBoxedPrimitiveBridgeFunctions,
+ kotlinDefaultFunctionDelegates = kotlinDefaultFunctionDelegates.toList(),
constructorParamType = constructorParamType
)
}
@@ -299,17 +299,17 @@
}
/**
- * Find Kotlin bridge methods generated for overrides of primitives, see KT-46650. When
- * generating the Java implementation of the DAO, Room needs to also override the bridge method
- * generated by Kotlin for the boxed version, it will contain the same name, return type and
- * parameter, but the generic primitive params will be boxed.
+ * Find Kotlin bridge functions generated for overrides of primitives, see KT-46650. When
+ * generating the Java implementation of the DAO, Room needs to also override the bridge
+ * function generated by Kotlin for the boxed version, it will contain the same name, return
+ * type and parameter, but the generic primitive params will be boxed.
*/
- private fun matchKotlinBoxedPrimitiveMethods(
- unannotatedMethods: List<XMethodElement>,
- annotatedMethods: List<XMethodElement>
+ private fun matchKotlinBoxedPrimitiveFunctions(
+ unannotatedFunctions: List<XMethodElement>,
+ annotatedFunctions: List<XMethodElement>
) =
- unannotatedMethods.mapNotNull { unannotated ->
- annotatedMethods
+ unannotatedFunctions.mapNotNull { unannotated ->
+ annotatedFunctions
.firstOrNull {
if (it.jvmName != unannotated.jvmName) {
return@firstOrNull false
@@ -341,8 +341,8 @@
}
return@firstOrNull true
}
- ?.let { matchingMethod ->
- KotlinBoxedPrimitiveMethodDelegate(unannotated, matchingMethod)
+ ?.let { matchingFunction ->
+ KotlinBoxedPrimitiveFunctionDelegate(unannotated, matchingFunction)
}
}
}
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/processor/DataClassMethodProcessor.kt b/room/room-compiler/src/main/kotlin/androidx/room/processor/DataClassFunctionProcessor.kt
similarity index 83%
rename from room/room-compiler/src/main/kotlin/androidx/room/processor/DataClassMethodProcessor.kt
rename to room/room-compiler/src/main/kotlin/androidx/room/processor/DataClassFunctionProcessor.kt
index 6f295d1e..aa6252b 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/processor/DataClassMethodProcessor.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/processor/DataClassFunctionProcessor.kt
@@ -18,16 +18,16 @@
import androidx.room.compiler.processing.XMethodElement
import androidx.room.compiler.processing.XType
-import androidx.room.vo.DataClassMethod
+import androidx.room.vo.DataClassFunction
/** processes an executable element as member of the owning class */
-class DataClassMethodProcessor(
+class DataClassFunctionProcessor(
private val context: Context,
private val element: XMethodElement,
private val owner: XType
) {
- fun process(): DataClassMethod {
+ fun process(): DataClassFunction {
val asMember = element.asMemberOf(owner)
- return DataClassMethod(element = element, resolvedType = asMember)
+ return DataClassFunction(element = element, resolvedType = asMember)
}
}
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/processor/DataClassProcessor.kt b/room/room-compiler/src/main/kotlin/androidx/room/processor/DataClassProcessor.kt
index efed0d7..a80892c 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/processor/DataClassProcessor.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/processor/DataClassProcessor.kt
@@ -38,7 +38,7 @@
import androidx.room.vo.CallType
import androidx.room.vo.Constructor
import androidx.room.vo.DataClass
-import androidx.room.vo.DataClassMethod
+import androidx.room.vo.DataClassFunction
import androidx.room.vo.EmbeddedField
import androidx.room.vo.Entity
import androidx.room.vo.EntityOrView
@@ -230,7 +230,11 @@
.asSequence()
.filter { !it.isAbstract() && !it.hasAnnotation(Ignore::class) }
.map {
- DataClassMethodProcessor(context = context, element = it, owner = declaredType)
+ DataClassFunctionProcessor(
+ context = context,
+ element = it,
+ owner = declaredType
+ )
.process()
}
.toList()
@@ -748,11 +752,11 @@
return referenceRecursionList.joinToString(" -> ")
}
- private fun assignGetters(fields: List<Field>, getterCandidates: List<DataClassMethod>) {
+ private fun assignGetters(fields: List<Field>, getterCandidates: List<DataClassFunction>) {
fields.forEach { field -> assignGetter(field, getterCandidates) }
}
- private fun assignGetter(field: Field, getterCandidates: List<DataClassMethod>) {
+ private fun assignGetter(field: Field, getterCandidates: List<DataClassFunction>) {
val success =
chooseAssignment(
field = field,
@@ -818,7 +822,7 @@
private fun assignSetters(
fields: List<Field>,
- setterCandidates: List<DataClassMethod>,
+ setterCandidates: List<DataClassFunction>,
constructor: Constructor?
) {
fields.forEach { field -> assignSetter(field, setterCandidates, constructor) }
@@ -826,7 +830,7 @@
private fun assignSetter(
field: Field,
- setterCandidates: List<DataClassMethod>,
+ setterCandidates: List<DataClassFunction>,
constructor: Constructor?
) {
if (constructor != null && constructor.hasField(field)) {
@@ -910,11 +914,11 @@
*/
private fun chooseAssignment(
field: Field,
- candidates: List<DataClassMethod>,
+ candidates: List<DataClassFunction>,
nameVariations: List<String>,
- getType: (DataClassMethod) -> XType,
+ getType: (DataClassFunction) -> XType,
assignFromField: () -> Unit,
- assignFromMethod: (DataClassMethod) -> Unit,
+ assignFromMethod: (DataClassFunction) -> Unit,
reportAmbiguity: (List<String>) -> Unit
): Boolean {
if (field.element.isPublic()) {
@@ -955,9 +959,9 @@
}
private fun verifyAndChooseOneFrom(
- candidates: List<DataClassMethod>?,
+ candidates: List<DataClassFunction>?,
reportAmbiguity: (List<String>) -> Unit
- ): DataClassMethod? {
+ ): DataClassFunction? {
if (candidates == null) {
return null
}
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/processor/DatabaseProcessor.kt b/room/room-compiler/src/main/kotlin/androidx/room/processor/DatabaseProcessor.kt
index 6cf7930..5892c05 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/processor/DatabaseProcessor.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/processor/DatabaseProcessor.kt
@@ -32,7 +32,7 @@
import androidx.room.verifier.DatabaseVerificationErrors
import androidx.room.verifier.DatabaseVerifier
import androidx.room.vo.Dao
-import androidx.room.vo.DaoMethod
+import androidx.room.vo.DaoFunction
import androidx.room.vo.Database
import androidx.room.vo.DatabaseConstructor
import androidx.room.vo.DatabaseView
@@ -87,7 +87,7 @@
validateUniqueTableAndViewNames(element, entities, views)
val declaredType = element.type
- val daoMethods =
+ val daoFunctions =
element
.getAllMethods()
.filter { it.isAbstract() }
@@ -104,25 +104,25 @@
if (daoElement == null) {
context.logger.e(
executable,
- ProcessorErrors.DATABASE_INVALID_DAO_METHOD_RETURN_TYPE
+ ProcessorErrors.DATABASE_INVALID_DAO_FUNCTION_RETURN_TYPE
)
null
} else {
if (executable.hasAnnotation(JvmName::class)) {
context.logger.w(
- Warning.JVM_NAME_ON_OVERRIDDEN_METHOD,
+ Warning.JVM_NAME_ON_OVERRIDDEN_FUNCTION,
executable,
- ProcessorErrors.JVM_NAME_ON_OVERRIDDEN_METHOD
+ ProcessorErrors.JVM_NAME_ON_OVERRIDDEN_FUNCTION
)
}
val dao =
DaoProcessor(context, daoElement, declaredType, dbVerifier).process()
- DaoMethod(executable, dao)
+ DaoFunction(executable, dao)
}
}
.toList()
- validateUniqueDaoClasses(element, daoMethods, entities)
+ validateUniqueDaoClasses(element, daoFunctions, entities)
validateUniqueIndices(element, entities)
val hasForeignKeys = entities.any { it.foreignKeys.isNotEmpty() }
@@ -145,7 +145,7 @@
type = element.type,
entities = entities,
views = views,
- daoMethods = daoMethods,
+ daoFunctions = daoFunctions,
exportSchema = dbAnnotation.value.exportSchema,
enableForeignKeys = hasForeignKeys,
overrideClearAllTables = hasClearAllTables,
@@ -315,23 +315,23 @@
private fun validateUniqueDaoClasses(
dbElement: XTypeElement,
- daoMethods: List<DaoMethod>,
+ daoFunctions: List<DaoFunction>,
entities: List<Entity>
) {
val entityTypeNames = entities.map { it.typeName }.toSet()
- daoMethods
+ daoFunctions
.groupBy { it.dao.typeName }
.forEach {
if (it.value.size > 1) {
val error =
ProcessorErrors.duplicateDao(
dao = it.key.toString(context.codeLanguage),
- methodNames = it.value.map { it.element.name }
+ functionNames = it.value.map { it.element.name }
)
- it.value.forEach { daoMethod ->
+ it.value.forEach { daoFunction ->
context.logger.e(
- daoMethod.element,
- ProcessorErrors.DAO_METHOD_CONFLICTS_WITH_OTHERS
+ daoFunction.element,
+ ProcessorErrors.DAO_FUNCTION_CONFLICTS_WITH_OTHERS
)
}
// also report the full error for the database
@@ -353,15 +353,15 @@
}
}
}
- daoMethods.forEach { daoMethod ->
- daoMethod.dao.deleteOrUpdateShortcutMethods.forEach { method ->
+ daoFunctions.forEach { daoFunction ->
+ daoFunction.dao.mDeleteOrUpdateShortcutFunctions.forEach { method ->
method.entities.forEach {
- check(method.element, daoMethod.dao, it.value.entityTypeName)
+ check(method.element, daoFunction.dao, it.value.entityTypeName)
}
}
- daoMethod.dao.insertOrUpsertShortcutMethods.forEach { method ->
+ daoFunction.dao.mInsertOrUpsertShortcutFunctions.forEach { method ->
method.entities.forEach {
- check(method.element, daoMethod.dao, it.value.entityTypeName)
+ check(method.element, daoFunction.dao, it.value.entityTypeName)
}
}
}
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/processor/DeleteMethodProcessor.kt b/room/room-compiler/src/main/kotlin/androidx/room/processor/DeleteFunctionProcessor.kt
similarity index 80%
rename from room/room-compiler/src/main/kotlin/androidx/room/processor/DeleteMethodProcessor.kt
rename to room/room-compiler/src/main/kotlin/androidx/room/processor/DeleteFunctionProcessor.kt
index 6967b93..0cf83d2 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/processor/DeleteMethodProcessor.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/processor/DeleteFunctionProcessor.kt
@@ -18,26 +18,26 @@
import androidx.room.Delete
import androidx.room.compiler.processing.XMethodElement
import androidx.room.compiler.processing.XType
-import androidx.room.vo.DeleteMethod
+import androidx.room.vo.DeleteFunction
-class DeleteMethodProcessor(
+class DeleteFunctionProcessor(
baseContext: Context,
val containing: XType,
val executableElement: XMethodElement
) {
val context = baseContext.fork(executableElement)
- fun process(): DeleteMethod {
- val delegate = ShortcutMethodProcessor(context, containing, executableElement)
+ fun process(): DeleteFunction {
+ val delegate = ShortcutFunctionProcessor(context, containing, executableElement)
val annotation =
delegate.extractAnnotation(Delete::class, ProcessorErrors.MISSING_DELETE_ANNOTATION)
val returnType = delegate.extractReturnType()
- val methodBinder = delegate.findDeleteOrUpdateMethodBinder(returnType)
+ val functionBinder = delegate.findDeleteOrUpdateFunctionBinder(returnType)
context.checker.check(
- methodBinder.adapter != null,
+ functionBinder.adapter != null,
executableElement,
ProcessorErrors.CANNOT_FIND_DELETE_RESULT_ADAPTER
)
@@ -49,11 +49,11 @@
onValidatePartialEntity = { _, _ -> }
)
- return DeleteMethod(
+ return DeleteFunction(
element = delegate.executableElement,
entities = entities,
parameters = params,
- methodBinder = methodBinder
+ functionBinder = functionBinder
)
}
}
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/processor/MethodProcessorDelegate.kt b/room/room-compiler/src/main/kotlin/androidx/room/processor/FunctionProcessorDelegate.kt
similarity index 72%
rename from room/room-compiler/src/main/kotlin/androidx/room/processor/MethodProcessorDelegate.kt
rename to room/room-compiler/src/main/kotlin/androidx/room/processor/FunctionProcessorDelegate.kt
index da5e301..d7b77ec 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/processor/MethodProcessorDelegate.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/processor/FunctionProcessorDelegate.kt
@@ -36,20 +36,20 @@
import androidx.room.solver.prepared.binder.PreparedQueryResultBinder
import androidx.room.solver.query.result.CoroutineResultBinder
import androidx.room.solver.query.result.QueryResultBinder
-import androidx.room.solver.shortcut.binder.CoroutineDeleteOrUpdateMethodBinder
-import androidx.room.solver.shortcut.binder.CoroutineInsertOrUpsertMethodBinder
-import androidx.room.solver.shortcut.binder.DeleteOrUpdateMethodBinder
-import androidx.room.solver.shortcut.binder.InsertOrUpsertMethodBinder
-import androidx.room.solver.transaction.binder.CoroutineTransactionMethodBinder
-import androidx.room.solver.transaction.binder.InstantTransactionMethodBinder
-import androidx.room.solver.transaction.binder.TransactionMethodBinder
-import androidx.room.solver.transaction.result.TransactionMethodAdapter
+import androidx.room.solver.shortcut.binder.CoroutineDeleteOrUpdateFunctionBinder
+import androidx.room.solver.shortcut.binder.CoroutineInsertOrUpsertFunctionBinder
+import androidx.room.solver.shortcut.binder.DeleteOrUpdateFunctionBinder
+import androidx.room.solver.shortcut.binder.InsertOrUpsertFunctionBinder
+import androidx.room.solver.transaction.binder.CoroutineTransactionFunctionBinder
+import androidx.room.solver.transaction.binder.InstantTransactionFunctionBinder
+import androidx.room.solver.transaction.binder.TransactionFunctionBinder
+import androidx.room.solver.transaction.result.TransactionFunctionAdapter
import androidx.room.vo.QueryParameter
import androidx.room.vo.ShortcutQueryParameter
-import androidx.room.vo.TransactionMethod
+import androidx.room.vo.TransactionFunction
-/** Delegate class with common functionality for DAO method processors. */
-abstract class MethodProcessorDelegate(
+/** Delegate class with common functionality for DAO function processors. */
+abstract class FunctionProcessorDelegate(
val context: Context,
val containing: XType,
val executableElement: XMethodElement
@@ -84,39 +84,39 @@
query: ParsedQuery
): PreparedQueryResultBinder
- abstract fun findInsertMethodBinder(
+ abstract fun findInsertFunctionBinder(
returnType: XType,
params: List<ShortcutQueryParameter>
- ): InsertOrUpsertMethodBinder
+ ): InsertOrUpsertFunctionBinder
- abstract fun findDeleteOrUpdateMethodBinder(returnType: XType): DeleteOrUpdateMethodBinder
+ abstract fun findDeleteOrUpdateFunctionBinder(returnType: XType): DeleteOrUpdateFunctionBinder
- abstract fun findUpsertMethodBinder(
+ abstract fun findUpsertFunctionBinder(
returnType: XType,
params: List<ShortcutQueryParameter>
- ): InsertOrUpsertMethodBinder
+ ): InsertOrUpsertFunctionBinder
- abstract fun findTransactionMethodBinder(
- callType: TransactionMethod.CallType
- ): TransactionMethodBinder
+ abstract fun findTransactionFunctionBinder(
+ callType: TransactionFunction.CallType
+ ): TransactionFunctionBinder
companion object {
fun createFor(
context: Context,
containing: XType,
executableElement: XMethodElement
- ): MethodProcessorDelegate {
+ ): FunctionProcessorDelegate {
val asMember = executableElement.asMemberOf(containing)
return if (asMember.isSuspendFunction()) {
- SuspendMethodProcessorDelegate(context, containing, executableElement, asMember)
+ SuspendFunctionProcessorDelegate(context, containing, executableElement, asMember)
} else {
- DefaultMethodProcessorDelegate(context, containing, executableElement, asMember)
+ DefaultFunctionProcessorDelegate(context, containing, executableElement, asMember)
}
}
}
}
-fun MethodProcessorDelegate.returnsDeferredType(): Boolean {
+fun FunctionProcessorDelegate.returnsDeferredType(): Boolean {
val deferredTypes =
DEFERRED_TYPES.mapNotNull { context.processingEnv.findType(it.canonicalName) }
val returnType = extractReturnType()
@@ -125,13 +125,13 @@
}
}
-/** Default delegate for DAO methods. */
-class DefaultMethodProcessorDelegate(
+/** Default delegate for DAO functions. */
+class DefaultFunctionProcessorDelegate(
context: Context,
containing: XType,
executableElement: XMethodElement,
val executableType: XMethodType
-) : MethodProcessorDelegate(context, containing, executableElement) {
+) : FunctionProcessorDelegate(context, containing, executableElement) {
override fun extractReturnType(): XType {
return executableType.returnType
@@ -148,34 +148,34 @@
override fun findPreparedResultBinder(returnType: XType, query: ParsedQuery) =
context.typeAdapterStore.findPreparedQueryResultBinder(returnType, query)
- override fun findInsertMethodBinder(returnType: XType, params: List<ShortcutQueryParameter>) =
- context.typeAdapterStore.findInsertMethodBinder(returnType, params)
+ override fun findInsertFunctionBinder(returnType: XType, params: List<ShortcutQueryParameter>) =
+ context.typeAdapterStore.findInsertFunctionBinder(returnType, params)
- override fun findDeleteOrUpdateMethodBinder(returnType: XType) =
- context.typeAdapterStore.findDeleteOrUpdateMethodBinder(returnType)
+ override fun findDeleteOrUpdateFunctionBinder(returnType: XType) =
+ context.typeAdapterStore.findDeleteOrUpdateFunctionBinder(returnType)
- override fun findUpsertMethodBinder(returnType: XType, params: List<ShortcutQueryParameter>) =
- context.typeAdapterStore.findUpsertMethodBinder(returnType, params)
+ override fun findUpsertFunctionBinder(returnType: XType, params: List<ShortcutQueryParameter>) =
+ context.typeAdapterStore.findUpsertFunctionBinder(returnType, params)
- override fun findTransactionMethodBinder(callType: TransactionMethod.CallType) =
- InstantTransactionMethodBinder(
+ override fun findTransactionFunctionBinder(callType: TransactionFunction.CallType) =
+ InstantTransactionFunctionBinder(
returnType = executableElement.returnType,
adapter =
- TransactionMethodAdapter(
- methodName = executableElement.name,
+ TransactionFunctionAdapter(
+ functionName = executableElement.name,
jvmMethodName = executableElement.jvmName,
callType = callType
),
)
}
-/** Delegate for DAO methods that are a suspend function. */
-class SuspendMethodProcessorDelegate(
+/** Delegate for DAO functions that are a suspend functions. */
+class SuspendFunctionProcessorDelegate(
context: Context,
containing: XType,
executableElement: XMethodElement,
val executableType: XSuspendMethodType
-) : MethodProcessorDelegate(context, containing, executableElement) {
+) : FunctionProcessorDelegate(context, containing, executableElement) {
private val continuationParam: XVariableElement by lazy {
val continuationType =
@@ -208,33 +208,33 @@
continuationParamName = continuationParam.name
)
- override fun findInsertMethodBinder(returnType: XType, params: List<ShortcutQueryParameter>) =
- CoroutineInsertOrUpsertMethodBinder(
+ override fun findInsertFunctionBinder(returnType: XType, params: List<ShortcutQueryParameter>) =
+ CoroutineInsertOrUpsertFunctionBinder(
typeArg = returnType,
adapter = context.typeAdapterStore.findInsertAdapter(returnType, params),
continuationParamName = continuationParam.name
)
- override fun findUpsertMethodBinder(returnType: XType, params: List<ShortcutQueryParameter>) =
- CoroutineInsertOrUpsertMethodBinder(
+ override fun findUpsertFunctionBinder(returnType: XType, params: List<ShortcutQueryParameter>) =
+ CoroutineInsertOrUpsertFunctionBinder(
typeArg = returnType,
adapter = context.typeAdapterStore.findUpsertAdapter(returnType, params),
continuationParamName = continuationParam.name
)
- override fun findDeleteOrUpdateMethodBinder(returnType: XType) =
- CoroutineDeleteOrUpdateMethodBinder(
+ override fun findDeleteOrUpdateFunctionBinder(returnType: XType) =
+ CoroutineDeleteOrUpdateFunctionBinder(
typeArg = returnType,
adapter = context.typeAdapterStore.findDeleteOrUpdateAdapter(returnType),
continuationParamName = continuationParam.name
)
- override fun findTransactionMethodBinder(callType: TransactionMethod.CallType) =
- CoroutineTransactionMethodBinder(
+ override fun findTransactionFunctionBinder(callType: TransactionFunction.CallType) =
+ CoroutineTransactionFunctionBinder(
returnType = executableElement.returnType,
adapter =
- TransactionMethodAdapter(
- methodName = executableElement.name,
+ TransactionFunctionAdapter(
+ functionName = executableElement.name,
jvmMethodName = executableElement.jvmName,
callType = callType
),
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/processor/InsertMethodProcessor.kt b/room/room-compiler/src/main/kotlin/androidx/room/processor/InsertFunctionProcessor.kt
similarity index 90%
rename from room/room-compiler/src/main/kotlin/androidx/room/processor/InsertMethodProcessor.kt
rename to room/room-compiler/src/main/kotlin/androidx/room/processor/InsertFunctionProcessor.kt
index 3337480..f0b6ace 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/processor/InsertMethodProcessor.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/processor/InsertFunctionProcessor.kt
@@ -22,18 +22,18 @@
import androidx.room.OnConflictStrategy
import androidx.room.compiler.processing.XMethodElement
import androidx.room.compiler.processing.XType
-import androidx.room.vo.InsertMethod
+import androidx.room.vo.InsertFunction
import androidx.room.vo.findFieldByColumnName
-class InsertMethodProcessor(
+class InsertFunctionProcessor(
baseContext: Context,
val containing: XType,
val executableElement: XMethodElement
) {
val context = baseContext.fork(executableElement)
- fun process(): InsertMethod {
- val delegate = ShortcutMethodProcessor(context, containing, executableElement)
+ fun process(): InsertFunction {
+ val delegate = ShortcutFunctionProcessor(context, containing, executableElement)
val annotation =
delegate.extractAnnotation(Insert::class, ProcessorErrors.MISSING_INSERT_ANNOTATION)
@@ -48,7 +48,7 @@
context.checker.notUnbound(
returnType,
executableElement,
- ProcessorErrors.CANNOT_USE_UNBOUND_GENERICS_IN_INSERT_METHODS
+ ProcessorErrors.CANNOT_USE_UNBOUND_GENERICS_IN_INSERT_FUNCTIONS
)
val (entities, params) =
@@ -88,21 +88,21 @@
}
)
- val methodBinder = delegate.findInsertMethodBinder(returnType, params)
+ val functionBinder = delegate.findInsertFunctionBinder(returnType, params)
context.checker.check(
- methodBinder.adapter != null,
+ functionBinder.adapter != null,
executableElement,
ProcessorErrors.CANNOT_FIND_INSERT_RESULT_ADAPTER
)
- return InsertMethod(
+ return InsertFunction(
element = executableElement,
returnType = returnType,
entities = entities,
parameters = params,
onConflict = onConflict,
- methodBinder = methodBinder
+ functionBinder = functionBinder
)
}
}
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/processor/ProcessorErrors.kt b/room/room-compiler/src/main/kotlin/androidx/room/processor/ProcessorErrors.kt
index afaa03d..c2a18e1 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/processor/ProcessorErrors.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/processor/ProcessorErrors.kt
@@ -36,56 +36,59 @@
return this.trimIndent().replace("\n", " ")
}
- val ISSUE_TRACKER_LINK = "https://issuetracker.google.com/issues/new?component=413107"
+ const val ISSUE_TRACKER_LINK = "https://issuetracker.google.com/issues/new?component=413107"
- val MISSING_QUERY_ANNOTATION = "Query methods must be annotated with ${Query::class.java}"
- val MISSING_INSERT_ANNOTATION = "Insert methods must be annotated with ${Insert::class.java}"
- val MISSING_DELETE_ANNOTATION = "Delete methods must be annotated with ${Delete::class.java}"
- val MISSING_UPDATE_ANNOTATION = "Update methods must be annotated with ${Update::class.java}"
- val MISSING_UPSERT_ANNOTATION = "Upsert methods must be annotated with ${Upsert::class.java}"
+ val MISSING_QUERY_ANNOTATION = "Query functions must be annotated with ${Query::class.java}"
+ val MISSING_INSERT_ANNOTATION = "Insert functions must be annotated with ${Insert::class.java}"
+ val MISSING_DELETE_ANNOTATION = "Delete functions must be annotated with ${Delete::class.java}"
+ val MISSING_UPDATE_ANNOTATION = "Update functions must be annotated with ${Update::class.java}"
+ val MISSING_UPSERT_ANNOTATION = "Upsert functions must be annotated with ${Upsert::class.java}"
val MISSING_RAWQUERY_ANNOTATION =
- "RawQuery methods must be annotated with" + " ${RawQuery::class.java}"
- val INVALID_ON_CONFLICT_VALUE = "On conflict value must be one of @OnConflictStrategy values."
- val TRANSACTION_REFERENCE_DOCS =
+ "RawQuery functions must be annotated with" + " ${RawQuery::class.java}"
+ const val INVALID_ON_CONFLICT_VALUE =
+ "On conflict value must be one of @OnConflictStrategy values."
+ const val TRANSACTION_REFERENCE_DOCS =
"https://developer.android.com/reference/androidx/" + "room/Transaction.html"
- val INVALID_ANNOTATION_COUNT_IN_DAO_METHOD =
- "An abstract DAO method must be" +
+ val INVALID_ANNOTATION_COUNT_IN_DAO_FUNCTION =
+ "An abstract DAO function must be" +
" annotated with one and only one of the following annotations: " +
DaoProcessor.PROCESSED_ANNOTATIONS.joinToString(", ") { "@" + it.java.simpleName }
val INVALID_ANNOTATION_IN_DAO_PROPERTY =
"An abstract DAO property must be" + " annotated with @get:${Query::class.java}."
- val CANNOT_RESOLVE_RETURN_TYPE = "Cannot resolve return type for %s"
- val CANNOT_USE_UNBOUND_GENERICS_IN_QUERY_METHODS =
+ const val CANNOT_RESOLVE_RETURN_TYPE = "Cannot resolve return type for %s"
+ const val CANNOT_USE_UNBOUND_GENERICS_IN_QUERY_FUNCTIONS =
"Cannot use unbound generics in query" +
- " methods. It must be bound to a type through base Dao class."
- val CANNOT_USE_UNBOUND_GENERICS_IN_INSERT_METHODS =
+ " functions. It must be bound to a type through base Dao class."
+ const val CANNOT_USE_UNBOUND_GENERICS_IN_INSERT_FUNCTIONS =
"Cannot use unbound generics in" +
- " insert methods. It must be bound to a type through base Dao class."
- val CANNOT_USE_UNBOUND_GENERICS_IN_UPSERT_METHODS =
+ " insert functions. It must be bound to a type through base Dao class."
+ const val CANNOT_USE_UNBOUND_GENERICS_IN_UPSERT_FUNCTIONS =
"Cannot use unbound generics in" +
- " upsert methods. It must be bound to a type through base Dao class."
- val CANNOT_USE_UNBOUND_GENERICS_IN_ENTITY_FIELDS = "Cannot use unbound fields in entities."
- val CANNOT_USE_UNBOUND_GENERICS_IN_DAO_CLASSES =
+ " upsert functions. It must be bound to a type through base Dao class."
+ const val CANNOT_USE_UNBOUND_GENERICS_IN_ENTITY_FIELDS =
+ "Cannot use unbound fields in entities."
+ const val CANNOT_USE_UNBOUND_GENERICS_IN_DAO_CLASSES =
"Cannot use unbound generics in Dao classes." +
" If you are trying to create a base DAO, create a normal class, extend it with type" +
" params then mark the subclass with @Dao."
- val CANNOT_USE_MAP_COLUMN_AND_MAP_INFO_SIMULTANEOUSLY =
+ const val CANNOT_USE_MAP_COLUMN_AND_MAP_INFO_SIMULTANEOUSLY =
"Cannot use @MapColumn and " +
" @MapInfo annotation in the same function. Please prefer using @MapColumn only."
- val CANNOT_FIND_GETTER_FOR_FIELD = "Cannot find getter for field."
- val CANNOT_FIND_SETTER_FOR_FIELD = "Cannot find setter for field."
- val MISSING_PRIMARY_KEY = "An entity must have at least 1 field annotated with @PrimaryKey"
- val AUTO_INCREMENTED_PRIMARY_KEY_IS_NOT_INT =
+ const val CANNOT_FIND_GETTER_FOR_FIELD = "Cannot find getter for field."
+ const val CANNOT_FIND_SETTER_FOR_FIELD = "Cannot find setter for field."
+ const val MISSING_PRIMARY_KEY =
+ "An entity must have at least 1 field annotated with @PrimaryKey"
+ const val AUTO_INCREMENTED_PRIMARY_KEY_IS_NOT_INT =
"If a primary key is annotated with" +
" autoGenerate, its type must be int, Integer, long or Long."
- val AUTO_INCREMENT_EMBEDDED_HAS_MULTIPLE_FIELDS =
+ const val AUTO_INCREMENT_EMBEDDED_HAS_MULTIPLE_FIELDS =
"When @PrimaryKey annotation is used on a" +
" field annotated with @Embedded, the embedded class should have only 1 field."
- val INVALID_INDEX_ORDERS_SIZE =
+ const val INVALID_INDEX_ORDERS_SIZE =
"The number of entries in @Index#orders() should be " +
"equal to the amount of columns defined in the @Index value."
- val DO_NOT_USE_GENERIC_IMMUTABLE_MULTIMAP =
+ const val DO_NOT_USE_GENERIC_IMMUTABLE_MULTIMAP =
"Do not use ImmutableMultimap as a type (as with" +
" Multimap itself). Instead use the subtypes such as ImmutableSetMultimap or " +
"ImmutableListMultimap."
@@ -104,9 +107,9 @@
" Available column names:${allColumns.joinToString(", ")}"
}
- val DAO_MUST_BE_AN_ABSTRACT_CLASS_OR_AN_INTERFACE =
+ const val DAO_MUST_BE_AN_ABSTRACT_CLASS_OR_AN_INTERFACE =
"Dao class must be an abstract class or" + " an interface"
- val DAO_MUST_BE_ANNOTATED_WITH_DAO = "Dao class must be annotated with @Dao"
+ const val DAO_MUST_BE_ANNOTATED_WITH_DAO = "Dao class must be annotated with @Dao"
fun daoMustHaveMatchingConstructor(daoName: String, dbName: String): String {
return """
@@ -116,81 +119,82 @@
.trim()
}
- val ENTITY_MUST_BE_ANNOTATED_WITH_ENTITY = "Entity class must be annotated with @Entity"
- val DATABASE_ANNOTATION_MUST_HAVE_LIST_OF_ENTITIES =
+ const val ENTITY_MUST_BE_ANNOTATED_WITH_ENTITY = "Entity class must be annotated with @Entity"
+ const val DATABASE_ANNOTATION_MUST_HAVE_LIST_OF_ENTITIES =
"@Database annotation must specify list" + " of entities"
- val COLUMN_NAME_CANNOT_BE_EMPTY =
+ const val COLUMN_NAME_CANNOT_BE_EMPTY =
"Column name cannot be blank. If you don't want to set it" +
", just remove the @ColumnInfo annotation or use @ColumnInfo.INHERIT_FIELD_NAME."
- val ENTITY_TABLE_NAME_CANNOT_BE_EMPTY =
+ const val ENTITY_TABLE_NAME_CANNOT_BE_EMPTY =
"Entity table name cannot be blank. If you don't want" +
" to set it, just remove the tableName property."
- val ENTITY_TABLE_NAME_CANNOT_START_WITH_SQLITE =
+ const val ENTITY_TABLE_NAME_CANNOT_START_WITH_SQLITE =
"Entity table name cannot start with \"sqlite_\"."
- val VIEW_MUST_BE_ANNOTATED_WITH_DATABASE_VIEW =
+ const val VIEW_MUST_BE_ANNOTATED_WITH_DATABASE_VIEW =
"View class must be annotated with " + "@DatabaseView"
- val VIEW_NAME_CANNOT_BE_EMPTY =
+ const val VIEW_NAME_CANNOT_BE_EMPTY =
"View name cannot be blank. If you don't want" +
" to set it, just remove the viewName property."
- val VIEW_NAME_CANNOT_START_WITH_SQLITE = "View name cannot start with \"sqlite_\"."
- val VIEW_QUERY_MUST_BE_SELECT = "Query for @DatabaseView must be a SELECT."
- val VIEW_QUERY_CANNOT_TAKE_ARGUMENTS = "Query for @DatabaseView cannot take any arguments."
+ const val VIEW_NAME_CANNOT_START_WITH_SQLITE = "View name cannot start with \"sqlite_\"."
+ const val VIEW_QUERY_MUST_BE_SELECT = "Query for @DatabaseView must be a SELECT."
+ const val VIEW_QUERY_CANNOT_TAKE_ARGUMENTS =
+ "Query for @DatabaseView cannot take any arguments."
fun viewCircularReferenceDetected(views: List<String>): String {
return "Circular reference detected among views: ${views.joinToString(", ")}"
}
- val CANNOT_BIND_QUERY_PARAMETER_INTO_STMT =
- "Query method parameters should either be a" +
+ const val CANNOT_BIND_QUERY_PARAMETER_INTO_STMT =
+ "Query function parameters should either be a" +
" type that can be converted into a database column or a List / Array that contains" +
" such type. You can consider adding a Type Adapter for this."
- val QUERY_PARAMETERS_CANNOT_START_WITH_UNDERSCORE =
- "Query/Insert method parameters cannot " + "start with underscore (_)."
+ const val QUERY_PARAMETERS_CANNOT_START_WITH_UNDERSCORE =
+ "Query/Insert function parameters cannot " + "start with underscore (_)."
fun cannotFindQueryResultAdapter(returnTypeName: String) =
- "Not sure how to convert the query result to this method's return type ($returnTypeName)."
+ "Not sure how to convert the query result to this function's return type ($returnTypeName)."
fun classMustImplementEqualsAndHashCode(keyType: String) =
"The key" +
- " of the provided method's multimap return type must implement equals() and " +
+ " of the provided function's multimap return type must implement equals() and " +
"hashCode(). Key type is: $keyType."
- val INSERT_DOES_NOT_HAVE_ANY_PARAMETERS_TO_INSERT =
- "Method annotated with" + " @Insert but does not have any parameters to insert."
+ const val INSERT_DOES_NOT_HAVE_ANY_PARAMETERS_TO_INSERT =
+ "Function annotated with" + " @Insert but does not have any parameters to insert."
- val UPSERT_DOES_NOT_HAVE_ANY_PARAMETERS_TO_UPSERT =
- "Method annotated with" + " @Upsert but does not have any parameters to insert or update."
+ const val UPSERT_DOES_NOT_HAVE_ANY_PARAMETERS_TO_UPSERT =
+ "Function annotated with" + " @Upsert but does not have any parameters to insert or update."
- val DELETE_MISSING_PARAMS =
- "Method annotated with" + " @Delete but does not have any parameters to delete."
+ const val DELETE_MISSING_PARAMS =
+ "Function annotated with" + " @Delete but does not have any parameters to delete."
fun cannotMapSpecifiedColumn(column: String, columnsInQuery: List<String>, annotation: String) =
"Column specified in the provided @$annotation annotation must be present in the query. " +
"Provided: $column. Columns found: ${columnsInQuery.joinToString(", ")}"
- val MAP_INFO_MUST_HAVE_AT_LEAST_ONE_COLUMN_PROVIDED =
+ const val MAP_INFO_MUST_HAVE_AT_LEAST_ONE_COLUMN_PROVIDED =
"To use the @MapInfo annotation, you " +
"must provide either the key column name, value column name, or both."
fun mayNeedMapColumn(columnArg: String): String {
return """
Looks like you may need to use @MapColumn to clarify the 'columnName' needed for
- type argument(s) in the return type of a method. Type argument that needs
+ type argument(s) in the return type of a function. Type argument that needs
@MapColumn: $columnArg
"""
.trim()
}
- val CANNOT_FIND_DELETE_RESULT_ADAPTER =
- "Not sure how to handle delete method's " +
+ const val CANNOT_FIND_DELETE_RESULT_ADAPTER =
+ "Not sure how to handle delete function's " +
"return type. Currently the supported return types are void, int or Int."
- val CANNOT_FIND_UPDATE_RESULT_ADAPTER =
- "Not sure how to handle update method's " +
+ const val CANNOT_FIND_UPDATE_RESULT_ADAPTER =
+ "Not sure how to handle update function's " +
"return type. Currently the supported return types are void, int or Int."
fun suspendReturnsDeferredType(returnTypeName: String) =
@@ -198,105 +202,107 @@
"modifier must not return a deferred/async type ($returnTypeName). Most probably this " +
"is an error. Consider changing the return type or removing the suspend modifier."
- val CANNOT_FIND_INSERT_RESULT_ADAPTER = "Not sure how to handle insert method's return type."
+ const val CANNOT_FIND_INSERT_RESULT_ADAPTER =
+ "Not sure how to handle insert function's return type."
- val CANNOT_FIND_UPSERT_RESULT_ADAPTER = "Not sure how to handle upsert method's return type."
+ const val CANNOT_FIND_UPSERT_RESULT_ADAPTER =
+ "Not sure how to handle upsert function's return type."
- val INSERT_MULTI_PARAM_SINGLE_RETURN_MISMATCH =
- "Insert method accepts multiple parameters " +
+ const val INSERT_MULTI_PARAM_SINGLE_RETURN_MISMATCH =
+ "Insert function accepts multiple parameters " +
"but the return type is a single element. Try using a multiple element return type."
- val UPSERT_MULTI_PARAM_SINGLE_RETURN_MISMATCH =
- "Upsert method accepts multiple parameters " +
+ const val UPSERT_MULTI_PARAM_SINGLE_RETURN_MISMATCH =
+ "Upsert function accepts multiple parameters " +
"but the return type is a single element. Try using a multiple element return type."
- val INSERT_SINGLE_PARAM_MULTI_RETURN_MISMATCH =
- "Insert method accepts a single parameter " +
+ const val INSERT_SINGLE_PARAM_MULTI_RETURN_MISMATCH =
+ "Insert function accepts a single parameter " +
"but the return type is a collection of elements. Try using a single element return type."
- val UPSERT_SINGLE_PARAM_MULTI_RETURN_MISMATCH =
- "Upsert method accepts a single parameter " +
+ const val UPSERT_SINGLE_PARAM_MULTI_RETURN_MISMATCH =
+ "Upsert function accepts a single parameter " +
"but the return type is a collection of elements. Try using a single element return type."
- val UPDATE_MISSING_PARAMS =
- "Method annotated with" + " @Update but does not have any parameters to update."
+ const val UPDATE_MISSING_PARAMS =
+ "Function annotated with" + " @Update but does not have any parameters to update."
- val TRANSACTION_METHOD_MODIFIERS =
- "Method annotated with @Transaction must not be " +
- "private, final, or abstract. It can be abstract only if the method is also" +
+ const val TRANSACTION_FUNCTION_MODIFIERS =
+ "Function annotated with @Transaction must not be " +
+ "private, final, or abstract. It can be abstract only if the function is also" +
" annotated with @Query."
- fun nullableParamInShortcutMethod(param: String) =
- "Methods annotated with [@Insert, " +
+ fun nullableParamInShortcutFunction(param: String) =
+ "Functions annotated with [@Insert, " +
"@Upsert, @Update, @Delete] shouldn't declare nullable parameters ($param)."
- fun transactionMethodAsync(returnTypeName: String) =
- "Method annotated with @Transaction must" +
+ fun transactionFunctionAsync(returnTypeName: String) =
+ "Function annotated with @Transaction must" +
" not return deferred/async return type $returnTypeName. Since transactions are" +
- " thread confined and Room cannot guarantee that all queries in the method" +
+ " thread confined and Room cannot guarantee that all queries in the function" +
" implementation are performed on the same thread, only synchronous @Transaction" +
- " implemented methods are allowed. If a transaction is started and a change of thread" +
+ " implemented functions are allowed. If a transaction is started and a change of thread" +
" is done and waited upon then a database deadlock can occur if the additional thread" +
" attempts to perform a query. This restrictions prevents such situation from" +
" occurring."
- val TRANSACTION_MISSING_ON_RELATION =
+ const val TRANSACTION_MISSING_ON_RELATION =
"The return value includes a data class with a @Relation." +
- " It is usually desired to annotate this method with @Transaction to avoid" +
+ " It is usually desired to annotate this function with @Transaction to avoid" +
" possibility of inconsistent results between the data class and its relations. See " +
TRANSACTION_REFERENCE_DOCS +
" for details."
- val CANNOT_FIND_ENTITY_FOR_SHORTCUT_QUERY_PARAMETER =
+ const val CANNOT_FIND_ENTITY_FOR_SHORTCUT_QUERY_PARAMETER =
"Type of the parameter must be a class " +
"annotated with @Entity or a collection/array of it."
val DB_MUST_EXTEND_ROOM_DB =
"Classes annotated with @Database should extend " + ROOM_DB.canonicalName
- val OBSERVABLE_QUERY_NOTHING_TO_OBSERVE =
+ const val OBSERVABLE_QUERY_NOTHING_TO_OBSERVE =
"Observable query return type (LiveData, Flowable" +
", DataSource, DataSourceFactory etc) can only be used with SELECT queries that" +
" directly or indirectly (via @Relation, for example) access at least one table. For" +
" @RawQuery, you should specify the list of tables to be observed via the" +
" observedEntities field."
- val RECURSIVE_REFERENCE_DETECTED =
+ const val RECURSIVE_REFERENCE_DETECTED =
"Recursive referencing through @Embedded and/or @Relation " + "detected: %s"
- private val TOO_MANY_MATCHING_GETTERS =
+ private const val TOO_MANY_MATCHING_GETTERS =
"Ambiguous getter for %s. All of the following " +
"match: %s. You can @Ignore the ones that you don't want to match."
- fun tooManyMatchingGetters(field: Field, methodNames: List<String>): String {
- return TOO_MANY_MATCHING_GETTERS.format(field, methodNames.joinToString(", "))
+ fun tooManyMatchingGetters(field: Field, functionNames: List<String>): String {
+ return TOO_MANY_MATCHING_GETTERS.format(field, functionNames.joinToString(", "))
}
- private val TOO_MANY_MATCHING_SETTERS =
+ private const val TOO_MANY_MATCHING_SETTERS =
"Ambiguous setter for %s. All of the following " +
"match: %s. You can @Ignore the ones that you don't want to match."
- fun tooManyMatchingSetter(field: Field, methodNames: List<String>): String {
- return TOO_MANY_MATCHING_SETTERS.format(field, methodNames.joinToString(", "))
+ fun tooManyMatchingSetter(field: Field, functionNames: List<String>): String {
+ return TOO_MANY_MATCHING_SETTERS.format(field, functionNames.joinToString(", "))
}
- val CANNOT_FIND_COLUMN_TYPE_ADAPTER =
+ const val CANNOT_FIND_COLUMN_TYPE_ADAPTER =
"Cannot figure out how to save this field into" +
" database. You can consider adding a type converter for it."
- val VALUE_CLASS_ONLY_SUPPORTED_IN_KSP =
+ const val VALUE_CLASS_ONLY_SUPPORTED_IN_KSP =
"Kotlin value classes are only supported " +
"in Room using KSP and generating Kotlin (room.generateKotlin=true)."
- val CANNOT_FIND_STMT_BINDER = "Cannot figure out how to bind this field into a statement."
+ const val CANNOT_FIND_STMT_BINDER = "Cannot figure out how to bind this field into a statement."
- val CANNOT_FIND_STMT_READER = "Cannot figure out how to read this field from a statement."
+ const val CANNOT_FIND_STMT_READER = "Cannot figure out how to read this field from a statement."
const val DEFAULT_VALUE_NULLABILITY = "Use of NULL as the default value of a non-null field"
- private val MISSING_PARAMETER_FOR_BIND =
+ private const val MISSING_PARAMETER_FOR_BIND =
"Each bind variable in the query must have a" +
- " matching method parameter. Cannot find method parameters for %s."
+ " matching function parameter. Cannot find function parameters for %s."
fun missingParameterForBindVariable(bindVarName: List<String>): String {
return MISSING_PARAMETER_FOR_BIND.format(bindVarName.joinToString(", "))
@@ -307,30 +313,30 @@
"Found $mapValueTypeName."
}
- private val UNUSED_QUERY_METHOD_PARAMETER = "Unused parameter%s: %s"
+ private const val UNUSED_QUERY_FUNCTION_PARAMETER = "Unused parameter%s: %s"
- fun unusedQueryMethodParameter(unusedParams: List<String>): String {
- return UNUSED_QUERY_METHOD_PARAMETER.format(
+ fun unusedQueryFunctionParameter(unusedParams: List<String>): String {
+ return UNUSED_QUERY_FUNCTION_PARAMETER.format(
if (unusedParams.size > 1) "s" else "",
unusedParams.joinToString(",")
)
}
- private val DUPLICATE_TABLES_OR_VIEWS =
+ private const val DUPLICATE_TABLES_OR_VIEWS =
"The name \"%s\" is used by multiple entities or views: %s"
fun duplicateTableNames(tableName: String, entityNames: List<String>): String {
return DUPLICATE_TABLES_OR_VIEWS.format(tableName, entityNames.joinToString(", "))
}
- val DAO_METHOD_CONFLICTS_WITH_OTHERS = "Dao method has conflicts."
+ const val DAO_FUNCTION_CONFLICTS_WITH_OTHERS = "Dao function has conflicts."
- fun duplicateDao(dao: String, methodNames: List<String>): String {
+ fun duplicateDao(dao: String, functionNames: List<String>): String {
return """
- All of these functions [${methodNames.joinToString(", ")}] return the same DAO
+ All of these functions [${functionNames.joinToString(", ")}] return the same DAO
class [$dao].
- A database can use a DAO only once so you should remove ${methodNames.size - 1} of
- these conflicting DAO methods. If you are implementing any of these to fulfill an
+ A database can use a DAO only once so you should remove ${functionNames.size - 1} of
+ these conflicting DAO functions. If you are implementing any of these to fulfill an
interface, don't make it abstract, instead, implement the code that calls the
other one.
"""
@@ -369,7 +375,7 @@
The query returns some columns [${unusedColumns.joinToString(", ")}] which are not
used by $dataClassNames. You can use @ColumnInfo annotation on the fields to specify
the mapping.
- You can annotate the method with @RewriteQueriesToDropUnusedColumns to direct Room
+ You can annotate the function with @RewriteQueriesToDropUnusedColumns to direct Room
to rewrite your query to avoid fetching unused columns.
"""
.trim()
@@ -389,28 +395,28 @@
return """
$unusedColumnsWarning
${unusedFieldsWarning.joinToString(separator = " ")}
- You can suppress this warning by annotating the method with
+ You can suppress this warning by annotating the function with
@SuppressWarnings(RoomWarnings.QUERY_MISMATCH).
Columns returned by the query: ${allColumns.joinToString(", ")}.
"""
.trim()
}
- val TYPE_CONVERTER_UNBOUND_GENERIC = "Cannot use unbound generics in Type Converters."
- val TYPE_CONVERTER_BAD_RETURN_TYPE = "Invalid return type for a type converter."
- val TYPE_CONVERTER_MUST_RECEIVE_1_PARAM = "Type converters must receive 1 parameter."
- val TYPE_CONVERTER_EMPTY_CLASS =
- "Class is referenced as a converter but it does not have any" + " converter methods."
- val TYPE_CONVERTER_MISSING_NOARG_CONSTRUCTOR =
+ const val TYPE_CONVERTER_UNBOUND_GENERIC = "Cannot use unbound generics in Type Converters."
+ const val TYPE_CONVERTER_BAD_RETURN_TYPE = "Invalid return type for a type converter."
+ const val TYPE_CONVERTER_MUST_RECEIVE_1_PARAM = "Type converters must receive 1 parameter."
+ const val TYPE_CONVERTER_EMPTY_CLASS =
+ "Class is referenced as a converter but it does not have any" + " converter functions."
+ const val TYPE_CONVERTER_MISSING_NOARG_CONSTRUCTOR =
"Classes that are used as TypeConverters must" +
" have no-argument public constructors. Use a ProvidedTypeConverter annotation if you" +
" need to take control over creating an instance of a TypeConverter."
- val TYPE_CONVERTER_MUST_BE_PUBLIC = "Type converters must be public."
- val INNER_CLASS_TYPE_CONVERTER_MUST_BE_STATIC =
+ const val TYPE_CONVERTER_MUST_BE_PUBLIC = "Type converters must be public."
+ const val INNER_CLASS_TYPE_CONVERTER_MUST_BE_STATIC =
"An inner class TypeConverter must be " + "static."
fun duplicateTypeConverters(converters: List<CustomTypeConverter>): String {
- return "Multiple methods define the same conversion. Conflicts with these:" +
+ return "Multiple functions define the same conversion. Conflicts with these:" +
" ${converters.joinToString(", ") { it.toString() }}"
}
@@ -419,7 +425,7 @@
}
// TODO must print field paths.
- val DATA_CLASS_FIELD_HAS_DUPLICATE_COLUMN_NAME = "Field has non-unique column name."
+ const val DATA_CLASS_FIELD_HAS_DUPLICATE_COLUMN_NAME = "Field has non-unique column name."
fun dataClassDuplicateFieldNames(columnName: String, fieldPaths: List<String>): String {
return "Multiple fields have the same columnName: $columnName." +
@@ -431,7 +437,7 @@
entityQName
}
- val INDEX_COLUMNS_CANNOT_BE_EMPTY = "List of columns in an index cannot be empty"
+ const val INDEX_COLUMNS_CANNOT_BE_EMPTY = "List of columns in an index cannot be empty"
fun indexColumnDoesNotExist(columnName: String, allColumns: List<String>): String {
return "$columnName referenced in the index does not exist in the Entity." +
@@ -478,7 +484,7 @@
" Alternatively, you can set inheritSuperIndices to true in the @Entity annotation."
}
- val NOT_ENTITY_OR_VIEW = "The class must be either @Entity or @DatabaseView."
+ const val NOT_ENTITY_OR_VIEW = "The class must be either @Entity or @DatabaseView."
fun relationCannotFindEntityField(
entityName: String,
@@ -522,7 +528,7 @@
"full table scan when resolving the relationship, it is highly advised to " +
"create an index that covers this column."
- val RELATION_IN_ENTITY = "Entities cannot have relations."
+ const val RELATION_IN_ENTITY = "Entities cannot have relations."
fun relationAffinityMismatch(
parentColumn: String,
@@ -585,13 +591,13 @@
.trim()
}
- val MISSING_SCHEMA_EXPORT_DIRECTORY =
+ const val MISSING_SCHEMA_EXPORT_DIRECTORY =
"Schema export directory was not provided to the" +
" annotation processor so Room cannot export the schema. You can either provide" +
" `room.schemaLocation` annotation processor argument by applying the Room Gradle plugin" +
" (id 'androidx.room') OR set exportSchema to false."
- val INVALID_FOREIGN_KEY_ACTION =
+ const val INVALID_FOREIGN_KEY_ACTION =
"Invalid foreign key action. It must be one of the constants" +
" defined in ForeignKey.Action"
@@ -603,7 +609,7 @@
.trim()
}
- val FOREIGN_KEY_CANNOT_FIND_PARENT = "Cannot find parent entity class."
+ const val FOREIGN_KEY_CANNOT_FIND_PARENT = "Cannot find parent entity class."
fun foreignKeyChildColumnDoesNotExist(columnName: String, allColumns: List<String>): String {
return "($columnName) referenced in the foreign key does not exist in the Entity." +
@@ -619,9 +625,11 @@
" ${allColumns.joinToString(",")}"
}
- val FOREIGN_KEY_EMPTY_CHILD_COLUMN_LIST = "Must specify at least 1 column name for the child"
+ const val FOREIGN_KEY_EMPTY_CHILD_COLUMN_LIST =
+ "Must specify at least 1 column name for the child"
- val FOREIGN_KEY_EMPTY_PARENT_COLUMN_LIST = "Must specify at least 1 column name for the parent"
+ const val FOREIGN_KEY_EMPTY_PARENT_COLUMN_LIST =
+ "Must specify at least 1 column name for the parent"
fun foreignKeyColumnNumberMismatch(
childColumns: List<String>,
@@ -687,33 +695,33 @@
.trim()
}
- val MISSING_ROOM_GUAVA_ARTIFACT =
+ const val MISSING_ROOM_GUAVA_ARTIFACT =
"To use Guava features, you must add `guava`" +
" artifact from Room as a dependency. androidx.room:room-guava:<version>"
- val MISSING_ROOM_RXJAVA2_ARTIFACT =
+ const val MISSING_ROOM_RXJAVA2_ARTIFACT =
"To use RxJava2 features, you must add `rxjava2`" +
" artifact from Room as a dependency. androidx.room:room-rxjava2:<version>"
- val MISSING_ROOM_RXJAVA3_ARTIFACT =
+ const val MISSING_ROOM_RXJAVA3_ARTIFACT =
"To use RxJava3 features, you must add `rxjava3`" +
" artifact from Room as a dependency. androidx.room:room-rxjava3:<version>"
- val MISSING_ROOM_PAGING_ARTIFACT =
+ const val MISSING_ROOM_PAGING_ARTIFACT =
"To use PagingSource, you must add `room-paging`" +
" artifact from Room as a dependency. androidx.room:room-paging:<version>"
- val MISSING_ROOM_PAGING_GUAVA_ARTIFACT =
+ const val MISSING_ROOM_PAGING_GUAVA_ARTIFACT =
"To use ListenableFuturePagingSource, you must " +
"add `room-paging-guava` artifact from Room as a dependency. " +
"androidx.room:room-paging-guava:<version>"
- val MISSING_ROOM_PAGING_RXJAVA2_ARTIFACT =
+ const val MISSING_ROOM_PAGING_RXJAVA2_ARTIFACT =
"To use RxPagingSource, you must " +
"add `room-paging-rxjava2` artifact from Room as a dependency. " +
"androidx.room:room-paging-rxjava2:<version>"
- val MISSING_ROOM_PAGING_RXJAVA3_ARTIFACT =
+ const val MISSING_ROOM_PAGING_RXJAVA3_ARTIFACT =
"To use RxPagingSource, you must " +
"add `room-paging-rxjava3` artifact from Room as a dependency. " +
"androidx.room:room-paging-rxjava3:<version>"
@@ -753,12 +761,13 @@
"""
.trim()
- val PAGING_SPECIFY_DATA_SOURCE_TYPE = "For now, Room only supports PositionalDataSource class."
+ const val PAGING_SPECIFY_DATA_SOURCE_TYPE =
+ "For now, Room only supports PositionalDataSource class."
- val PAGING_SPECIFY_PAGING_SOURCE_TYPE =
+ const val PAGING_SPECIFY_PAGING_SOURCE_TYPE =
"For now, Room only supports PagingSource with Key of" + " type Int."
- val PAGING_SPECIFY_PAGING_SOURCE_VALUE_TYPE =
+ const val PAGING_SPECIFY_PAGING_SOURCE_VALUE_TYPE =
"For now, Room only supports PagingSource with" + " Value that is not of Collection type."
fun primaryKeyNull(field: String): String {
@@ -768,13 +777,14 @@
"https://www.sqlite.org/lang_createtable.html"
}
- val INVALID_COLUMN_NAME =
+ const val INVALID_COLUMN_NAME =
"Invalid column name. Room does not allow using ` or \" in column" + " names"
- val INVALID_TABLE_NAME = "Invalid table name. Room does not allow using ` or \" in table names"
+ const val INVALID_TABLE_NAME =
+ "Invalid table name. Room does not allow using ` or \" in table names"
- val RAW_QUERY_BAD_PARAMS =
- "RawQuery methods should have 1 and only 1 parameter with type" + " SupportSQLiteQuery"
+ const val RAW_QUERY_BAD_PARAMS =
+ "RawQuery functions should have 1 and only 1 parameter with type" + " SupportSQLiteQuery"
fun parameterCannotBeNullable(parameterName: String) =
"""
@@ -782,7 +792,7 @@
"""
.trimIndent()
- val RAW_QUERY_BAD_RETURN_TYPE = "RawQuery methods must return a non-void type."
+ const val RAW_QUERY_BAD_RETURN_TYPE = "RawQuery functions must return a non-void type."
fun rawQueryBadEntity(typeName: String): String {
return """
@@ -798,43 +808,45 @@
"@RawQuery does not allow passing a string anymore." +
" Please use ${RoomTypeNames.RAW_QUERY.canonicalName}."
- val MISSING_COPY_ANNOTATIONS =
+ const val MISSING_COPY_ANNOTATIONS =
"Annotated property getter is missing " + "@AutoValue.CopyAnnotations."
fun invalidAnnotationTarget(annotationName: String, elementKindName: String): String {
return "@$annotationName is not allowed in this $elementKindName."
}
- val INDICES_IN_FTS_ENTITY = "Indices not allowed in FTS Entity."
+ const val INDICES_IN_FTS_ENTITY = "Indices not allowed in FTS Entity."
- val FOREIGN_KEYS_IN_FTS_ENTITY = "Foreign Keys not allowed in FTS Entity."
+ const val FOREIGN_KEYS_IN_FTS_ENTITY = "Foreign Keys not allowed in FTS Entity."
- val MISSING_PRIMARY_KEYS_ANNOTATION_IN_ROW_ID =
+ const val MISSING_PRIMARY_KEYS_ANNOTATION_IN_ROW_ID =
"The field with column name 'rowid' in " +
"an FTS entity must be annotated with @PrimaryKey."
- val TOO_MANY_PRIMARY_KEYS_IN_FTS_ENTITY = "An FTS entity can only have a single primary key."
+ const val TOO_MANY_PRIMARY_KEYS_IN_FTS_ENTITY =
+ "An FTS entity can only have a single primary key."
- val INVALID_FTS_ENTITY_PRIMARY_KEY_NAME =
+ const val INVALID_FTS_ENTITY_PRIMARY_KEY_NAME =
"The single primary key field in an FTS entity " +
"must either be named 'rowid' or must be annotated with @ColumnInfo(name = \"rowid\")"
- val INVALID_FTS_ENTITY_PRIMARY_KEY_AFFINITY =
+ const val INVALID_FTS_ENTITY_PRIMARY_KEY_AFFINITY =
"The single @PrimaryKey annotated field in an " + "FTS entity must be of INTEGER affinity."
fun missingLanguageIdField(columnName: String) =
- "The specified 'languageid' column: " + "\"$columnName\", was not found."
+ "The specified 'languageid' column: \"$columnName\", was not found."
- val INVALID_FTS_ENTITY_LANGUAGE_ID_AFFINITY =
+ const val INVALID_FTS_ENTITY_LANGUAGE_ID_AFFINITY =
"The 'languageid' field must be of INTEGER " + "affinity."
fun missingNotIndexedField(missingNotIndexedColumns: List<String>) =
"Non-existent columns are specified to be not indexed in notIndexed: " +
missingNotIndexedColumns.joinToString(",")
- val INVALID_FTS_ENTITY_PREFIX_SIZES = "Prefix sizes to index must non-zero positive values."
+ const val INVALID_FTS_ENTITY_PREFIX_SIZES =
+ "Prefix sizes to index must non-zero positive values."
- val FTS_EXTERNAL_CONTENT_CANNOT_FIND_ENTITY = "Cannot find external content entity class."
+ const val FTS_EXTERNAL_CONTENT_CANNOT_FIND_ENTITY = "Cannot find external content entity class."
fun externalContentNotAnEntity(className: String) =
"External content entity referenced in " +
@@ -855,10 +867,10 @@
"$entityName that matches with this partial entity field. If you don't wish to use " +
"the field then you can annotate it with @Ignore."
- val INVALID_TARGET_ENTITY_IN_SHORTCUT_METHOD =
+ const val INVALID_TARGET_ENTITY_IN_SHORTCUT_FUNCTION =
"Target entity declared in @Insert, @Update " + "or @Delete must be annotated with @Entity."
- val INVALID_RELATION_IN_PARTIAL_ENTITY = "Partial entities cannot have relations."
+ const val INVALID_RELATION_IN_PARTIAL_ENTITY = "Partial entities cannot have relations."
fun invalidQueryForSingleColumnArray(returnType: String) =
"If a DAO function has a " +
@@ -911,20 +923,20 @@
fun cannotFindPreparedQueryResultAdapter(returnType: String, type: QueryType) =
StringBuilder()
.apply {
- append("Not sure how to handle query method's return type ($returnType). ")
+ append("Not sure how to handle query function's return type ($returnType). ")
if (type == QueryType.INSERT) {
append(
- "INSERT query methods must either return void " +
+ "INSERT query functions must either return void " +
"or long (the rowid of the inserted row)."
)
} else if (type == QueryType.UPDATE) {
append(
- "UPDATE query methods must either return void " +
+ "UPDATE query functions must either return void " +
"or int (the number of updated rows)."
)
} else if (type == QueryType.DELETE) {
append(
- "DELETE query methods must either return void " +
+ "DELETE query functions must either return void " +
"or int (the number of deleted rows)."
)
}
@@ -968,8 +980,8 @@
"""
.trim()
- val DATABASE_INVALID_DAO_METHOD_RETURN_TYPE =
- "Abstract database methods must return a @Dao " + "annotated class or interface."
+ const val DATABASE_INVALID_DAO_FUNCTION_RETURN_TYPE =
+ "Abstract database functions must return a @Dao " + "annotated class or interface."
fun invalidEntityTypeInDatabaseAnnotation(typeName: String): String {
return "Invalid Entity type: $typeName. An entity in the database must be a class."
@@ -985,22 +997,22 @@
"an @AutoMigration annotation."
}
- val EMBEDDED_TYPES_MUST_BE_A_CLASS_OR_INTERFACE =
+ const val EMBEDDED_TYPES_MUST_BE_A_CLASS_OR_INTERFACE =
"The type of an Embedded field must be a " + "class or an interface."
- val RELATION_TYPE_MUST_BE_A_CLASS_OR_INTERFACE =
+ const val RELATION_TYPE_MUST_BE_A_CLASS_OR_INTERFACE =
"Entity type in a Relation must be a class " + "or an interface."
- fun shortcutMethodArgumentMustBeAClass(typeName: String): String {
+ fun shortcutFunctionArgumentMustBeAClass(typeName: String): String {
return "Invalid query argument: $typeName. It must be a class or an interface."
}
- val AUTOMIGRATION_SPEC_MUST_BE_CLASS = "The AutoMigration spec " + "type must be a class."
+ const val AUTOMIGRATION_SPEC_MUST_BE_CLASS = "The AutoMigration spec " + "type must be a class."
fun autoMigrationElementMustImplementSpec(spec: String): String {
- return "The AutoMigration spec " + "$spec must implement the AutoMigrationSpec interface."
+ return "The AutoMigration spec $spec must implement the AutoMigrationSpec interface."
}
- // TODO: (b/180389433) If the files don't exist the getSchemaFile() method should return
+ // TODO: (b/180389433) If the files don't exist the getSchemaFile() function should return
// null and before calling process
fun autoMigrationToVersionMustBeGreaterThanFrom(to: Int, from: Int) =
if (from > to) {
@@ -1147,10 +1159,10 @@
return "Conflicting @RenameColumn annotations found: [$annotations]"
}
- val AUTO_MIGRATION_FOUND_BUT_EXPORT_SCHEMA_OFF =
+ const val AUTO_MIGRATION_FOUND_BUT_EXPORT_SCHEMA_OFF =
"Cannot create auto migrations when " + "exportSchema is false."
- val AUTO_MIGRATION_SCHEMA_IN_FOLDER_NULL =
+ const val AUTO_MIGRATION_SCHEMA_IN_FOLDER_NULL =
"Schema import directory was not provided to the" +
" annotation processor so Room cannot read older schemas. To generate auto migrations," +
" you must provide `room.schemaLocation` annotation processor arguments by applying the" +
@@ -1162,15 +1174,15 @@
" a different name."
}
- val INNER_CLASS_AUTOMIGRATION_SPEC_MUST_BE_STATIC =
+ const val INNER_CLASS_AUTOMIGRATION_SPEC_MUST_BE_STATIC =
"An inner class AutoMigrationSpec must be" + " static."
- val AUTOMIGRATION_SPEC_MISSING_NOARG_CONSTRUCTOR =
+ const val AUTOMIGRATION_SPEC_MISSING_NOARG_CONSTRUCTOR =
"Classes that are used as " +
"AutoMigrationSpec " +
"implementations must have no-argument public constructors."
- val JVM_NAME_ON_OVERRIDDEN_METHOD =
+ const val JVM_NAME_ON_OVERRIDDEN_FUNCTION =
"Using @JvmName annotation on a function or accessor " +
"that will be overridden by Room is not supported. If this is important for your use " +
"case, please file a bug at $ISSUE_TRACKER_LINK with details."
@@ -1198,7 +1210,7 @@
return "The column '$columnName' $locationDesc is ambiguous and cannot be properly " +
"resolved. Please alias the column and $recommendation. Otherwise there is a risk of " +
"the query returning invalid values. You can suppress this warning by annotating " +
- "the method with @SuppressWarnings(RoomWarnings.AMBIGUOUS_COLUMN_IN_RESULT)."
+ "the function with @SuppressWarnings(RoomWarnings.AMBIGUOUS_COLUMN_IN_RESULT)."
}
enum class AmbiguousColumnLocation {
@@ -1207,25 +1219,25 @@
ENTITY,
}
- val NONNULL_VOID =
+ const val NONNULL_VOID =
"Invalid non-null declaration of 'Void', should be nullable. The 'Void' " +
"class represents a placeholder type that is uninstantiable and 'null' is always returned."
- fun nullableCollectionOrArrayReturnTypeInDaoMethod(
+ fun nullableCollectionOrArrayReturnTypeInDaoFunction(
typeName: String,
returnType: String
): String {
- return "The nullable `$returnType` ($typeName) return type in a DAO method is " +
+ return "The nullable `$returnType` ($typeName) return type in a DAO function is " +
"meaningless because Room will instead return an empty `$returnType` if no rows are " +
"returned from the query."
}
- fun nullableComponentInDaoMethodReturnType(typeName: String): String {
- return "The DAO method return type ($typeName) with the nullable type argument " +
+ fun nullableComponentInDaoFunctionReturnType(typeName: String): String {
+ return "The DAO function return type ($typeName) with the nullable type argument " +
"is meaningless because for now Room will never put a null value in a result."
}
- val EXPORTING_SCHEMA_TO_RESOURCES =
+ const val EXPORTING_SCHEMA_TO_RESOURCES =
"Schema export is set to be outputted as a resource" +
" (i.e. room.exportSchemaResource is set to true), this means Room will write the current" +
" schema version file into the produced JAR. Such flag must only be used for generating" +
@@ -1233,42 +1245,42 @@
" the schema file will end up in the final artifact which is typically not desired. This" +
" warning serves as a reminder to use room.exportSchemaResource cautiously."
- val INVALID_GRADLE_PLUGIN_AND_SCHEMA_LOCATION_OPTION =
+ const val INVALID_GRADLE_PLUGIN_AND_SCHEMA_LOCATION_OPTION =
"The Room Gradle plugin " +
"(id 'androidx.room') cannot be used with an explicit use of the annotation processor" +
"option `room.schemaLocation`, please remove the configuration of the option and " +
"configure the schema location via the plugin project extension: " +
"`room { schemaDirectory(...) }`."
- val INVALID_DATABASE_VERSION = "Database version must be greater than 0"
+ const val INVALID_DATABASE_VERSION = "Database version must be greater than 0"
- val JAVA_CODEGEN_ON_NON_ANDROID_TARGET =
+ const val JAVA_CODEGEN_ON_NON_ANDROID_TARGET =
"Cannot generate Java targeting a non-Android " +
"platform. To generate Java, you must only have Android as a target platform. " +
"To process a non-Android target platform, you must enable Kotlin code " +
"generation in KSP."
- val INVALID_BLOCKING_DAO_FUNCTION_NON_ANDROID =
+ const val INVALID_BLOCKING_DAO_FUNCTION_NON_ANDROID =
"Only suspend functions are allowed in DAOs" +
" declared in source sets targeting non-Android platforms."
val INVALID_KOTLIN_CODE_GEN_IN_JAVAC =
"${Context.BooleanProcessorOptions.GENERATE_KOTLIN.argName} can only be enabled in KSP."
- val RAW_QUERY_NOT_SUPPORTED_ON_NON_ANDROID =
+ const val RAW_QUERY_NOT_SUPPORTED_ON_NON_ANDROID =
"@RawQuery annotated DAO functions are currently not supported in source sets targeting " +
"non-Android platforms."
- val MISSING_CONSTRUCTED_BY_ANNOTATION =
+ const val MISSING_CONSTRUCTED_BY_ANNOTATION =
"The @Database class must be annotated with @ConstructedBy since the source is targeting " +
"non-Android platforms."
- val INVALID_CONSTRUCTED_BY_CLASS = "The @ConstructedBy 'value' must be a valid class."
+ const val INVALID_CONSTRUCTED_BY_CLASS = "The @ConstructedBy 'value' must be a valid class."
- val INVALID_CONSTRUCTED_BY_NOT_OBJECT =
+ const val INVALID_CONSTRUCTED_BY_NOT_OBJECT =
"The @ConstructedBy definition must be an 'object' declaration."
- val INVALID_CONSTRUCTED_BY_NOT_EXPECT =
+ const val INVALID_CONSTRUCTED_BY_NOT_EXPECT =
"The @ConstructedBy definition must be an 'expect' declaration."
fun invalidConstructedBySuperInterface(expected: String) =
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/processor/QueryMethodProcessor.kt b/room/room-compiler/src/main/kotlin/androidx/room/processor/QueryFunctionProcessor.kt
similarity index 88%
rename from room/room-compiler/src/main/kotlin/androidx/room/processor/QueryMethodProcessor.kt
rename to room/room-compiler/src/main/kotlin/androidx/room/processor/QueryFunctionProcessor.kt
index f01ca3d..1304860 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/processor/QueryMethodProcessor.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/processor/QueryFunctionProcessor.kt
@@ -33,13 +33,13 @@
import androidx.room.verifier.DatabaseVerificationErrors
import androidx.room.verifier.DatabaseVerifier
import androidx.room.vo.MapInfo
-import androidx.room.vo.QueryMethod
+import androidx.room.vo.QueryFunction
import androidx.room.vo.QueryParameter
-import androidx.room.vo.ReadQueryMethod
+import androidx.room.vo.ReadQueryFunction
import androidx.room.vo.Warning
-import androidx.room.vo.WriteQueryMethod
+import androidx.room.vo.WriteQueryFunction
-class QueryMethodProcessor(
+class QueryFunctionProcessor(
baseContext: Context,
val containing: XType,
val executableElement: XMethodElement,
@@ -48,11 +48,11 @@
val context = baseContext.fork(executableElement)
/**
- * The processing of the method might happen in multiple steps if we decide to rewrite the query
- * after the first processing. To allow it while respecting the Context, it is implemented as a
- * sub procedure in [InternalQueryProcessor].
+ * The processing of the function might happen in multiple steps if we decide to rewrite the
+ * query after the first processing. To allow it while respecting the Context, it is implemented
+ * as a sub procedure in [InternalQueryProcessor].
*/
- fun process(): QueryMethod {
+ fun process(): QueryFunction {
val annotation = executableElement.getAnnotation(Query::class)?.value
context.checker.check(
annotation != null,
@@ -76,7 +76,7 @@
}
// check if want to swap the query for a better one
val finalResult =
- if (initialResult is ReadQueryMethod) {
+ if (initialResult is ReadQueryFunction) {
val resultAdapter = initialResult.queryResultBinder.adapter
val originalQuery = initialResult.query
val finalQuery =
@@ -112,8 +112,8 @@
val containing: XType,
val dbVerifier: DatabaseVerifier? = null
) {
- fun processQuery(input: String?): QueryMethod {
- val delegate = MethodProcessorDelegate.createFor(context, containing, executableElement)
+ fun processQuery(input: String?): QueryFunction {
+ val delegate = FunctionProcessorDelegate.createFor(context, containing, executableElement)
val returnType = delegate.extractReturnType()
val returnsDeferredType = delegate.returnsDeferredType()
@@ -156,23 +156,23 @@
context.checker.notUnbound(
returnType,
executableElement,
- ProcessorErrors.CANNOT_USE_UNBOUND_GENERICS_IN_QUERY_METHODS
+ ProcessorErrors.CANNOT_USE_UNBOUND_GENERICS_IN_QUERY_FUNCTIONS
)
val isPreparedQuery = PREPARED_TYPES.contains(query.type)
- val queryMethod =
+ val queryFunction =
if (isPreparedQuery) {
- getPreparedQueryMethod(delegate, returnType, query)
+ getPreparedQueryFunction(delegate, returnType, query)
} else {
- getQueryMethod(delegate, returnType, query)
+ getQueryFunction(delegate, returnType, query)
}
- return processQueryMethod(queryMethod)
+ return processQueryFunction(queryFunction)
}
- private fun processQueryMethod(queryMethod: QueryMethod): QueryMethod {
+ private fun processQueryFunction(queryFunction: QueryFunction): QueryFunction {
val missing =
- queryMethod.sectionToParamMapping.filter { it.second == null }.map { it.first.text }
+ queryFunction.sectionToParamMapping.filter { it.second == null }.map { it.first.text }
if (missing.isNotEmpty()) {
context.logger.e(
executableElement,
@@ -181,14 +181,19 @@
}
val unused =
- queryMethod.parameters
- .filterNot { param -> queryMethod.sectionToParamMapping.any { it.second == param } }
+ queryFunction.parameters
+ .filterNot { param ->
+ queryFunction.sectionToParamMapping.any { it.second == param }
+ }
.map(QueryParameter::sqlName)
if (unused.isNotEmpty()) {
- context.logger.e(executableElement, ProcessorErrors.unusedQueryMethodParameter(unused))
+ context.logger.e(
+ executableElement,
+ ProcessorErrors.unusedQueryFunctionParameter(unused)
+ )
}
- return queryMethod
+ return queryFunction
}
private fun validateQuery(query: ParsedQuery) {
@@ -205,11 +210,11 @@
}
}
- private fun getPreparedQueryMethod(
- delegate: MethodProcessorDelegate,
+ private fun getPreparedQueryFunction(
+ delegate: FunctionProcessorDelegate,
returnType: XType,
query: ParsedQuery
- ): WriteQueryMethod {
+ ): WriteQueryFunction {
val resultBinder = delegate.findPreparedResultBinder(returnType, query)
context.checker.check(
resultBinder.adapter != null,
@@ -221,7 +226,7 @@
)
val parameters = delegate.extractQueryParams(query)
- return WriteQueryMethod(
+ return WriteQueryFunction(
element = executableElement,
query = query,
returnType = returnType,
@@ -231,11 +236,11 @@
}
@Suppress("DEPRECATION") // Due to MapInfo usage
- private fun getQueryMethod(
- delegate: MethodProcessorDelegate,
+ private fun getQueryFunction(
+ delegate: FunctionProcessorDelegate,
returnType: XType,
query: ParsedQuery
- ): QueryMethod {
+ ): QueryFunction {
val resultBinder =
delegate.findResultBinder(returnType, query) {
delegate.executableElement.getAnnotation(androidx.room.MapInfo::class)?.let {
@@ -303,7 +308,7 @@
val parameters = delegate.extractQueryParams(query)
- return ReadQueryMethod(
+ return ReadQueryFunction(
element = executableElement,
query = query,
returnType = returnType,
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/processor/RawQueryMethodProcessor.kt b/room/room-compiler/src/main/kotlin/androidx/room/processor/RawQueryFunctionProcessor.kt
similarity index 93%
rename from room/room-compiler/src/main/kotlin/androidx/room/processor/RawQueryMethodProcessor.kt
rename to room/room-compiler/src/main/kotlin/androidx/room/processor/RawQueryFunctionProcessor.kt
index 158cb27..6b7ecef 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/processor/RawQueryMethodProcessor.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/processor/RawQueryFunctionProcessor.kt
@@ -28,17 +28,17 @@
import androidx.room.parser.SqlParser
import androidx.room.processor.ProcessorErrors.RAW_QUERY_STRING_PARAMETER_REMOVED
import androidx.room.vo.MapInfo
-import androidx.room.vo.RawQueryMethod
+import androidx.room.vo.RawQueryFunction
-class RawQueryMethodProcessor(
+class RawQueryFunctionProcessor(
baseContext: Context,
val containing: XType,
val executableElement: XMethodElement
) {
val context = baseContext.fork(executableElement)
- fun process(): RawQueryMethod {
- val delegate = MethodProcessorDelegate.createFor(context, containing, executableElement)
+ fun process(): RawQueryFunction {
+ val delegate = FunctionProcessorDelegate.createFor(context, containing, executableElement)
val returnType = delegate.extractReturnType()
context.checker.check(
@@ -50,7 +50,7 @@
context.checker.notUnbound(
returnType,
executableElement,
- ProcessorErrors.CANNOT_USE_UNBOUND_GENERICS_IN_QUERY_METHODS
+ ProcessorErrors.CANNOT_USE_UNBOUND_GENERICS_IN_QUERY_FUNCTIONS
)
val returnsDeferredType = delegate.returnsDeferredType()
@@ -91,8 +91,8 @@
val runtimeQueryParam = findRuntimeQueryParameter(delegate.extractParams())
val inTransaction = executableElement.hasAnnotation(Transaction::class)
- val rawQueryMethod =
- RawQueryMethod(
+ val rawQueryFunction =
+ RawQueryFunction(
element = executableElement,
observedTableNames = observedTableNames,
returnType = returnType,
@@ -102,11 +102,11 @@
)
// TODO: Lift this restriction, to allow for INSERT, UPDATE and DELETE raw statements.
context.checker.check(
- rawQueryMethod.returnsValue,
+ rawQueryFunction.returnsValue,
executableElement,
ProcessorErrors.RAW_QUERY_BAD_RETURN_TYPE
)
- return rawQueryMethod
+ return rawQueryFunction
}
private fun processObservedTables(): Set<String> {
@@ -151,7 +151,7 @@
private fun findRuntimeQueryParameter(
extractParams: List<XVariableElement>
- ): RawQueryMethod.RuntimeQueryParameter? {
+ ): RawQueryFunction.RuntimeQueryParameter? {
if (extractParams.size == 1 && !executableElement.isVarArgs()) {
val param = extractParams.first().asMemberOf(containing)
val processingEnv = context.processingEnv
@@ -167,7 +167,7 @@
processingEnv.findType(RoomTypeNames.RAW_QUERY)?.let { rawQueryType ->
if (rawQueryType.isAssignableFrom(param)) {
- return RawQueryMethod.RuntimeQueryParameter(
+ return RawQueryFunction.RuntimeQueryParameter(
paramName = extractParams[0].name,
typeName = rawQueryType.asTypeName()
)
@@ -176,7 +176,7 @@
processingEnv.findType(SupportDbTypeNames.QUERY)?.let { supportQueryType ->
if (supportQueryType.isAssignableFrom(param)) {
- return RawQueryMethod.RuntimeQueryParameter(
+ return RawQueryFunction.RuntimeQueryParameter(
paramName = extractParams[0].name,
typeName = supportQueryType.asTypeName()
)
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/processor/ShortcutMethodProcessor.kt b/room/room-compiler/src/main/kotlin/androidx/room/processor/ShortcutFunctionProcessor.kt
similarity index 92%
rename from room/room-compiler/src/main/kotlin/androidx/room/processor/ShortcutMethodProcessor.kt
rename to room/room-compiler/src/main/kotlin/androidx/room/processor/ShortcutFunctionProcessor.kt
index 6507652..2291a2c 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/processor/ShortcutMethodProcessor.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/processor/ShortcutFunctionProcessor.kt
@@ -27,14 +27,15 @@
import androidx.room.vo.findFieldByColumnName
import kotlin.reflect.KClass
-/** Common functionality for shortcut method processors */
-class ShortcutMethodProcessor(
+/** Common functionality for shortcut function processors */
+class ShortcutFunctionProcessor(
baseContext: Context,
val containing: XType,
val executableElement: XMethodElement
) {
val context = baseContext.fork(executableElement)
- private val delegate = MethodProcessorDelegate.createFor(context, containing, executableElement)
+ private val delegate =
+ FunctionProcessorDelegate.createFor(context, containing, executableElement)
fun <T : Annotation> extractAnnotation(klass: KClass<T>, errorMsg: String): XAnnotationBox<T>? {
val annotation = executableElement.getAnnotation(klass)
@@ -87,7 +88,7 @@
if (targetTypeElement == null) {
context.logger.e(
executableElement,
- ProcessorErrors.INVALID_TARGET_ENTITY_IN_SHORTCUT_METHOD
+ ProcessorErrors.INVALID_TARGET_ENTITY_IN_SHORTCUT_FUNCTION
)
null
} else {
@@ -96,7 +97,7 @@
onInvalid = {
context.logger.e(
executableElement,
- ProcessorErrors.INVALID_TARGET_ENTITY_IN_SHORTCUT_METHOD
+ ProcessorErrors.INVALID_TARGET_ENTITY_IN_SHORTCUT_FUNCTION
)
return emptyMap<String, ShortcutEntity>() to emptyList()
}
@@ -138,7 +139,7 @@
if (pojoTypeElement == null) {
context.logger.e(
targetEntity.element,
- ProcessorErrors.shortcutMethodArgumentMustBeAClass(
+ ProcessorErrors.shortcutFunctionArgumentMustBeAClass(
typeName =
param.pojoType.asTypeName().toString(context.codeLanguage)
)
@@ -229,12 +230,12 @@
null
}
- fun findInsertMethodBinder(returnType: XType, params: List<ShortcutQueryParameter>) =
- delegate.findInsertMethodBinder(returnType, params)
+ fun findInsertFunctionBinder(returnType: XType, params: List<ShortcutQueryParameter>) =
+ delegate.findInsertFunctionBinder(returnType, params)
- fun findUpsertMethodBinder(returnType: XType, params: List<ShortcutQueryParameter>) =
- delegate.findUpsertMethodBinder(returnType, params)
+ fun findUpsertFunctionBinder(returnType: XType, params: List<ShortcutQueryParameter>) =
+ delegate.findUpsertFunctionBinder(returnType, params)
- fun findDeleteOrUpdateMethodBinder(returnType: XType) =
- delegate.findDeleteOrUpdateMethodBinder(returnType)
+ fun findDeleteOrUpdateFunctionBinder(returnType: XType) =
+ delegate.findDeleteOrUpdateFunctionBinder(returnType)
}
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/processor/ShortcutParameterProcessor.kt b/room/room-compiler/src/main/kotlin/androidx/room/processor/ShortcutParameterProcessor.kt
index 9b3dfdf..765526f 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/processor/ShortcutParameterProcessor.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/processor/ShortcutParameterProcessor.kt
@@ -36,7 +36,7 @@
context.logger.e(
element = element,
msg =
- ProcessorErrors.nullableParamInShortcutMethod(
+ ProcessorErrors.nullableParamInShortcutFunction(
asMember.asTypeName().toString(context.codeLanguage)
)
)
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/processor/TransactionMethodProcessor.kt b/room/room-compiler/src/main/kotlin/androidx/room/processor/TransactionFunctionProcessor.kt
similarity index 83%
rename from room/room-compiler/src/main/kotlin/androidx/room/processor/TransactionMethodProcessor.kt
rename to room/room-compiler/src/main/kotlin/androidx/room/processor/TransactionFunctionProcessor.kt
index 8667172..3994d4f 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/processor/TransactionMethodProcessor.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/processor/TransactionFunctionProcessor.kt
@@ -21,9 +21,9 @@
import androidx.room.compiler.processing.XType
import androidx.room.compiler.processing.XTypeElement
import androidx.room.ext.DEFERRED_TYPES
-import androidx.room.vo.TransactionMethod
+import androidx.room.vo.TransactionFunction
-class TransactionMethodProcessor(
+class TransactionFunctionProcessor(
baseContext: Context,
val containingElement: XTypeElement,
val containingType: XType,
@@ -32,14 +32,15 @@
val context = baseContext.fork(executableElement)
- fun process(): TransactionMethod {
- val delegate = MethodProcessorDelegate.createFor(context, containingType, executableElement)
+ fun process(): TransactionFunction {
+ val delegate =
+ FunctionProcessorDelegate.createFor(context, containingType, executableElement)
val hasKotlinDefaultImpl = executableElement.hasKotlinDefaultImpl()
context.checker.check(
executableElement.isOverrideableIgnoringContainer() &&
(!executableElement.isAbstract() || hasKotlinDefaultImpl),
executableElement,
- ProcessorErrors.TRANSACTION_METHOD_MODIFIERS
+ ProcessorErrors.TRANSACTION_FUNCTION_MODIFIERS
)
val returnType = delegate.extractReturnType()
@@ -54,7 +55,7 @@
}
if (deferredReturnTypeName != null) {
context.logger.e(
- ProcessorErrors.transactionMethodAsync(
+ ProcessorErrors.transactionFunctionAsync(
deferredReturnTypeName.toString(context.codeLanguage)
),
executableElement
@@ -76,10 +77,10 @@
val callType =
when {
containingElement.isInterface() && executableElement.isJavaDefault() ->
- TransactionMethod.CallType.DEFAULT_JAVA8
+ TransactionFunction.CallType.DEFAULT_JAVA8
containingElement.isInterface() && hasKotlinDefaultImpl ->
- TransactionMethod.CallType.DEFAULT_KOTLIN
- else -> TransactionMethod.CallType.CONCRETE
+ TransactionFunction.CallType.DEFAULT_KOTLIN
+ else -> TransactionFunction.CallType.CONCRETE
}
val parameters = delegate.extractParams()
@@ -93,12 +94,12 @@
}
}
- return TransactionMethod(
+ return TransactionFunction(
element = executableElement,
returnType = returnType,
parameterNames = processedParamNames,
callType = callType,
- methodBinder = delegate.findTransactionMethodBinder(callType)
+ functionBinder = delegate.findTransactionFunctionBinder(callType)
)
}
}
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/processor/UpdateMethodProcessor.kt b/room/room-compiler/src/main/kotlin/androidx/room/processor/UpdateFunctionProcessor.kt
similarity index 87%
rename from room/room-compiler/src/main/kotlin/androidx/room/processor/UpdateMethodProcessor.kt
rename to room/room-compiler/src/main/kotlin/androidx/room/processor/UpdateFunctionProcessor.kt
index 15c1dd8..704b25d 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/processor/UpdateMethodProcessor.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/processor/UpdateFunctionProcessor.kt
@@ -20,18 +20,18 @@
import androidx.room.Update
import androidx.room.compiler.processing.XMethodElement
import androidx.room.compiler.processing.XType
-import androidx.room.vo.UpdateMethod
+import androidx.room.vo.UpdateFunction
import androidx.room.vo.findFieldByColumnName
-class UpdateMethodProcessor(
+class UpdateFunctionProcessor(
baseContext: Context,
val containing: XType,
val executableElement: XMethodElement
) {
val context = baseContext.fork(executableElement)
- fun process(): UpdateMethod {
- val delegate = ShortcutMethodProcessor(context, containing, executableElement)
+ fun process(): UpdateFunction {
+ val delegate = ShortcutFunctionProcessor(context, containing, executableElement)
val annotation =
delegate.extractAnnotation(Update::class, ProcessorErrors.MISSING_UPDATE_ANNOTATION)
@@ -63,19 +63,19 @@
)
val returnType = delegate.extractReturnType()
- val methodBinder = delegate.findDeleteOrUpdateMethodBinder(returnType)
+ val functionBinder = delegate.findDeleteOrUpdateFunctionBinder(returnType)
context.checker.check(
- methodBinder.adapter != null,
+ functionBinder.adapter != null,
executableElement,
ProcessorErrors.CANNOT_FIND_UPDATE_RESULT_ADAPTER
)
- return UpdateMethod(
+ return UpdateFunction(
element = delegate.executableElement,
entities = entities,
onConflictStrategy = onConflict,
- methodBinder = methodBinder,
+ functionBinder = functionBinder,
parameters = params
)
}
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/processor/UpsertMethodProcessor.kt b/room/room-compiler/src/main/kotlin/androidx/room/processor/UpsertFunctionProcessor.kt
similarity index 89%
rename from room/room-compiler/src/main/kotlin/androidx/room/processor/UpsertMethodProcessor.kt
rename to room/room-compiler/src/main/kotlin/androidx/room/processor/UpsertFunctionProcessor.kt
index b65836c..cf4eff5 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/processor/UpsertMethodProcessor.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/processor/UpsertFunctionProcessor.kt
@@ -19,18 +19,18 @@
import androidx.room.Upsert
import androidx.room.compiler.processing.XMethodElement
import androidx.room.compiler.processing.XType
-import androidx.room.vo.UpsertMethod
+import androidx.room.vo.UpsertFunction
import androidx.room.vo.findFieldByColumnName
-class UpsertMethodProcessor(
+class UpsertFunctionProcessor(
baseContext: Context,
val containing: XType,
val executableElement: XMethodElement
) {
val context = baseContext.fork(executableElement)
- fun process(): UpsertMethod {
- val delegate = ShortcutMethodProcessor(context, containing, executableElement)
+ fun process(): UpsertFunction {
+ val delegate = ShortcutFunctionProcessor(context, containing, executableElement)
val annotation =
delegate.extractAnnotation(Upsert::class, ProcessorErrors.MISSING_UPSERT_ANNOTATION)
@@ -39,7 +39,7 @@
context.checker.notUnbound(
returnType,
executableElement,
- ProcessorErrors.CANNOT_USE_UNBOUND_GENERICS_IN_UPSERT_METHODS
+ ProcessorErrors.CANNOT_USE_UNBOUND_GENERICS_IN_UPSERT_FUNCTIONS
)
val (entities, params) =
@@ -79,20 +79,20 @@
}
)
- val methodBinder = delegate.findUpsertMethodBinder(returnType, params)
+ val functionBinder = delegate.findUpsertFunctionBinder(returnType, params)
context.checker.check(
- methodBinder.adapter != null,
+ functionBinder.adapter != null,
executableElement,
ProcessorErrors.CANNOT_FIND_UPSERT_RESULT_ADAPTER
)
- return UpsertMethod(
+ return UpsertFunction(
element = executableElement,
returnType = returnType,
entities = entities,
parameters = params,
- methodBinder = methodBinder
+ functionBinder = functionBinder
)
}
}
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/solver/KotlinBoxedPrimitiveMethodDelegateBinder.kt b/room/room-compiler/src/main/kotlin/androidx/room/solver/KotlinBoxedPrimitiveFunctionDelegateBinder.kt
similarity index 86%
rename from room/room-compiler/src/main/kotlin/androidx/room/solver/KotlinBoxedPrimitiveMethodDelegateBinder.kt
rename to room/room-compiler/src/main/kotlin/androidx/room/solver/KotlinBoxedPrimitiveFunctionDelegateBinder.kt
index 32c2d77..07817be 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/solver/KotlinBoxedPrimitiveMethodDelegateBinder.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/solver/KotlinBoxedPrimitiveFunctionDelegateBinder.kt
@@ -22,18 +22,18 @@
import androidx.room.compiler.codegen.unbox
import androidx.room.compiler.processing.XType
import androidx.room.compiler.processing.isVoid
-import androidx.room.vo.KotlinBoxedPrimitiveMethodDelegate
+import androidx.room.vo.KotlinBoxedPrimitiveFunctionDelegate
/**
- * Method binder that delegates to a sibling DAO function in a Kotlin interface or abstract class
+ * Function binder that delegates to a sibling DAO function in a Kotlin interface or abstract class
* and specifically to a sibling function with unboxed primitive parameters.
*
- * @see [KotlinBoxedPrimitiveMethodDelegate]
+ * @see [KotlinBoxedPrimitiveFunctionDelegate]
*/
-object KotlinBoxedPrimitiveMethodDelegateBinder {
+object KotlinBoxedPrimitiveFunctionDelegateBinder {
fun execute(
- methodName: String,
+ functionName: String,
returnType: XType,
parameters: List<Pair<XTypeName, String>>,
scope: CodeGenScope
@@ -45,7 +45,7 @@
append("return ")
}
append("%L(")
- params.add(methodName)
+ params.add(functionName)
parameters.forEachIndexed { i, (typeName, name) ->
if (typeName.isPrimitive) {
append("(%T) %L")
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/solver/KotlinDefaultMethodDelegateBinder.kt b/room/room-compiler/src/main/kotlin/androidx/room/solver/KotlinDefaultFunctionDelegateBinder.kt
similarity index 85%
rename from room/room-compiler/src/main/kotlin/androidx/room/solver/KotlinDefaultMethodDelegateBinder.kt
rename to room/room-compiler/src/main/kotlin/androidx/room/solver/KotlinDefaultFunctionDelegateBinder.kt
index a83c58f..a1beae3 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/solver/KotlinDefaultMethodDelegateBinder.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/solver/KotlinDefaultFunctionDelegateBinder.kt
@@ -22,19 +22,19 @@
import androidx.room.compiler.processing.XType
import androidx.room.compiler.processing.isVoid
import androidx.room.ext.DEFAULT_IMPLS_CLASS_NAME
-import androidx.room.vo.KotlinDefaultMethodDelegate
+import androidx.room.vo.KotlinDefaultFunctionDelegate
/**
- * Method binder that delegates to concrete DAO function in a Kotlin interface, specifically to a
+ * Function binder that delegates to concrete DAO function in a Kotlin interface, specifically to a
* function where the implementation is in the DefaultImpl Kotlin generated class.
*
- * @see [KotlinDefaultMethodDelegate]
+ * @see [KotlinDefaultFunctionDelegate]
*/
-object KotlinDefaultMethodDelegateBinder {
+object KotlinDefaultFunctionDelegateBinder {
fun executeAndReturn(
daoName: XClassName,
daoImplName: XClassName,
- methodName: String,
+ functionName: String,
returnType: XType,
parameterNames: List<String>,
scope: CodeGenScope
@@ -48,7 +48,7 @@
append("%T.%L.%L(%T.this")
params.add(daoName)
params.add(DEFAULT_IMPLS_CLASS_NAME)
- params.add(methodName)
+ params.add(functionName)
params.add(daoImplName)
parameterNames.forEach {
append(", %L")
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/solver/TypeAdapterStore.kt b/room/room-compiler/src/main/kotlin/androidx/room/solver/TypeAdapterStore.kt
index b2a9f1a..1c364db 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/solver/TypeAdapterStore.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/solver/TypeAdapterStore.kt
@@ -90,18 +90,18 @@
import androidx.room.solver.query.result.SingleColumnRowAdapter
import androidx.room.solver.query.result.SingleItemQueryResultAdapter
import androidx.room.solver.query.result.SingleNamedColumnRowAdapter
-import androidx.room.solver.shortcut.binder.DeleteOrUpdateMethodBinder
-import androidx.room.solver.shortcut.binder.InsertOrUpsertMethodBinder
-import androidx.room.solver.shortcut.binderprovider.DeleteOrUpdateMethodBinderProvider
-import androidx.room.solver.shortcut.binderprovider.GuavaListenableFutureDeleteOrUpdateMethodBinderProvider
-import androidx.room.solver.shortcut.binderprovider.GuavaListenableFutureInsertOrUpsertMethodBinderProvider
-import androidx.room.solver.shortcut.binderprovider.InsertOrUpsertMethodBinderProvider
-import androidx.room.solver.shortcut.binderprovider.InstantDeleteOrUpdateMethodBinderProvider
-import androidx.room.solver.shortcut.binderprovider.InstantInsertOrUpsertMethodBinderProvider
-import androidx.room.solver.shortcut.binderprovider.RxCallableDeleteOrUpdateMethodBinderProvider
-import androidx.room.solver.shortcut.binderprovider.RxCallableInsertOrUpsertMethodBinderProvider
-import androidx.room.solver.shortcut.result.DeleteOrUpdateMethodAdapter
-import androidx.room.solver.shortcut.result.InsertOrUpsertMethodAdapter
+import androidx.room.solver.shortcut.binder.DeleteOrUpdateFunctionBinder
+import androidx.room.solver.shortcut.binder.InsertOrUpsertFunctionBinder
+import androidx.room.solver.shortcut.binderprovider.DeleteOrUpdateFunctionBinderProvider
+import androidx.room.solver.shortcut.binderprovider.GuavaListenableFutureDeleteOrUpdateFunctionBinderProvider
+import androidx.room.solver.shortcut.binderprovider.GuavaListenableFutureInsertOrUpsertFunctionBinderProvider
+import androidx.room.solver.shortcut.binderprovider.InsertOrUpsertFunctionBinderProvider
+import androidx.room.solver.shortcut.binderprovider.InstantDeleteOrUpdateFunctionBinderProvider
+import androidx.room.solver.shortcut.binderprovider.InstantInsertOrUpsertFunctionBinderProvider
+import androidx.room.solver.shortcut.binderprovider.RxCallableDeleteOrUpdateFunctionBinderProvider
+import androidx.room.solver.shortcut.binderprovider.RxCallableInsertOrUpsertFunctionBinderProvider
+import androidx.room.solver.shortcut.result.DeleteOrUpdateFunctionAdapter
+import androidx.room.solver.shortcut.result.InsertOrUpsertFunctionAdapter
import androidx.room.solver.types.BoxedBooleanToBoxedIntConverter
import androidx.room.solver.types.BoxedPrimitiveColumnTypeAdapter
import androidx.room.solver.types.ByteArrayColumnTypeAdapter
@@ -229,18 +229,18 @@
add(InstantPreparedQueryResultBinderProvider(context))
}
- private val insertOrUpsertBinderProviders: List<InsertOrUpsertMethodBinderProvider> =
- mutableListOf<InsertOrUpsertMethodBinderProvider>().apply {
- addAll(RxCallableInsertOrUpsertMethodBinderProvider.getAll(context))
- add(GuavaListenableFutureInsertOrUpsertMethodBinderProvider(context))
- add(InstantInsertOrUpsertMethodBinderProvider(context))
+ private val insertOrUpsertBinderProviders: List<InsertOrUpsertFunctionBinderProvider> =
+ mutableListOf<InsertOrUpsertFunctionBinderProvider>().apply {
+ addAll(RxCallableInsertOrUpsertFunctionBinderProvider.getAll(context))
+ add(GuavaListenableFutureInsertOrUpsertFunctionBinderProvider(context))
+ add(InstantInsertOrUpsertFunctionBinderProvider(context))
}
- private val deleteOrUpdateBinderProvider: List<DeleteOrUpdateMethodBinderProvider> =
- mutableListOf<DeleteOrUpdateMethodBinderProvider>().apply {
- addAll(RxCallableDeleteOrUpdateMethodBinderProvider.getAll(context))
- add(GuavaListenableFutureDeleteOrUpdateMethodBinderProvider(context))
- add(InstantDeleteOrUpdateMethodBinderProvider(context))
+ private val deleteOrUpdateBinderProvider: List<DeleteOrUpdateFunctionBinderProvider> =
+ mutableListOf<DeleteOrUpdateFunctionBinderProvider>().apply {
+ addAll(RxCallableDeleteOrUpdateFunctionBinderProvider.getAll(context))
+ add(GuavaListenableFutureDeleteOrUpdateFunctionBinderProvider(context))
+ add(InstantDeleteOrUpdateFunctionBinderProvider(context))
}
/** Searches 1 way to bind a value into a statement. */
@@ -419,23 +419,23 @@
}
}
- fun findDeleteOrUpdateMethodBinder(typeMirror: XType): DeleteOrUpdateMethodBinder {
+ fun findDeleteOrUpdateFunctionBinder(typeMirror: XType): DeleteOrUpdateFunctionBinder {
return deleteOrUpdateBinderProvider.first { it.matches(typeMirror) }.provide(typeMirror)
}
- fun findInsertMethodBinder(
+ fun findInsertFunctionBinder(
typeMirror: XType,
params: List<ShortcutQueryParameter>
- ): InsertOrUpsertMethodBinder {
+ ): InsertOrUpsertFunctionBinder {
return insertOrUpsertBinderProviders
.first { it.matches(typeMirror) }
.provide(typeMirror, params, false)
}
- fun findUpsertMethodBinder(
+ fun findUpsertFunctionBinder(
typeMirror: XType,
params: List<ShortcutQueryParameter>
- ): InsertOrUpsertMethodBinder {
+ ): InsertOrUpsertFunctionBinder {
return insertOrUpsertBinderProviders
.first { it.matches(typeMirror) }
.provide(typeMirror, params, true)
@@ -471,22 +471,22 @@
fun findPreparedQueryResultAdapter(typeMirror: XType, query: ParsedQuery) =
PreparedQueryResultAdapter.create(typeMirror, query.type)
- fun findDeleteOrUpdateAdapter(typeMirror: XType): DeleteOrUpdateMethodAdapter? {
- return DeleteOrUpdateMethodAdapter.create(typeMirror)
+ fun findDeleteOrUpdateAdapter(typeMirror: XType): DeleteOrUpdateFunctionAdapter? {
+ return DeleteOrUpdateFunctionAdapter.create(typeMirror)
}
fun findInsertAdapter(
typeMirror: XType,
params: List<ShortcutQueryParameter>
- ): InsertOrUpsertMethodAdapter? {
- return InsertOrUpsertMethodAdapter.createInsert(context, typeMirror, params)
+ ): InsertOrUpsertFunctionAdapter? {
+ return InsertOrUpsertFunctionAdapter.createInsert(context, typeMirror, params)
}
fun findUpsertAdapter(
typeMirror: XType,
params: List<ShortcutQueryParameter>
- ): InsertOrUpsertMethodAdapter? {
- return InsertOrUpsertMethodAdapter.createUpsert(context, typeMirror, params)
+ ): InsertOrUpsertFunctionAdapter? {
+ return InsertOrUpsertFunctionAdapter.createUpsert(context, typeMirror, params)
}
fun findQueryResultAdapter(
@@ -772,7 +772,7 @@
if (collectionType.nullability != XNullability.NONNULL) {
context.logger.w(
Warning.UNNECESSARY_NULLABILITY_IN_DAO_RETURN_TYPE,
- ProcessorErrors.nullableCollectionOrArrayReturnTypeInDaoMethod(
+ ProcessorErrors.nullableCollectionOrArrayReturnTypeInDaoFunction(
searchingType.asTypeName().toString(context.codeLanguage),
typeKeyword
)
@@ -783,7 +783,7 @@
if (arrayComponentType != null && arrayComponentType.nullability != XNullability.NONNULL) {
context.logger.w(
Warning.UNNECESSARY_NULLABILITY_IN_DAO_RETURN_TYPE,
- ProcessorErrors.nullableComponentInDaoMethodReturnType(
+ ProcessorErrors.nullableComponentInDaoFunctionReturnType(
searchingType.asTypeName().toString(context.codeLanguage)
)
)
@@ -794,7 +794,7 @@
if (typeArg.nullability != XNullability.NONNULL) {
context.logger.w(
Warning.UNNECESSARY_NULLABILITY_IN_DAO_RETURN_TYPE,
- ProcessorErrors.nullableComponentInDaoMethodReturnType(
+ ProcessorErrors.nullableComponentInDaoFunctionReturnType(
searchingType.asTypeName().toString(context.codeLanguage)
)
)
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binder/CoroutineDeleteOrUpdateMethodBinder.kt b/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binder/CoroutineDeleteOrUpdateFunctionBinder.kt
similarity index 91%
rename from room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binder/CoroutineDeleteOrUpdateMethodBinder.kt
rename to room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binder/CoroutineDeleteOrUpdateFunctionBinder.kt
index 348f3a1..4799df2 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binder/CoroutineDeleteOrUpdateMethodBinder.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binder/CoroutineDeleteOrUpdateFunctionBinder.kt
@@ -26,15 +26,15 @@
import androidx.room.ext.RoomMemberNames.DB_UTIL_PERFORM_SUSPENDING
import androidx.room.ext.SQLiteDriverTypeNames
import androidx.room.solver.CodeGenScope
-import androidx.room.solver.shortcut.result.DeleteOrUpdateMethodAdapter
+import androidx.room.solver.shortcut.result.DeleteOrUpdateFunctionAdapter
import androidx.room.vo.ShortcutQueryParameter
/** Binder for suspending delete and update methods. */
-class CoroutineDeleteOrUpdateMethodBinder(
+class CoroutineDeleteOrUpdateFunctionBinder(
val typeArg: XType,
- adapter: DeleteOrUpdateMethodAdapter?,
+ adapter: DeleteOrUpdateFunctionAdapter?,
private val continuationParamName: String
-) : DeleteOrUpdateMethodBinder(adapter) {
+) : DeleteOrUpdateFunctionBinder(adapter) {
override fun convertAndReturn(
parameters: List<ShortcutQueryParameter>,
@@ -62,7 +62,7 @@
javaLambdaSyntaxAvailable = scope.javaLambdaSyntaxAvailable
) {
override fun XCodeBlock.Builder.body(scope: CodeGenScope) {
- adapter.generateMethodBody(
+ adapter.generateFunctionBody(
scope = scope,
parameters = parameters,
adapters = adapters,
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binder/CoroutineInsertOrUpsertMethodBinder.kt b/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binder/CoroutineInsertOrUpsertFunctionBinder.kt
similarity index 91%
rename from room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binder/CoroutineInsertOrUpsertMethodBinder.kt
rename to room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binder/CoroutineInsertOrUpsertFunctionBinder.kt
index e8043e3..dae6d52b 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binder/CoroutineInsertOrUpsertMethodBinder.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binder/CoroutineInsertOrUpsertFunctionBinder.kt
@@ -25,15 +25,15 @@
import androidx.room.ext.RoomMemberNames.DB_UTIL_PERFORM_SUSPENDING
import androidx.room.ext.SQLiteDriverTypeNames
import androidx.room.solver.CodeGenScope
-import androidx.room.solver.shortcut.result.InsertOrUpsertMethodAdapter
+import androidx.room.solver.shortcut.result.InsertOrUpsertFunctionAdapter
import androidx.room.vo.ShortcutQueryParameter
/** Binder for suspending insert or upsert methods. */
-class CoroutineInsertOrUpsertMethodBinder(
+class CoroutineInsertOrUpsertFunctionBinder(
val typeArg: XType,
- adapter: InsertOrUpsertMethodAdapter?,
+ adapter: InsertOrUpsertFunctionAdapter?,
private val continuationParamName: String
-) : InsertOrUpsertMethodBinder(adapter) {
+) : InsertOrUpsertFunctionBinder(adapter) {
override fun convertAndReturn(
parameters: List<ShortcutQueryParameter>,
@@ -61,7 +61,7 @@
javaLambdaSyntaxAvailable = scope.javaLambdaSyntaxAvailable
) {
override fun XCodeBlock.Builder.body(scope: CodeGenScope) {
- adapter.generateMethodBody(
+ adapter.generateFunctionBody(
scope = scope,
parameters = parameters,
adapters = adapters,
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binder/DeleteOrUpdateMethodBinder.kt b/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binder/DeleteOrUpdateFunctionBinder.kt
similarity index 72%
rename from room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binder/DeleteOrUpdateMethodBinder.kt
rename to room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binder/DeleteOrUpdateFunctionBinder.kt
index 25342d5..525256e 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binder/DeleteOrUpdateMethodBinder.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binder/DeleteOrUpdateFunctionBinder.kt
@@ -19,17 +19,18 @@
import androidx.room.compiler.codegen.XPropertySpec
import androidx.room.compiler.codegen.XTypeSpec
import androidx.room.solver.CodeGenScope
-import androidx.room.solver.shortcut.result.DeleteOrUpdateMethodAdapter
+import androidx.room.solver.shortcut.result.DeleteOrUpdateFunctionAdapter
import androidx.room.vo.ShortcutQueryParameter
/**
- * Connects the delete or update method, the database and the [DeleteOrUpdateMethodAdapter].
+ * Connects the delete or update method, the database and the [DeleteOrUpdateFunctionAdapter].
*
- * The default implementation is [InstantDeleteOrUpdateMethodBinder] that executes the delete/update
- * synchronously. If the delete/update is deferred, rather than synchronously, alternatives
- * implementations can be implemented using this interface (e.g. RxJava, coroutines etc).
+ * The default implementation is [InstantDeleteOrUpdateFunctionBinder] that executes the
+ * delete/update synchronously. If the delete/update is deferred, rather than synchronously,
+ * alternatives implementations can be implemented using this interface (e.g. RxJava, coroutines
+ * etc).
*/
-abstract class DeleteOrUpdateMethodBinder(val adapter: DeleteOrUpdateMethodAdapter?) {
+abstract class DeleteOrUpdateFunctionBinder(val adapter: DeleteOrUpdateFunctionAdapter?) {
/**
* Received the delete/update method parameters, the adapters and generates the code that runs
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binder/InsertOrUpsertMethodBinder.kt b/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binder/InsertOrUpsertFunctionBinder.kt
similarity index 85%
rename from room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binder/InsertOrUpsertMethodBinder.kt
rename to room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binder/InsertOrUpsertFunctionBinder.kt
index 67fb0fd..fb180a4 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binder/InsertOrUpsertMethodBinder.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binder/InsertOrUpsertFunctionBinder.kt
@@ -18,11 +18,11 @@
import androidx.room.compiler.codegen.XPropertySpec
import androidx.room.solver.CodeGenScope
-import androidx.room.solver.shortcut.result.InsertOrUpsertMethodAdapter
+import androidx.room.solver.shortcut.result.InsertOrUpsertFunctionAdapter
import androidx.room.vo.ShortcutQueryParameter
-/** Connects the insert and upsert method, the database and the [InsertOrUpsertMethodAdapter]. */
-abstract class InsertOrUpsertMethodBinder(val adapter: InsertOrUpsertMethodAdapter?) {
+/** Connects the insert and upsert method, the database and the [InsertOrUpsertFunctionAdapter]. */
+abstract class InsertOrUpsertFunctionBinder(val adapter: InsertOrUpsertFunctionAdapter?) {
/**
* Received an insert or upsert method parameters, their adapters and generations the code that
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binder/InstantDeleteOrUpdateMethodBinder.kt b/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binder/InstantDeleteOrUpdateFunctionBinder.kt
similarity index 92%
rename from room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binder/InstantDeleteOrUpdateMethodBinder.kt
rename to room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binder/InstantDeleteOrUpdateFunctionBinder.kt
index 34e4967..6dcbdb3 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binder/InstantDeleteOrUpdateMethodBinder.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binder/InstantDeleteOrUpdateFunctionBinder.kt
@@ -27,12 +27,12 @@
import androidx.room.ext.SQLiteDriverTypeNames
import androidx.room.ext.isNotVoid
import androidx.room.solver.CodeGenScope
-import androidx.room.solver.shortcut.result.DeleteOrUpdateMethodAdapter
+import androidx.room.solver.shortcut.result.DeleteOrUpdateFunctionAdapter
import androidx.room.vo.ShortcutQueryParameter
/** Binder that knows how to write instant (blocking) delete and update methods. */
-class InstantDeleteOrUpdateMethodBinder(adapter: DeleteOrUpdateMethodAdapter?) :
- DeleteOrUpdateMethodBinder(adapter) {
+class InstantDeleteOrUpdateFunctionBinder(adapter: DeleteOrUpdateFunctionAdapter?) :
+ DeleteOrUpdateFunctionBinder(adapter) {
override fun convertAndReturn(
parameters: List<ShortcutQueryParameter>,
@@ -59,7 +59,7 @@
javaLambdaSyntaxAvailable = scope.javaLambdaSyntaxAvailable
) {
override fun XCodeBlock.Builder.body(scope: CodeGenScope) {
- adapter.generateMethodBody(
+ adapter.generateFunctionBody(
scope = scope,
parameters = parameters,
adapters = adapters,
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binder/InstantInsertOrUpsertMethodBinder.kt b/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binder/InstantInsertOrUpsertFunctionBinder.kt
similarity index 91%
rename from room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binder/InstantInsertOrUpsertMethodBinder.kt
rename to room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binder/InstantInsertOrUpsertFunctionBinder.kt
index 322e206..a740eeb 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binder/InstantInsertOrUpsertMethodBinder.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binder/InstantInsertOrUpsertFunctionBinder.kt
@@ -26,12 +26,12 @@
import androidx.room.ext.SQLiteDriverTypeNames
import androidx.room.ext.isNotVoid
import androidx.room.solver.CodeGenScope
-import androidx.room.solver.shortcut.result.InsertOrUpsertMethodAdapter
+import androidx.room.solver.shortcut.result.InsertOrUpsertFunctionAdapter
import androidx.room.vo.ShortcutQueryParameter
/** Binder that knows how to write instant (blocking) insert or upsert methods. */
-class InstantInsertOrUpsertMethodBinder(adapter: InsertOrUpsertMethodAdapter?) :
- InsertOrUpsertMethodBinder(adapter) {
+class InstantInsertOrUpsertFunctionBinder(adapter: InsertOrUpsertFunctionAdapter?) :
+ InsertOrUpsertFunctionBinder(adapter) {
override fun convertAndReturn(
parameters: List<ShortcutQueryParameter>,
@@ -58,7 +58,7 @@
javaLambdaSyntaxAvailable = scope.javaLambdaSyntaxAvailable
) {
override fun XCodeBlock.Builder.body(scope: CodeGenScope) {
- adapter.generateMethodBody(
+ adapter.generateFunctionBody(
scope = scope,
parameters = parameters,
adapters = adapters,
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binder/LambdaDeleteOrUpdateMethodBinder.kt b/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binder/LambdaDeleteOrUpdateFunctionBinder.kt
similarity index 91%
rename from room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binder/LambdaDeleteOrUpdateMethodBinder.kt
rename to room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binder/LambdaDeleteOrUpdateFunctionBinder.kt
index 3cdca44..1d01edb 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binder/LambdaDeleteOrUpdateMethodBinder.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binder/LambdaDeleteOrUpdateFunctionBinder.kt
@@ -25,7 +25,7 @@
import androidx.room.ext.LambdaSpec
import androidx.room.ext.SQLiteDriverTypeNames
import androidx.room.solver.CodeGenScope
-import androidx.room.solver.shortcut.result.DeleteOrUpdateMethodAdapter
+import androidx.room.solver.shortcut.result.DeleteOrUpdateFunctionAdapter
import androidx.room.vo.ShortcutQueryParameter
/**
@@ -34,11 +34,11 @@
* This binder generates code that invokes [functionName] with a lambda whose body will delegate to
* the given [adapter].
*/
-class LambdaDeleteOrUpdateMethodBinder(
+class LambdaDeleteOrUpdateFunctionBinder(
val typeArg: XType,
val functionName: XMemberName,
- adapter: DeleteOrUpdateMethodAdapter?
-) : DeleteOrUpdateMethodBinder(adapter) {
+ adapter: DeleteOrUpdateFunctionAdapter?
+) : DeleteOrUpdateFunctionBinder(adapter) {
override fun convertAndReturn(
parameters: List<ShortcutQueryParameter>,
adapters: Map<String, Pair<XPropertySpec, XTypeSpec>>,
@@ -64,7 +64,7 @@
javaLambdaSyntaxAvailable = scope.javaLambdaSyntaxAvailable
) {
override fun XCodeBlock.Builder.body(scope: CodeGenScope) {
- adapter.generateMethodBody(
+ adapter.generateFunctionBody(
scope = scope,
parameters = parameters,
adapters = adapters,
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binder/LambdaInsertOrUpsertMethodBinder.kt b/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binder/LambdaInsertOrUpsertFunctionBinder.kt
similarity index 91%
rename from room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binder/LambdaInsertOrUpsertMethodBinder.kt
rename to room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binder/LambdaInsertOrUpsertFunctionBinder.kt
index af0a2ea..2619f3d 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binder/LambdaInsertOrUpsertMethodBinder.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binder/LambdaInsertOrUpsertFunctionBinder.kt
@@ -24,7 +24,7 @@
import androidx.room.ext.LambdaSpec
import androidx.room.ext.SQLiteDriverTypeNames
import androidx.room.solver.CodeGenScope
-import androidx.room.solver.shortcut.result.InsertOrUpsertMethodAdapter
+import androidx.room.solver.shortcut.result.InsertOrUpsertFunctionAdapter
import androidx.room.vo.ShortcutQueryParameter
/**
@@ -33,11 +33,11 @@
* This binder generates code that invokes [functionName] with a lambda whose body will delegate to
* the given [adapter].
*/
-class LambdaInsertOrUpsertMethodBinder(
+class LambdaInsertOrUpsertFunctionBinder(
val typeArg: XType,
val functionName: XMemberName,
- adapter: InsertOrUpsertMethodAdapter?
-) : InsertOrUpsertMethodBinder(adapter) {
+ adapter: InsertOrUpsertFunctionAdapter?
+) : InsertOrUpsertFunctionBinder(adapter) {
override fun convertAndReturn(
parameters: List<ShortcutQueryParameter>,
@@ -64,7 +64,7 @@
javaLambdaSyntaxAvailable = scope.javaLambdaSyntaxAvailable
) {
override fun XCodeBlock.Builder.body(scope: CodeGenScope) {
- adapter.generateMethodBody(
+ adapter.generateFunctionBody(
scope = scope,
parameters = parameters,
adapters = adapters,
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binderprovider/DeleteOrUpdateMethodBinderProvider.kt b/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binderprovider/DeleteOrUpdateFunctionBinderProvider.kt
similarity index 70%
rename from room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binderprovider/DeleteOrUpdateMethodBinderProvider.kt
rename to room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binderprovider/DeleteOrUpdateFunctionBinderProvider.kt
index bf22009..d6d5215 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binderprovider/DeleteOrUpdateMethodBinderProvider.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binderprovider/DeleteOrUpdateFunctionBinderProvider.kt
@@ -17,15 +17,15 @@
package androidx.room.solver.shortcut.binderprovider
import androidx.room.compiler.processing.XType
-import androidx.room.solver.shortcut.binder.DeleteOrUpdateMethodBinder
-import androidx.room.solver.shortcut.result.DeleteOrUpdateMethodAdapter
+import androidx.room.solver.shortcut.binder.DeleteOrUpdateFunctionBinder
+import androidx.room.solver.shortcut.result.DeleteOrUpdateFunctionAdapter
/** Provider for delete or update binders */
-interface DeleteOrUpdateMethodBinderProvider {
+interface DeleteOrUpdateFunctionBinderProvider {
- /** Check whether the [XType] can be handled by the [DeleteOrUpdateMethodBinder] */
+ /** Check whether the [XType] can be handled by the [DeleteOrUpdateFunctionBinder] */
fun matches(declared: XType): Boolean
- /** Provider of [DeleteOrUpdateMethodAdapter], based on the [XType] */
- fun provide(declared: XType): DeleteOrUpdateMethodBinder
+ /** Provider of [DeleteOrUpdateFunctionAdapter], based on the [XType] */
+ fun provide(declared: XType): DeleteOrUpdateFunctionBinder
}
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binderprovider/GuavaListenableFutureDeleteOrUpdateMethodBinderProvider.kt b/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binderprovider/GuavaListenableFutureDeleteOrUpdateFunctionBinderProvider.kt
similarity index 85%
rename from room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binderprovider/GuavaListenableFutureDeleteOrUpdateMethodBinderProvider.kt
rename to room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binderprovider/GuavaListenableFutureDeleteOrUpdateFunctionBinderProvider.kt
index bca756c..88e0680 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binderprovider/GuavaListenableFutureDeleteOrUpdateMethodBinderProvider.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binderprovider/GuavaListenableFutureDeleteOrUpdateFunctionBinderProvider.kt
@@ -24,12 +24,12 @@
import androidx.room.ext.RoomGuavaTypeNames.GUAVA_ROOM_MARKER
import androidx.room.processor.Context
import androidx.room.processor.ProcessorErrors
-import androidx.room.solver.shortcut.binder.DeleteOrUpdateMethodBinder
-import androidx.room.solver.shortcut.binder.LambdaDeleteOrUpdateMethodBinder
+import androidx.room.solver.shortcut.binder.DeleteOrUpdateFunctionBinder
+import androidx.room.solver.shortcut.binder.LambdaDeleteOrUpdateFunctionBinder
/** Provider for Guava ListenableFuture binders. */
-class GuavaListenableFutureDeleteOrUpdateMethodBinderProvider(val context: Context) :
- DeleteOrUpdateMethodBinderProvider {
+class GuavaListenableFutureDeleteOrUpdateFunctionBinderProvider(val context: Context) :
+ DeleteOrUpdateFunctionBinderProvider {
private val hasGuavaRoom by lazy {
context.processingEnv.getElementsFromPackage(GUAVA_ROOM_MARKER.packageName).isNotEmpty()
@@ -39,7 +39,7 @@
declared.typeArguments.size == 1 &&
declared.rawType.asTypeName() == GuavaUtilConcurrentTypeNames.LISTENABLE_FUTURE
- override fun provide(declared: XType): DeleteOrUpdateMethodBinder {
+ override fun provide(declared: XType): DeleteOrUpdateFunctionBinder {
if (!hasGuavaRoom) {
context.logger.e(ProcessorErrors.MISSING_ROOM_GUAVA_ARTIFACT)
}
@@ -49,7 +49,7 @@
context.logger.e(ProcessorErrors.NONNULL_VOID)
}
- return LambdaDeleteOrUpdateMethodBinder(
+ return LambdaDeleteOrUpdateFunctionBinder(
typeArg = typeArg,
functionName = GUAVA_ROOM_CREATE_LISTENABLE_FUTURE,
adapter = context.typeAdapterStore.findDeleteOrUpdateAdapter(typeArg)
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binderprovider/GuavaListenableFutureInsertOrUpsertMethodBinderProvider.kt b/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binderprovider/GuavaListenableFutureInsertOrUpsertFunctionBinderProvider.kt
similarity index 88%
rename from room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binderprovider/GuavaListenableFutureInsertOrUpsertMethodBinderProvider.kt
rename to room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binderprovider/GuavaListenableFutureInsertOrUpsertFunctionBinderProvider.kt
index 0153c10..3a67fa9 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binderprovider/GuavaListenableFutureInsertOrUpsertMethodBinderProvider.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binderprovider/GuavaListenableFutureInsertOrUpsertFunctionBinderProvider.kt
@@ -24,13 +24,13 @@
import androidx.room.ext.RoomGuavaTypeNames.GUAVA_ROOM_MARKER
import androidx.room.processor.Context
import androidx.room.processor.ProcessorErrors
-import androidx.room.solver.shortcut.binder.InsertOrUpsertMethodBinder
-import androidx.room.solver.shortcut.binder.LambdaInsertOrUpsertMethodBinder
+import androidx.room.solver.shortcut.binder.InsertOrUpsertFunctionBinder
+import androidx.room.solver.shortcut.binder.LambdaInsertOrUpsertFunctionBinder
import androidx.room.vo.ShortcutQueryParameter
/** Provider for Guava ListenableFuture binders. */
-class GuavaListenableFutureInsertOrUpsertMethodBinderProvider(private val context: Context) :
- InsertOrUpsertMethodBinderProvider {
+class GuavaListenableFutureInsertOrUpsertFunctionBinderProvider(private val context: Context) :
+ InsertOrUpsertFunctionBinderProvider {
private val hasGuavaRoom by lazy {
context.processingEnv.findTypeElement(GUAVA_ROOM_MARKER.canonicalName) != null
@@ -44,7 +44,7 @@
declared: XType,
params: List<ShortcutQueryParameter>,
forUpsert: Boolean
- ): InsertOrUpsertMethodBinder {
+ ): InsertOrUpsertFunctionBinder {
if (!hasGuavaRoom) {
context.logger.e(ProcessorErrors.MISSING_ROOM_GUAVA_ARTIFACT)
}
@@ -54,7 +54,7 @@
context.logger.e(ProcessorErrors.NONNULL_VOID)
}
- return LambdaInsertOrUpsertMethodBinder(
+ return LambdaInsertOrUpsertFunctionBinder(
typeArg = typeArg,
functionName = GUAVA_ROOM_CREATE_LISTENABLE_FUTURE,
adapter =
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binderprovider/InsertOrUpsertMethodBinderProvider.kt b/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binderprovider/InsertOrUpsertFunctionBinderProvider.kt
similarity index 73%
rename from room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binderprovider/InsertOrUpsertMethodBinderProvider.kt
rename to room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binderprovider/InsertOrUpsertFunctionBinderProvider.kt
index 57e8bba..dac8c97 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binderprovider/InsertOrUpsertMethodBinderProvider.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binderprovider/InsertOrUpsertFunctionBinderProvider.kt
@@ -17,19 +17,21 @@
package androidx.room.solver.shortcut.binderprovider
import androidx.room.compiler.processing.XType
-import androidx.room.solver.shortcut.binder.InsertOrUpsertMethodBinder
+import androidx.room.solver.shortcut.binder.InsertOrUpsertFunctionBinder
import androidx.room.vo.ShortcutQueryParameter
-/** Provider for insert and upsert method binders. */
-interface InsertOrUpsertMethodBinderProvider {
+/** Provider for insert and upsert function binders. */
+interface InsertOrUpsertFunctionBinderProvider {
- /** Check whether the [XType] can be handled by the [InsertOrUpsertMethodBinder] */
+ /** Check whether the [XType] can be handled by the [InsertOrUpsertFunctionBinder] */
fun matches(declared: XType): Boolean
- /** Provider of [InsertOrUpsertMethodBinder], based on the [XType] and the list of parameters */
+ /**
+ * Provider of [InsertOrUpsertFunctionBinder], based on the [XType] and the list of parameters
+ */
fun provide(
declared: XType,
params: List<ShortcutQueryParameter>,
forUpsert: Boolean
- ): InsertOrUpsertMethodBinder
+ ): InsertOrUpsertFunctionBinder
}
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binderprovider/InstantDeleteOrUpdateMethodBinderProvider.kt b/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binderprovider/InstantDeleteOrUpdateFunctionBinderProvider.kt
similarity index 69%
rename from room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binderprovider/InstantDeleteOrUpdateMethodBinderProvider.kt
rename to room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binderprovider/InstantDeleteOrUpdateFunctionBinderProvider.kt
index 3e8ef08..8abbd94 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binderprovider/InstantDeleteOrUpdateMethodBinderProvider.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binderprovider/InstantDeleteOrUpdateFunctionBinderProvider.kt
@@ -18,17 +18,17 @@
import androidx.room.compiler.processing.XType
import androidx.room.processor.Context
-import androidx.room.solver.shortcut.binder.DeleteOrUpdateMethodBinder
-import androidx.room.solver.shortcut.binder.InstantDeleteOrUpdateMethodBinder
+import androidx.room.solver.shortcut.binder.DeleteOrUpdateFunctionBinder
+import androidx.room.solver.shortcut.binder.InstantDeleteOrUpdateFunctionBinder
-/** Provider for instant (blocking) delete or update method binder */
-class InstantDeleteOrUpdateMethodBinderProvider(private val context: Context) :
- DeleteOrUpdateMethodBinderProvider {
+/** Provider for instant (blocking) delete or update function binder */
+class InstantDeleteOrUpdateFunctionBinderProvider(private val context: Context) :
+ DeleteOrUpdateFunctionBinderProvider {
override fun matches(declared: XType) = true
- override fun provide(declared: XType): DeleteOrUpdateMethodBinder {
+ override fun provide(declared: XType): DeleteOrUpdateFunctionBinder {
val adapter = context.typeAdapterStore.findDeleteOrUpdateAdapter(declared)
- return InstantDeleteOrUpdateMethodBinder(adapter)
+ return InstantDeleteOrUpdateFunctionBinder(adapter)
}
}
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binderprovider/InstantInsertOrUpsertMethodBinder.kt b/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binderprovider/InstantInsertOrUpsertFunctionBinder.kt
similarity index 77%
rename from room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binderprovider/InstantInsertOrUpsertMethodBinder.kt
rename to room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binderprovider/InstantInsertOrUpsertFunctionBinder.kt
index e902119..99fcd51 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binderprovider/InstantInsertOrUpsertMethodBinder.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binderprovider/InstantInsertOrUpsertFunctionBinder.kt
@@ -18,13 +18,13 @@
import androidx.room.compiler.processing.XType
import androidx.room.processor.Context
-import androidx.room.solver.shortcut.binder.InsertOrUpsertMethodBinder
-import androidx.room.solver.shortcut.binder.InstantInsertOrUpsertMethodBinder
+import androidx.room.solver.shortcut.binder.InsertOrUpsertFunctionBinder
+import androidx.room.solver.shortcut.binder.InstantInsertOrUpsertFunctionBinder
import androidx.room.vo.ShortcutQueryParameter
-/** Provider for instant (blocking) insert or upsert method binder. */
-class InstantInsertOrUpsertMethodBinderProvider(private val context: Context) :
- InsertOrUpsertMethodBinderProvider {
+/** Provider for instant (blocking) insert or upsert function binders. */
+class InstantInsertOrUpsertFunctionBinderProvider(private val context: Context) :
+ InsertOrUpsertFunctionBinderProvider {
override fun matches(declared: XType) = true
@@ -32,8 +32,8 @@
declared: XType,
params: List<ShortcutQueryParameter>,
forUpsert: Boolean
- ): InsertOrUpsertMethodBinder {
- return InstantInsertOrUpsertMethodBinder(
+ ): InsertOrUpsertFunctionBinder {
+ return InstantInsertOrUpsertFunctionBinder(
if (forUpsert) {
context.typeAdapterStore.findUpsertAdapter(declared, params)
} else {
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binderprovider/RxCallableDeleteOrUpdateMethodBinderProvider.kt b/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binderprovider/RxCallableDeleteOrUpdateFunctionBinderProvider.kt
similarity index 70%
rename from room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binderprovider/RxCallableDeleteOrUpdateMethodBinderProvider.kt
rename to room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binderprovider/RxCallableDeleteOrUpdateFunctionBinderProvider.kt
index 535e608..d152405 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binderprovider/RxCallableDeleteOrUpdateMethodBinderProvider.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binderprovider/RxCallableDeleteOrUpdateFunctionBinderProvider.kt
@@ -21,13 +21,13 @@
import androidx.room.ext.KotlinTypeNames
import androidx.room.processor.Context
import androidx.room.solver.RxType
-import androidx.room.solver.shortcut.binder.DeleteOrUpdateMethodBinder
-import androidx.room.solver.shortcut.binder.LambdaDeleteOrUpdateMethodBinder
+import androidx.room.solver.shortcut.binder.DeleteOrUpdateFunctionBinder
+import androidx.room.solver.shortcut.binder.LambdaDeleteOrUpdateFunctionBinder
/** Provider for Rx Callable binders. */
-open class RxCallableDeleteOrUpdateMethodBinderProvider
+open class RxCallableDeleteOrUpdateFunctionBinderProvider
internal constructor(val context: Context, private val rxType: RxType) :
- DeleteOrUpdateMethodBinderProvider {
+ DeleteOrUpdateFunctionBinderProvider {
/**
* [Single] and [Maybe] are generics but [Completable] is not so each implementation of this
@@ -42,10 +42,10 @@
return declared.rawType.asTypeName() == rxType.className
}
- override fun provide(declared: XType): DeleteOrUpdateMethodBinder {
+ override fun provide(declared: XType): DeleteOrUpdateFunctionBinder {
val typeArg = extractTypeArg(declared)
val adapter = context.typeAdapterStore.findDeleteOrUpdateAdapter(typeArg)
- return LambdaDeleteOrUpdateMethodBinder(
+ return LambdaDeleteOrUpdateFunctionBinder(
typeArg = typeArg,
functionName = rxType.factoryMethodName,
adapter = adapter
@@ -55,18 +55,18 @@
companion object {
fun getAll(context: Context) =
listOf(
- RxSingleOrMaybeDeleteOrUpdateMethodBinderProvider(context, RxType.RX2_SINGLE),
- RxSingleOrMaybeDeleteOrUpdateMethodBinderProvider(context, RxType.RX2_MAYBE),
- RxCompletableDeleteOrUpdateMethodBinderProvider(context, RxType.RX2_COMPLETABLE),
- RxSingleOrMaybeDeleteOrUpdateMethodBinderProvider(context, RxType.RX3_SINGLE),
- RxSingleOrMaybeDeleteOrUpdateMethodBinderProvider(context, RxType.RX3_MAYBE),
- RxCompletableDeleteOrUpdateMethodBinderProvider(context, RxType.RX3_COMPLETABLE)
+ RxSingleOrMaybeDeleteOrUpdateFunctionBinderProvider(context, RxType.RX2_SINGLE),
+ RxSingleOrMaybeDeleteOrUpdateFunctionBinderProvider(context, RxType.RX2_MAYBE),
+ RxCompletableDeleteOrUpdateFunctionBinderProvider(context, RxType.RX2_COMPLETABLE),
+ RxSingleOrMaybeDeleteOrUpdateFunctionBinderProvider(context, RxType.RX3_SINGLE),
+ RxSingleOrMaybeDeleteOrUpdateFunctionBinderProvider(context, RxType.RX3_MAYBE),
+ RxCompletableDeleteOrUpdateFunctionBinderProvider(context, RxType.RX3_COMPLETABLE)
)
}
}
-private class RxCompletableDeleteOrUpdateMethodBinderProvider(context: Context, rxType: RxType) :
- RxCallableDeleteOrUpdateMethodBinderProvider(context, rxType) {
+private class RxCompletableDeleteOrUpdateFunctionBinderProvider(context: Context, rxType: RxType) :
+ RxCallableDeleteOrUpdateFunctionBinderProvider(context, rxType) {
private val completableType: XRawType? by lazy {
context.processingEnv.findType(rxType.className.canonicalName)?.rawType
@@ -87,8 +87,10 @@
}
}
-private class RxSingleOrMaybeDeleteOrUpdateMethodBinderProvider(context: Context, rxType: RxType) :
- RxCallableDeleteOrUpdateMethodBinderProvider(context, rxType) {
+private class RxSingleOrMaybeDeleteOrUpdateFunctionBinderProvider(
+ context: Context,
+ rxType: RxType
+) : RxCallableDeleteOrUpdateFunctionBinderProvider(context, rxType) {
/** Since Maybe can have null values, the lambda returned must allow for null values. */
override fun extractTypeArg(declared: XType): XType =
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binderprovider/RxCallableInsertOrUpsertMethodBinderProvider.kt b/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binderprovider/RxCallableInsertOrUpsertFunctionBinderProvider.kt
similarity index 73%
rename from room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binderprovider/RxCallableInsertOrUpsertMethodBinderProvider.kt
rename to room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binderprovider/RxCallableInsertOrUpsertFunctionBinderProvider.kt
index 9b0223d..ef89ede 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binderprovider/RxCallableInsertOrUpsertMethodBinderProvider.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/binderprovider/RxCallableInsertOrUpsertFunctionBinderProvider.kt
@@ -21,14 +21,14 @@
import androidx.room.ext.KotlinTypeNames
import androidx.room.processor.Context
import androidx.room.solver.RxType
-import androidx.room.solver.shortcut.binder.InsertOrUpsertMethodBinder
-import androidx.room.solver.shortcut.binder.LambdaInsertOrUpsertMethodBinder
+import androidx.room.solver.shortcut.binder.InsertOrUpsertFunctionBinder
+import androidx.room.solver.shortcut.binder.LambdaInsertOrUpsertFunctionBinder
import androidx.room.vo.ShortcutQueryParameter
/** Provider for Rx Callable binders. */
-open class RxCallableInsertOrUpsertMethodBinderProvider
+open class RxCallableInsertOrUpsertFunctionBinderProvider
internal constructor(val context: Context, private val rxType: RxType) :
- InsertOrUpsertMethodBinderProvider {
+ InsertOrUpsertFunctionBinderProvider {
/**
* [Single] and [Maybe] are generics but [Completable] is not so each implementation of this
@@ -47,7 +47,7 @@
declared: XType,
params: List<ShortcutQueryParameter>,
forUpsert: Boolean
- ): InsertOrUpsertMethodBinder {
+ ): InsertOrUpsertFunctionBinder {
val typeArg = extractTypeArg(declared)
val adapter =
if (forUpsert) {
@@ -55,7 +55,7 @@
} else {
context.typeAdapterStore.findInsertAdapter(typeArg, params)
}
- return LambdaInsertOrUpsertMethodBinder(
+ return LambdaInsertOrUpsertFunctionBinder(
typeArg = typeArg,
functionName = rxType.factoryMethodName,
adapter = adapter
@@ -65,18 +65,18 @@
companion object {
fun getAll(context: Context) =
listOf(
- RxSingleOrMaybeInsertOrUpsertMethodBinderProvider(context, RxType.RX2_SINGLE),
- RxSingleOrMaybeInsertOrUpsertMethodBinderProvider(context, RxType.RX2_MAYBE),
- RxCompletableInsertOrUpsertMethodBinderProvider(context, RxType.RX2_COMPLETABLE),
- RxSingleOrMaybeInsertOrUpsertMethodBinderProvider(context, RxType.RX3_SINGLE),
- RxSingleOrMaybeInsertOrUpsertMethodBinderProvider(context, RxType.RX3_MAYBE),
- RxCompletableInsertOrUpsertMethodBinderProvider(context, RxType.RX3_COMPLETABLE)
+ RxSingleOrMaybeInsertOrUpsertFunctionBinderProvider(context, RxType.RX2_SINGLE),
+ RxSingleOrMaybeInsertOrUpsertFunctionBinderProvider(context, RxType.RX2_MAYBE),
+ RxCompletableInsertOrUpsertFunctionBinderProvider(context, RxType.RX2_COMPLETABLE),
+ RxSingleOrMaybeInsertOrUpsertFunctionBinderProvider(context, RxType.RX3_SINGLE),
+ RxSingleOrMaybeInsertOrUpsertFunctionBinderProvider(context, RxType.RX3_MAYBE),
+ RxCompletableInsertOrUpsertFunctionBinderProvider(context, RxType.RX3_COMPLETABLE)
)
}
}
-private class RxCompletableInsertOrUpsertMethodBinderProvider(context: Context, rxType: RxType) :
- RxCallableInsertOrUpsertMethodBinderProvider(context, rxType) {
+private class RxCompletableInsertOrUpsertFunctionBinderProvider(context: Context, rxType: RxType) :
+ RxCallableInsertOrUpsertFunctionBinderProvider(context, rxType) {
private val completableType: XRawType? by lazy {
context.processingEnv.findType(rxType.className.canonicalName)?.rawType
@@ -97,8 +97,10 @@
}
}
-private class RxSingleOrMaybeInsertOrUpsertMethodBinderProvider(context: Context, rxType: RxType) :
- RxCallableInsertOrUpsertMethodBinderProvider(context, rxType) {
+private class RxSingleOrMaybeInsertOrUpsertFunctionBinderProvider(
+ context: Context,
+ rxType: RxType
+) : RxCallableInsertOrUpsertFunctionBinderProvider(context, rxType) {
/** Since Maybe can have null values, the lambda returned must allow for null values. */
override fun extractTypeArg(declared: XType): XType =
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/result/DeleteOrUpdateMethodAdapter.kt b/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/result/DeleteOrUpdateFunctionAdapter.kt
similarity index 90%
rename from room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/result/DeleteOrUpdateMethodAdapter.kt
rename to room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/result/DeleteOrUpdateFunctionAdapter.kt
index 512d877..e89ebbd 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/result/DeleteOrUpdateMethodAdapter.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/result/DeleteOrUpdateFunctionAdapter.kt
@@ -32,12 +32,12 @@
import androidx.room.solver.CodeGenScope
import androidx.room.vo.ShortcutQueryParameter
-/** Class that knows how to generate a delete or update method body. */
-class DeleteOrUpdateMethodAdapter private constructor(val returnType: XType) {
+/** Class that knows how to generate a delete or update function body. */
+class DeleteOrUpdateFunctionAdapter private constructor(val returnType: XType) {
companion object {
- fun create(returnType: XType): DeleteOrUpdateMethodAdapter? {
+ fun create(returnType: XType): DeleteOrUpdateFunctionAdapter? {
if (isDeleteOrUpdateValid(returnType)) {
- return DeleteOrUpdateMethodAdapter(returnType)
+ return DeleteOrUpdateFunctionAdapter(returnType)
}
return null
}
@@ -50,7 +50,7 @@
}
}
- fun generateMethodBody(
+ fun generateFunctionBody(
scope: CodeGenScope,
parameters: List<ShortcutQueryParameter>,
adapters: Map<String, Pair<XPropertySpec, Any>>,
@@ -81,7 +81,7 @@
"%L%L.%L(%L, %L)",
if (resultVar == null) "" else "$resultVar += ",
adapter.name,
- param.handleMethodName,
+ param.handleFunctionName,
connectionVar,
param.name
)
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/result/InsertOrUpsertMethodAdapter.kt b/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/result/InsertOrUpsertFunctionAdapter.kt
similarity index 83%
rename from room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/result/InsertOrUpsertMethodAdapter.kt
rename to room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/result/InsertOrUpsertFunctionAdapter.kt
index c6b9dbd..22d0950e 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/result/InsertOrUpsertMethodAdapter.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/solver/shortcut/result/InsertOrUpsertFunctionAdapter.kt
@@ -37,20 +37,20 @@
import androidx.room.solver.CodeGenScope
import androidx.room.vo.ShortcutQueryParameter
-class InsertOrUpsertMethodAdapter private constructor(private val methodInfo: MethodInfo) {
- internal val returnType = methodInfo.returnType
+class InsertOrUpsertFunctionAdapter private constructor(private val functionInfo: FunctionInfo) {
+ internal val returnType = functionInfo.returnType
companion object {
fun createInsert(
context: Context,
returnType: XType,
params: List<ShortcutQueryParameter>
- ): InsertOrUpsertMethodAdapter? {
- return createMethod(
+ ): InsertOrUpsertFunctionAdapter? {
+ return createFunction(
context = context,
returnType = returnType,
params = params,
- methodInfoClass = ::InsertMethodInfo,
+ functionInfoClass = ::InsertFunctionInfo,
multiParamSingleReturnError =
ProcessorErrors.INSERT_MULTI_PARAM_SINGLE_RETURN_MISMATCH,
singleParamMultiReturnError =
@@ -62,12 +62,12 @@
context: Context,
returnType: XType,
params: List<ShortcutQueryParameter>
- ): InsertOrUpsertMethodAdapter? {
- return createMethod(
+ ): InsertOrUpsertFunctionAdapter? {
+ return createFunction(
context = context,
returnType = returnType,
params = params,
- methodInfoClass = ::UpsertMethodInfo,
+ functionInfoClass = ::UpsertFunctionInfo,
multiParamSingleReturnError =
ProcessorErrors.UPSERT_MULTI_PARAM_SINGLE_RETURN_MISMATCH,
singleParamMultiReturnError =
@@ -75,27 +75,27 @@
)
}
- private fun createMethod(
+ private fun createFunction(
context: Context,
returnType: XType,
params: List<ShortcutQueryParameter>,
- methodInfoClass: (returnInfo: ReturnInfo, returnType: XType) -> MethodInfo,
+ functionInfoClass: (returnInfo: ReturnInfo, returnType: XType) -> FunctionInfo,
multiParamSingleReturnError: String,
singleParamMultiReturnError: String
- ): InsertOrUpsertMethodAdapter? {
- val methodReturnType = getReturnType(returnType)
+ ): InsertOrUpsertFunctionAdapter? {
+ val functionReturnType = getReturnType(returnType)
if (
- methodReturnType != null &&
+ functionReturnType != null &&
isReturnValid(
context,
- methodReturnType,
+ functionReturnType,
params,
multiParamSingleReturnError,
singleParamMultiReturnError
)
) {
- val methodInfo = methodInfoClass(methodReturnType, returnType)
- return InsertOrUpsertMethodAdapter(methodInfo = methodInfo)
+ val functionInfo = functionInfoClass(functionReturnType, returnType)
+ return InsertOrUpsertFunctionAdapter(functionInfo = functionInfo)
}
return null
}
@@ -175,7 +175,7 @@
}
}
- fun generateMethodBody(
+ fun generateFunctionBody(
scope: CodeGenScope,
connectionVar: String,
parameters: List<ShortcutQueryParameter>,
@@ -198,19 +198,19 @@
XCodeBlock.of(
"%L.%L(%L, %L)",
upsertAdapter.name,
- methodInfo.methodName,
+ functionInfo.functionName,
connectionVar,
param.name
)
.let {
if (
scope.language == CodeLanguage.KOTLIN &&
- methodInfo.returnInfo == ReturnInfo.ID_ARRAY_BOX &&
- methodInfo.returnType.asTypeName() ==
- methodInfo.returnInfo.typeName
+ functionInfo.returnInfo == ReturnInfo.ID_ARRAY_BOX &&
+ functionInfo.returnType.asTypeName() ==
+ functionInfo.returnInfo.typeName
) {
XCodeBlock.ofCast(
- typeName = methodInfo.returnInfo.typeName,
+ typeName = functionInfo.returnInfo.typeName,
expressionBlock = it
)
} else {
@@ -219,7 +219,7 @@
}
when (scope.language) {
CodeLanguage.JAVA -> {
- when (methodInfo.returnInfo) {
+ when (functionInfo.returnInfo) {
ReturnInfo.VOID,
ReturnInfo.VOID_OBJECT -> {
if (param == parameters.last()) {
@@ -262,21 +262,21 @@
}
}
- sealed class MethodInfo(val returnInfo: ReturnInfo, val returnType: XType) {
- abstract val methodName: String
+ sealed class FunctionInfo(val returnInfo: ReturnInfo, val returnType: XType) {
+ abstract val functionName: String
}
- class InsertMethodInfo(returnInfo: ReturnInfo, returnType: XType) :
- MethodInfo(returnInfo, returnType) {
- override val methodName: String = "insert${returnInfo.methodSuffix}"
+ class InsertFunctionInfo(returnInfo: ReturnInfo, returnType: XType) :
+ FunctionInfo(returnInfo, returnType) {
+ override val functionName: String = "insert${returnInfo.functionSuffix}"
}
- class UpsertMethodInfo(returnInfo: ReturnInfo, returnType: XType) :
- MethodInfo(returnInfo, returnType) {
- override val methodName: String = "upsert${returnInfo.methodSuffix}"
+ class UpsertFunctionInfo(returnInfo: ReturnInfo, returnType: XType) :
+ FunctionInfo(returnInfo, returnType) {
+ override val functionName: String = "upsert${returnInfo.functionSuffix}"
}
- enum class ReturnInfo(val methodSuffix: String, val typeName: XTypeName) {
+ enum class ReturnInfo(val functionSuffix: String, val typeName: XTypeName) {
VOID("", XTypeName.UNIT_VOID), // return void
VOID_OBJECT("", CommonTypeNames.VOID), // return Void
UNIT("", XTypeName.UNIT_VOID), // return kotlin.Unit.INSTANCE
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/solver/transaction/binder/CoroutineTransactionMethodBinder.kt b/room/room-compiler/src/main/kotlin/androidx/room/solver/transaction/binder/CoroutineTransactionFunctionBinder.kt
similarity index 94%
rename from room/room-compiler/src/main/kotlin/androidx/room/solver/transaction/binder/CoroutineTransactionMethodBinder.kt
rename to room/room-compiler/src/main/kotlin/androidx/room/solver/transaction/binder/CoroutineTransactionFunctionBinder.kt
index f1ae556..b999825 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/solver/transaction/binder/CoroutineTransactionMethodBinder.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/solver/transaction/binder/CoroutineTransactionFunctionBinder.kt
@@ -27,14 +27,14 @@
import androidx.room.ext.LambdaSpec
import androidx.room.ext.RoomMemberNames.DB_UTIL_PERFORM_IN_TRANSACTION_SUSPENDING
import androidx.room.solver.CodeGenScope
-import androidx.room.solver.transaction.result.TransactionMethodAdapter
+import androidx.room.solver.transaction.result.TransactionFunctionAdapter
/** Binder that knows how to write suspending transaction wrapper methods. */
-class CoroutineTransactionMethodBinder(
+class CoroutineTransactionFunctionBinder(
private val returnType: XType,
- adapter: TransactionMethodAdapter,
+ adapter: TransactionFunctionAdapter,
private val continuationParamName: String
-) : TransactionMethodBinder(adapter) {
+) : TransactionFunctionBinder(adapter) {
override fun executeAndReturn(
parameterNames: List<String>,
daoName: XClassName,
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/solver/transaction/binder/InstantTransactionMethodBinder.kt b/room/room-compiler/src/main/kotlin/androidx/room/solver/transaction/binder/InstantTransactionFunctionBinder.kt
similarity index 95%
rename from room/room-compiler/src/main/kotlin/androidx/room/solver/transaction/binder/InstantTransactionMethodBinder.kt
rename to room/room-compiler/src/main/kotlin/androidx/room/solver/transaction/binder/InstantTransactionFunctionBinder.kt
index e2e6208..ff0b66e 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/solver/transaction/binder/InstantTransactionMethodBinder.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/solver/transaction/binder/InstantTransactionFunctionBinder.kt
@@ -30,13 +30,13 @@
import androidx.room.ext.RoomMemberNames.DB_UTIL_PERFORM_BLOCKING
import androidx.room.ext.SQLiteDriverTypeNames
import androidx.room.solver.CodeGenScope
-import androidx.room.solver.transaction.result.TransactionMethodAdapter
+import androidx.room.solver.transaction.result.TransactionFunctionAdapter
/** Binder that knows how to write instant (blocking) transaction wrapper methods. */
-class InstantTransactionMethodBinder(
+class InstantTransactionFunctionBinder(
private val returnType: XType,
- adapter: TransactionMethodAdapter,
-) : TransactionMethodBinder(adapter) {
+ adapter: TransactionFunctionAdapter,
+) : TransactionFunctionBinder(adapter) {
override fun executeAndReturn(
parameterNames: List<String>,
daoName: XClassName,
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/solver/transaction/binder/TransactionMethodBinder.kt b/room/room-compiler/src/main/kotlin/androidx/room/solver/transaction/binder/TransactionFunctionBinder.kt
similarity index 65%
rename from room/room-compiler/src/main/kotlin/androidx/room/solver/transaction/binder/TransactionMethodBinder.kt
rename to room/room-compiler/src/main/kotlin/androidx/room/solver/transaction/binder/TransactionFunctionBinder.kt
index 6665400..7705da5 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/solver/transaction/binder/TransactionMethodBinder.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/solver/transaction/binder/TransactionFunctionBinder.kt
@@ -19,20 +19,20 @@
import androidx.room.compiler.codegen.XClassName
import androidx.room.compiler.codegen.XPropertySpec
import androidx.room.solver.CodeGenScope
-import androidx.room.solver.transaction.result.TransactionMethodAdapter
+import androidx.room.solver.transaction.result.TransactionFunctionAdapter
/**
- * Connects a transaction method, database and a [TransactionMethodAdapter].
+ * Connects a transaction function, database and a [TransactionFunctionAdapter].
*
- * The default implementation is [InstantTransactionMethodBinder] that executes the transaction
+ * The default implementation is [InstantTransactionFunctionBinder] that executes the transaction
* synchronously. Other deferred transactions are unsupported expect for coroutines, for such
- * binding then [CoroutineTransactionMethodBinder] is used.
+ * binding then [CoroutineTransactionFunctionBinder] is used.
*/
-abstract class TransactionMethodBinder(val adapter: TransactionMethodAdapter) {
+abstract class TransactionFunctionBinder(val adapter: TransactionFunctionAdapter) {
/**
- * Receives the method's return type, parameters along with the Dao class names to generate the
- * transaction wrapper body that delegates to the non-abstract or default dao method.
+ * Receives the function's return type, parameters along with the Dao class names to generate
+ * the transaction wrapper body that delegates to the non-abstract or default dao function.
*/
abstract fun executeAndReturn(
parameterNames: List<String>,
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/solver/transaction/result/TransactionMethodAdapter.kt b/room/room-compiler/src/main/kotlin/androidx/room/solver/transaction/result/TransactionFunctionAdapter.kt
similarity index 83%
rename from room/room-compiler/src/main/kotlin/androidx/room/solver/transaction/result/TransactionMethodAdapter.kt
rename to room/room-compiler/src/main/kotlin/androidx/room/solver/transaction/result/TransactionFunctionAdapter.kt
index 3811e48..8ccbca2 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/solver/transaction/result/TransactionMethodAdapter.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/solver/transaction/result/TransactionFunctionAdapter.kt
@@ -21,16 +21,16 @@
import androidx.room.compiler.codegen.XCodeBlock
import androidx.room.ext.DEFAULT_IMPLS_CLASS_NAME
import androidx.room.solver.CodeGenScope
-import androidx.room.vo.TransactionMethod
+import androidx.room.vo.TransactionFunction
/**
- * Class that knows how to generate the transaction method delegate code. Callers should take care
+ * Class that knows how to generate the transaction function delegate code. Callers should take care
* of using the invocation code in a statement or in another block (such as a lambda).
*/
-class TransactionMethodAdapter(
- private val methodName: String,
+class TransactionFunctionAdapter(
+ private val functionName: String,
private val jvmMethodName: String,
- private val callType: TransactionMethod.CallType
+ private val callType: TransactionFunction.CallType
) {
fun createDelegateToSuperCode(
parameterNames: List<String>,
@@ -51,7 +51,7 @@
if (
scope.language == CodeLanguage.JAVA &&
- callType == TransactionMethod.CallType.DEFAULT_KOTLIN &&
+ callType == TransactionFunction.CallType.DEFAULT_KOTLIN &&
parameterNames.isNotEmpty()
) {
// An invoke to DefaultImpls has an extra 1st param so we need a comma if there
@@ -76,13 +76,13 @@
daoImplName: XClassName,
): XCodeBlock =
when (callType) {
- TransactionMethod.CallType.CONCRETE -> {
+ TransactionFunction.CallType.CONCRETE -> {
XCodeBlock.of("%T.super.%N(", daoImplName, jvmMethodName)
}
- TransactionMethod.CallType.DEFAULT_JAVA8 -> {
+ TransactionFunction.CallType.DEFAULT_JAVA8 -> {
XCodeBlock.of("%T.super.%N(", daoName, jvmMethodName)
}
- TransactionMethod.CallType.DEFAULT_KOTLIN -> {
+ TransactionFunction.CallType.DEFAULT_KOTLIN -> {
XCodeBlock.of(
"%T.%N.%N(%T.this",
daoName,
@@ -95,5 +95,5 @@
private fun CodeGenScope.getKotlinInvokeExpr(
daoImplName: XClassName,
- ): XCodeBlock = XCodeBlock.of("super@%T.%N(", daoImplName, methodName)
+ ): XCodeBlock = XCodeBlock.of("super@%T.%N(", daoImplName, functionName)
}
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/vo/Dao.kt b/room/room-compiler/src/main/kotlin/androidx/room/vo/Dao.kt
index 0f0d8b6..e24f25b 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/vo/Dao.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/vo/Dao.kt
@@ -24,15 +24,15 @@
data class Dao(
val element: XTypeElement,
val type: XType,
- val queryMethods: List<QueryMethod>,
- val rawQueryMethods: List<RawQueryMethod>,
- val insertMethods: List<InsertMethod>,
- val deleteMethods: List<DeleteMethod>,
- val updateMethods: List<UpdateMethod>,
- val upsertMethods: List<UpsertMethod>,
- val transactionMethods: List<TransactionMethod>,
- val kotlinBoxedPrimitiveMethodDelegates: List<KotlinBoxedPrimitiveMethodDelegate>,
- val kotlinDefaultMethodDelegates: List<KotlinDefaultMethodDelegate>,
+ val queryFunctions: List<QueryFunction>,
+ val rawQueryFunctions: List<RawQueryFunction>,
+ val insertFunctions: List<InsertFunction>,
+ val deleteFunctions: List<DeleteFunction>,
+ val updateFunctions: List<UpdateFunction>,
+ val upsertFunctions: List<UpsertFunction>,
+ val transactionFunctions: List<TransactionFunction>,
+ val kotlinBoxedPrimitiveFunctionDelegates: List<KotlinBoxedPrimitiveFunctionDelegate>,
+ val kotlinDefaultFunctionDelegates: List<KotlinDefaultFunctionDelegate>,
val constructorParamType: XTypeName?
) {
// parsed dao might have a suffix if it is used in multiple databases.
@@ -46,12 +46,12 @@
val typeName: XClassName by lazy { element.asClassName() }
- val deleteOrUpdateShortcutMethods: List<DeleteOrUpdateShortcutMethod> by lazy {
- deleteMethods + updateMethods
+ val mDeleteOrUpdateShortcutFunctions: List<DeleteOrUpdateShortcutFunction> by lazy {
+ deleteFunctions + updateFunctions
}
- val insertOrUpsertShortcutMethods: List<InsertOrUpsertShortcutMethod> by lazy {
- insertMethods + upsertMethods
+ val mInsertOrUpsertShortcutFunctions: List<InsertOrUpsertShortcutFunction> by lazy {
+ insertFunctions + upsertFunctions
}
val implTypeName: XClassName by lazy {
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/vo/DaoMethod.kt b/room/room-compiler/src/main/kotlin/androidx/room/vo/DaoFunction.kt
similarity index 85%
rename from room/room-compiler/src/main/kotlin/androidx/room/vo/DaoMethod.kt
rename to room/room-compiler/src/main/kotlin/androidx/room/vo/DaoFunction.kt
index 32fab37..a3bbbd2 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/vo/DaoMethod.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/vo/DaoFunction.kt
@@ -18,7 +18,7 @@
import androidx.room.compiler.processing.XMethodElement
-/** References a method that returns a dao in a Database */
-data class DaoMethod(val element: XMethodElement, val dao: Dao) {
+/** References a function that returns a dao in a Database */
+data class DaoFunction(val element: XMethodElement, val dao: Dao) {
val isProperty = element.isKotlinPropertyMethod()
}
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/vo/DataClassMethod.kt b/room/room-compiler/src/main/kotlin/androidx/room/vo/DataClassFunction.kt
similarity index 96%
rename from room/room-compiler/src/main/kotlin/androidx/room/vo/DataClassMethod.kt
rename to room/room-compiler/src/main/kotlin/androidx/room/vo/DataClassFunction.kt
index b8d948d..153b1d1 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/vo/DataClassMethod.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/vo/DataClassFunction.kt
@@ -20,7 +20,7 @@
import androidx.room.compiler.processing.XMethodType
/** An executable element processed as member of a class (data class or entity) */
-class DataClassMethod(
+class DataClassFunction(
val element: XMethodElement,
val resolvedType: XMethodType,
)
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/vo/Database.kt b/room/room-compiler/src/main/kotlin/androidx/room/vo/Database.kt
index 15f95d4..02efebf 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/vo/Database.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/vo/Database.kt
@@ -35,7 +35,7 @@
val type: XType,
val entities: List<Entity>,
val views: List<DatabaseView>,
- val daoMethods: List<DaoMethod>,
+ val daoFunctions: List<DaoFunction>,
val version: Int,
val exportSchema: Boolean,
val enableForeignKeys: Boolean,
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/vo/DeleteMethod.kt b/room/room-compiler/src/main/kotlin/androidx/room/vo/DeleteFunction.kt
similarity index 78%
rename from room/room-compiler/src/main/kotlin/androidx/room/vo/DeleteMethod.kt
rename to room/room-compiler/src/main/kotlin/androidx/room/vo/DeleteFunction.kt
index 7e69f5f..016e9b4 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/vo/DeleteMethod.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/vo/DeleteFunction.kt
@@ -16,11 +16,11 @@
package androidx.room.vo
import androidx.room.compiler.processing.XMethodElement
-import androidx.room.solver.shortcut.binder.DeleteOrUpdateMethodBinder
+import androidx.room.solver.shortcut.binder.DeleteOrUpdateFunctionBinder
-class DeleteMethod(
+class DeleteFunction(
element: XMethodElement,
entities: Map<String, ShortcutEntity>,
parameters: List<ShortcutQueryParameter>,
- methodBinder: DeleteOrUpdateMethodBinder?
-) : DeleteOrUpdateShortcutMethod(element, entities, parameters, methodBinder)
+ functionBinder: DeleteOrUpdateFunctionBinder?
+) : DeleteOrUpdateShortcutFunction(element, entities, parameters, functionBinder)
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/vo/DeleteOrUpdateShortcutMethod.kt b/room/room-compiler/src/main/kotlin/androidx/room/vo/DeleteOrUpdateShortcutFunction.kt
similarity index 78%
rename from room/room-compiler/src/main/kotlin/androidx/room/vo/DeleteOrUpdateShortcutMethod.kt
rename to room/room-compiler/src/main/kotlin/androidx/room/vo/DeleteOrUpdateShortcutFunction.kt
index ce477a6..4de4de6e 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/vo/DeleteOrUpdateShortcutMethod.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/vo/DeleteOrUpdateShortcutFunction.kt
@@ -17,12 +17,12 @@
package androidx.room.vo
import androidx.room.compiler.processing.XMethodElement
-import androidx.room.solver.shortcut.binder.DeleteOrUpdateMethodBinder
+import androidx.room.solver.shortcut.binder.DeleteOrUpdateFunctionBinder
-/** Base class for shortcut methods in @DAO. */
-abstract class DeleteOrUpdateShortcutMethod(
+/** Base class for shortcut functions in @DAO. */
+abstract class DeleteOrUpdateShortcutFunction(
val element: XMethodElement,
val entities: Map<String, ShortcutEntity>,
val parameters: List<ShortcutQueryParameter>,
- val methodBinder: DeleteOrUpdateMethodBinder?
+ val functionBinder: DeleteOrUpdateFunctionBinder?
)
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/vo/InsertMethod.kt b/room/room-compiler/src/main/kotlin/androidx/room/vo/InsertFunction.kt
similarity index 80%
rename from room/room-compiler/src/main/kotlin/androidx/room/vo/InsertMethod.kt
rename to room/room-compiler/src/main/kotlin/androidx/room/vo/InsertFunction.kt
index c97af3d..3a966ff 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/vo/InsertMethod.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/vo/InsertFunction.kt
@@ -19,13 +19,13 @@
import androidx.room.OnConflictStrategy
import androidx.room.compiler.processing.XMethodElement
import androidx.room.compiler.processing.XType
-import androidx.room.solver.shortcut.binder.InsertOrUpsertMethodBinder
+import androidx.room.solver.shortcut.binder.InsertOrUpsertFunctionBinder
-class InsertMethod(
+class InsertFunction(
element: XMethodElement,
@OnConflictStrategy val onConflict: Int,
entities: Map<String, ShortcutEntity>,
returnType: XType,
parameters: List<ShortcutQueryParameter>,
- methodBinder: InsertOrUpsertMethodBinder
-) : InsertOrUpsertShortcutMethod(element, entities, returnType, parameters, methodBinder)
+ functionBinder: InsertOrUpsertFunctionBinder
+) : InsertOrUpsertShortcutFunction(element, entities, returnType, parameters, functionBinder)
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/vo/InsertOrUpsertShortcutMethod.kt b/room/room-compiler/src/main/kotlin/androidx/room/vo/InsertOrUpsertShortcutFunction.kt
similarity index 79%
rename from room/room-compiler/src/main/kotlin/androidx/room/vo/InsertOrUpsertShortcutMethod.kt
rename to room/room-compiler/src/main/kotlin/androidx/room/vo/InsertOrUpsertShortcutFunction.kt
index 2d04873..94b1b47 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/vo/InsertOrUpsertShortcutMethod.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/vo/InsertOrUpsertShortcutFunction.kt
@@ -18,13 +18,13 @@
import androidx.room.compiler.processing.XMethodElement
import androidx.room.compiler.processing.XType
-import androidx.room.solver.shortcut.binder.InsertOrUpsertMethodBinder
+import androidx.room.solver.shortcut.binder.InsertOrUpsertFunctionBinder
-/** Base class for shortcut methods in @DAO. */
-abstract class InsertOrUpsertShortcutMethod(
+/** Base class for shortcut functions in @DAO. */
+abstract class InsertOrUpsertShortcutFunction(
val element: XMethodElement,
val entities: Map<String, ShortcutEntity>,
val returnType: XType,
val parameters: List<ShortcutQueryParameter>,
- val methodBinder: InsertOrUpsertMethodBinder?
+ val functionBinder: InsertOrUpsertFunctionBinder?
)
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/vo/KotlinBoxedPrimitiveMethodDelegate.kt b/room/room-compiler/src/main/kotlin/androidx/room/vo/KotlinBoxedPrimitiveFunctionDelegate.kt
similarity index 65%
rename from room/room-compiler/src/main/kotlin/androidx/room/vo/KotlinBoxedPrimitiveMethodDelegate.kt
rename to room/room-compiler/src/main/kotlin/androidx/room/vo/KotlinBoxedPrimitiveFunctionDelegate.kt
index 0a7ed24..4b5076d 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/vo/KotlinBoxedPrimitiveMethodDelegate.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/vo/KotlinBoxedPrimitiveFunctionDelegate.kt
@@ -19,11 +19,11 @@
import androidx.room.compiler.processing.XMethodElement
/**
- * Represents a DAO bridge method that to supported the boxed version of a generic abstract class or
- * interface in Kotlin. When generating the Java implementation of the DAO, Room needs to also
- * override the bridge method generated by Kotlin for the boxed version support, see KT-46650.
+ * Represents a DAO bridge function that to supported the boxed version of a generic abstract class
+ * or interface in Kotlin. When generating the Java implementation of the DAO, Room needs to also
+ * override the bridge function generated by Kotlin for the boxed version support, see KT-46650.
*/
-data class KotlinBoxedPrimitiveMethodDelegate(
+data class KotlinBoxedPrimitiveFunctionDelegate(
val element: XMethodElement,
- val concreteMethod: XMethodElement
+ val concreteFunction: XMethodElement
)
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/vo/KotlinDefaultMethodDelegate.kt b/room/room-compiler/src/main/kotlin/androidx/room/vo/KotlinDefaultFunctionDelegate.kt
similarity index 86%
rename from room/room-compiler/src/main/kotlin/androidx/room/vo/KotlinDefaultMethodDelegate.kt
rename to room/room-compiler/src/main/kotlin/androidx/room/vo/KotlinDefaultFunctionDelegate.kt
index a6a43b4..de4ffe0 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/vo/KotlinDefaultMethodDelegate.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/vo/KotlinDefaultFunctionDelegate.kt
@@ -19,10 +19,10 @@
import androidx.room.compiler.processing.XMethodElement
/**
- * Represents a DAO method that delegates to a concrete implementation, specifically to override a
+ * Represents a DAO function that delegates to a concrete implementation, specifically to override a
* Kotlin interface whose implementation is in the DefaultImpl generated class.
*/
-data class KotlinDefaultMethodDelegate(
+data class KotlinDefaultFunctionDelegate(
// the original element, not the stub that is generated for DefaultImpls
val element: XMethodElement
)
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/vo/QueryMethod.kt b/room/room-compiler/src/main/kotlin/androidx/room/vo/QueryFunction.kt
similarity index 81%
rename from room/room-compiler/src/main/kotlin/androidx/room/vo/QueryMethod.kt
rename to room/room-compiler/src/main/kotlin/androidx/room/vo/QueryFunction.kt
index 6d837c0..0ff3413 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/vo/QueryMethod.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/vo/QueryFunction.kt
@@ -23,10 +23,10 @@
import androidx.room.solver.query.result.QueryResultBinder
/**
- * A class that holds information about a QueryMethod. It is self sufficient and must have all
+ * A class that holds information about a QueryFunction. It is self sufficient and must have all
* generics etc resolved once created.
*/
-sealed class QueryMethod(
+sealed class QueryFunction(
val element: XMethodElement,
val query: ParsedQuery,
val returnType: XType,
@@ -46,23 +46,23 @@
}
}
-/** A query method who's query is a SELECT statement. */
-class ReadQueryMethod(
+/** A query function who's query is a SELECT statement. */
+class ReadQueryFunction(
element: XMethodElement,
query: ParsedQuery,
returnType: XType,
parameters: List<QueryParameter>,
val inTransaction: Boolean,
val queryResultBinder: QueryResultBinder
-) : QueryMethod(element, query, returnType, parameters) {
+) : QueryFunction(element, query, returnType, parameters) {
val isProperty = element.isKotlinPropertyMethod()
}
-/** A query method who's query is a INSERT, UPDATE or DELETE statement. */
-class WriteQueryMethod(
+/** A query function who's query is a INSERT, UPDATE or DELETE statement. */
+class WriteQueryFunction(
element: XMethodElement,
query: ParsedQuery,
returnType: XType,
parameters: List<QueryParameter>,
val preparedQueryResultBinder: PreparedQueryResultBinder
-) : QueryMethod(element, query, returnType, parameters)
+) : QueryFunction(element, query, returnType, parameters)
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/vo/RawQueryMethod.kt b/room/room-compiler/src/main/kotlin/androidx/room/vo/RawQueryFunction.kt
similarity index 89%
rename from room/room-compiler/src/main/kotlin/androidx/room/vo/RawQueryMethod.kt
rename to room/room-compiler/src/main/kotlin/androidx/room/vo/RawQueryFunction.kt
index c447dd3..c359a85 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/vo/RawQueryMethod.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/vo/RawQueryFunction.kt
@@ -27,10 +27,10 @@
import androidx.room.solver.query.result.QueryResultBinder
/**
- * A class that holds information about a method annotated with RawQuery. It is self sufficient and
- * must have all generics etc resolved once created.
+ * A class that holds information about a function annotated with RawQuery. It is self sufficient
+ * and must have all generics etc resolved once created.
*/
-data class RawQueryMethod(
+data class RawQueryFunction(
val element: XMethodElement,
val returnType: XType,
val inTransaction: Boolean,
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/vo/ShortcutQueryParameter.kt b/room/room-compiler/src/main/kotlin/androidx/room/vo/ShortcutQueryParameter.kt
index 90196b8..425eb69 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/vo/ShortcutQueryParameter.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/vo/ShortcutQueryParameter.kt
@@ -20,7 +20,7 @@
import androidx.room.compiler.processing.XType
import androidx.room.compiler.processing.XVariableElement
-/** Parameters used in DAO methods that are annotated with Insert, Delete, Update, and Upsert. */
+/** Parameters used in DAO functions that are annotated with Insert, Delete, Update, and Upsert. */
data class ShortcutQueryParameter(
val element: XVariableElement,
val name: String,
@@ -28,8 +28,8 @@
val pojoType: XType?, // extracted type, never a Collection
val isMultiple: Boolean
) {
- /** Method name in entity insertion or update adapter. */
- val handleMethodName =
+ /** Function name in entity insertion or update adapter. */
+ val handleFunctionName =
if (isMultiple) {
"handleMultiple"
} else {
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/vo/TransactionMethod.kt b/room/room-compiler/src/main/kotlin/androidx/room/vo/TransactionFunction.kt
similarity index 83%
rename from room/room-compiler/src/main/kotlin/androidx/room/vo/TransactionMethod.kt
rename to room/room-compiler/src/main/kotlin/androidx/room/vo/TransactionFunction.kt
index a63abbc..6edaef4 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/vo/TransactionMethod.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/vo/TransactionFunction.kt
@@ -18,17 +18,17 @@
import androidx.room.compiler.processing.XMethodElement
import androidx.room.compiler.processing.XType
-import androidx.room.solver.transaction.binder.TransactionMethodBinder
+import androidx.room.solver.transaction.binder.TransactionFunctionBinder
-class TransactionMethod(
+class TransactionFunction(
val element: XMethodElement,
val returnType: XType,
val parameterNames: List<String>,
val callType: CallType,
- val methodBinder: TransactionMethodBinder
+ val functionBinder: TransactionFunctionBinder
) {
enum class CallType {
- /** Directly call the method, it has a super implementation */
+ /** Directly call the function, it has a super implementation */
CONCRETE,
/**
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/vo/UpdateMethod.kt b/room/room-compiler/src/main/kotlin/androidx/room/vo/UpdateFunction.kt
similarity index 79%
rename from room/room-compiler/src/main/kotlin/androidx/room/vo/UpdateMethod.kt
rename to room/room-compiler/src/main/kotlin/androidx/room/vo/UpdateFunction.kt
index bbcc6fa..fbf3eaa 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/vo/UpdateMethod.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/vo/UpdateFunction.kt
@@ -18,12 +18,12 @@
import androidx.room.OnConflictStrategy
import androidx.room.compiler.processing.XMethodElement
-import androidx.room.solver.shortcut.binder.DeleteOrUpdateMethodBinder
+import androidx.room.solver.shortcut.binder.DeleteOrUpdateFunctionBinder
-class UpdateMethod(
+class UpdateFunction(
element: XMethodElement,
entities: Map<String, ShortcutEntity>,
parameters: List<ShortcutQueryParameter>,
- methodBinder: DeleteOrUpdateMethodBinder?,
+ functionBinder: DeleteOrUpdateFunctionBinder?,
@OnConflictStrategy val onConflictStrategy: Int
-) : DeleteOrUpdateShortcutMethod(element, entities, parameters, methodBinder)
+) : DeleteOrUpdateShortcutFunction(element, entities, parameters, functionBinder)
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/vo/UpsertMethod.kt b/room/room-compiler/src/main/kotlin/androidx/room/vo/UpsertFunction.kt
similarity index 78%
rename from room/room-compiler/src/main/kotlin/androidx/room/vo/UpsertMethod.kt
rename to room/room-compiler/src/main/kotlin/androidx/room/vo/UpsertFunction.kt
index 161aa46..5ebb039 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/vo/UpsertMethod.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/vo/UpsertFunction.kt
@@ -18,12 +18,12 @@
import androidx.room.compiler.processing.XMethodElement
import androidx.room.compiler.processing.XType
-import androidx.room.solver.shortcut.binder.InsertOrUpsertMethodBinder
+import androidx.room.solver.shortcut.binder.InsertOrUpsertFunctionBinder
-class UpsertMethod(
+class UpsertFunction(
element: XMethodElement,
entities: Map<String, ShortcutEntity>,
returnType: XType,
parameters: List<ShortcutQueryParameter>,
- methodBinder: InsertOrUpsertMethodBinder
-) : InsertOrUpsertShortcutMethod(element, entities, returnType, parameters, methodBinder)
+ functionBinder: InsertOrUpsertFunctionBinder
+) : InsertOrUpsertShortcutFunction(element, entities, returnType, parameters, functionBinder)
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/vo/Warning.kt b/room/room-compiler/src/main/kotlin/androidx/room/vo/Warning.kt
index 181bf5b..cdfbbc8 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/vo/Warning.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/vo/Warning.kt
@@ -48,7 +48,7 @@
// expand projection is removed.
EXPAND_PROJECTION_WITH_REMOVE_UNUSED_COLUMNS("ROOM_EXPAND_PROJECTION_WITH_UNUSED_COLUMNS"),
// We shouldn't let devs suppress this error via Room so there is no runtime constant for it
- JVM_NAME_ON_OVERRIDDEN_METHOD("ROOM_JVM_NAME_IN_OVERRIDDEN_METHOD"),
+ JVM_NAME_ON_OVERRIDDEN_FUNCTION("ROOM_JVM_NAME_IN_OVERRIDDEN_FUNCTION"),
AMBIGUOUS_COLUMN_IN_RESULT("ROOM_AMBIGUOUS_COLUMN_IN_RESULT"),
UNNECESSARY_NULLABILITY_IN_DAO_RETURN_TYPE("ROOM_UNNECESSARY_NULLABILITY_IN_DAO_RETURN_TYPE");
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/writer/DaoWriter.kt b/room/room-compiler/src/main/kotlin/androidx/room/writer/DaoWriter.kt
index 4f73947..5130e72 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/writer/DaoWriter.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/writer/DaoWriter.kt
@@ -45,21 +45,21 @@
import androidx.room.ext.capitalize
import androidx.room.processor.OnConflictProcessor
import androidx.room.solver.CodeGenScope
-import androidx.room.solver.KotlinBoxedPrimitiveMethodDelegateBinder
-import androidx.room.solver.KotlinDefaultMethodDelegateBinder
+import androidx.room.solver.KotlinBoxedPrimitiveFunctionDelegateBinder
+import androidx.room.solver.KotlinDefaultFunctionDelegateBinder
import androidx.room.solver.types.getRequiredTypeConverters
import androidx.room.vo.Dao
-import androidx.room.vo.DeleteOrUpdateShortcutMethod
-import androidx.room.vo.InsertMethod
-import androidx.room.vo.KotlinBoxedPrimitiveMethodDelegate
-import androidx.room.vo.KotlinDefaultMethodDelegate
-import androidx.room.vo.RawQueryMethod
-import androidx.room.vo.ReadQueryMethod
+import androidx.room.vo.DeleteOrUpdateShortcutFunction
+import androidx.room.vo.InsertFunction
+import androidx.room.vo.KotlinBoxedPrimitiveFunctionDelegate
+import androidx.room.vo.KotlinDefaultFunctionDelegate
+import androidx.room.vo.RawQueryFunction
+import androidx.room.vo.ReadQueryFunction
import androidx.room.vo.ShortcutEntity
-import androidx.room.vo.TransactionMethod
-import androidx.room.vo.UpdateMethod
-import androidx.room.vo.UpsertMethod
-import androidx.room.vo.WriteQueryMethod
+import androidx.room.vo.TransactionFunction
+import androidx.room.vo.UpdateFunction
+import androidx.room.vo.UpsertFunction
+import androidx.room.vo.WriteQueryFunction
import com.squareup.kotlinpoet.FunSpec
import com.squareup.kotlinpoet.KModifier
import com.squareup.kotlinpoet.jvm.jvmName
@@ -82,7 +82,7 @@
private val companionTypeBuilder = lazy { XTypeSpec.companionObjectBuilder() }
companion object {
- const val GET_LIST_OF_TYPE_CONVERTERS_METHOD = "getRequiredConverters"
+ const val GET_LIST_OF_TYPE_CONVERTERS_FUNCTION = "getRequiredConverters"
const val DB_PROPERTY_NAME = "__db"
@@ -103,14 +103,14 @@
override fun createTypeSpecBuilder(): XTypeSpec.Builder {
val builder = XTypeSpec.classBuilder(className)
- val preparedQueries = dao.queryMethods.filterIsInstance<WriteQueryMethod>()
+ val preparedQueries = dao.queryFunctions.filterIsInstance<WriteQueryFunction>()
- val shortcutMethods = buildList {
- addAll(createInsertMethods())
- addAll(createDeleteMethods())
- addAll(createUpdateMethods())
- addAll(createTransactionMethods())
- addAll(createUpsertMethods())
+ val shortcutFunctions = buildList {
+ addAll(createInsertFunctions())
+ addAll(createDeleteFunctions())
+ addAll(createUpdateFunctions())
+ addAll(createTransactionFunctions())
+ addAll(createUpsertFunctions())
}
builder.apply {
@@ -130,20 +130,20 @@
addProperty(dbProperty)
setPrimaryConstructor(
- createConstructor(shortcutMethods, dao.constructorParamType != null)
+ createConstructor(shortcutFunctions, dao.constructorParamType != null)
)
- shortcutMethods.forEach { addFunction(it.functionImpl) }
- dao.queryMethods.filterIsInstance<ReadQueryMethod>().forEach { method ->
- addFunction(createSelectMethod(method))
- if (method.isProperty) {
+ shortcutFunctions.forEach { addFunction(it.functionImpl) }
+ dao.queryFunctions.filterIsInstance<ReadQueryFunction>().forEach { function ->
+ addFunction(createSelectFunction(function))
+ if (function.isProperty) {
// DAO function is a getter from a Kotlin property, generate property override.
applyToKotlinPoet {
addProperty(
- PropertySpecHelper.overriding(method.element, declaredDao)
+ PropertySpecHelper.overriding(function.element, declaredDao)
.getter(
FunSpec.getterBuilder()
- .addCode("return %L()", method.element.name)
+ .addCode("return %L()", function.element.name)
.build()
)
.build()
@@ -151,20 +151,20 @@
}
}
}
- preparedQueries.forEach { addFunction(createPreparedQueryMethod(it)) }
- dao.rawQueryMethods.forEach { addFunction(createRawQueryMethod(it)) }
+ preparedQueries.forEach { addFunction(createPreparedQueryFunction(it)) }
+ dao.rawQueryFunctions.forEach { addFunction(createRawQueryFunction(it)) }
applyTo(CodeLanguage.JAVA) {
- dao.kotlinDefaultMethodDelegates.forEach {
- addFunction(createDefaultImplMethodDelegate(it))
+ dao.kotlinDefaultFunctionDelegates.forEach {
+ addFunction(createDefaultImplFunctionDelegate(it))
}
- dao.kotlinBoxedPrimitiveMethodDelegates.forEach {
- addFunction(createBoxedPrimitiveBridgeMethodDelegate(it))
+ dao.kotlinBoxedPrimitiveFunctionDelegates.forEach {
+ addFunction(createBoxedPrimitiveBridgeFunctionDelegate(it))
}
}
// Keep this the last one to be generated because used custom converters will
// register fields with a payload which we collect in dao to report used
// Type Converters.
- addConverterListMethod(this)
+ addConverterListFunction(this)
applyTo(CodeLanguage.KOTLIN) {
if (companionTypeBuilder.isInitialized()) {
addType(companionTypeBuilder.value.build())
@@ -174,16 +174,16 @@
return builder
}
- private fun addConverterListMethod(typeSpecBuilder: XTypeSpec.Builder) {
+ private fun addConverterListFunction(typeSpecBuilder: XTypeSpec.Builder) {
// For Java a static method is created
- typeSpecBuilder.applyTo(CodeLanguage.JAVA) { addFunction(createConverterListMethod()) }
+ typeSpecBuilder.applyTo(CodeLanguage.JAVA) { addFunction(createConverterListFunction()) }
// For Kotlin a function in the companion object is created
companionTypeBuilder.value.applyTo(CodeLanguage.KOTLIN) {
- addFunction(createConverterListMethod())
+ addFunction(createConverterListFunction())
}
}
- private fun createConverterListMethod(): XFunSpec {
+ private fun createConverterListFunction(): XFunSpec {
val body = buildCodeBlock { language ->
val requiredTypeConverters = getRequiredTypeConverters()
if (requiredTypeConverters.isEmpty()) {
@@ -218,7 +218,7 @@
}
}
}
- return XFunSpec.builder(GET_LIST_OF_TYPE_CONVERTERS_METHOD, VisibilityModifier.PUBLIC)
+ return XFunSpec.builder(GET_LIST_OF_TYPE_CONVERTERS_FUNCTION, VisibilityModifier.PUBLIC)
.applyToJavaPoet { addModifiers(javax.lang.model.element.Modifier.STATIC) }
.applyTo { language ->
returns(
@@ -234,33 +234,33 @@
.build()
}
- private fun createTransactionMethods(): List<PreparedStmtQuery> {
- return dao.transactionMethods.map {
- PreparedStmtQuery(emptyMap(), createTransactionMethodBody(it))
+ private fun createTransactionFunctions(): List<PreparedStmtQuery> {
+ return dao.transactionFunctions.map {
+ PreparedStmtQuery(emptyMap(), createTransactionFunctionBody(it))
}
}
- private fun createTransactionMethodBody(method: TransactionMethod): XFunSpec {
+ private fun createTransactionFunctionBody(function: TransactionFunction): XFunSpec {
val scope = CodeGenScope(this)
- method.methodBinder.executeAndReturn(
- parameterNames = method.parameterNames,
+ function.functionBinder.executeAndReturn(
+ parameterNames = function.parameterNames,
daoName = dao.typeName,
daoImplName = dao.implTypeName,
dbProperty = dbProperty,
scope = scope
)
- return overrideWithoutAnnotations(method.element, declaredDao)
+ return overrideWithoutAnnotations(function.element, declaredDao)
.addCode(scope.generate())
.build()
}
private fun createConstructor(
- shortcutMethods: List<PreparedStmtQuery>,
+ shortcutFunctions: List<PreparedStmtQuery>,
callSuper: Boolean
): XFunSpec {
val body = buildCodeBlock {
addStatement("this.%N = %L", dbProperty, dbProperty.name)
- shortcutMethods
+ shortcutFunctions
.asSequence()
.filterNot { it.fields.isEmpty() }
.map { it.fields.values }
@@ -282,11 +282,11 @@
.build()
}
- private fun createSelectMethod(method: ReadQueryMethod): XFunSpec {
- return overrideWithoutAnnotations(method.element, declaredDao)
+ private fun createSelectFunction(function: ReadQueryFunction): XFunSpec {
+ return overrideWithoutAnnotations(function.element, declaredDao)
.applyToKotlinPoet {
// TODO: Update XPoet to better handle this case.
- if (method.isProperty) {
+ if (function.isProperty) {
// When the DAO function is from a Kotlin property, we'll still generate
// a DAO function, but it won't be an override and it'll be private, to be
// called from the overridden property's getter.
@@ -302,34 +302,34 @@
context.targetPlatforms.size == 1 &&
context.targetPlatforms.contains(XProcessingEnv.Platform.JVM)
) {
- jvmName("_private${method.element.name.capitalize(Locale.US)}")
+ jvmName("_private${function.element.name.capitalize(Locale.US)}")
}
}
}
- .addCode(createQueryMethodBody(method))
+ .addCode(createQueryFunctionBody(function))
.build()
}
- private fun createRawQueryMethod(method: RawQueryMethod): XFunSpec {
- return overrideWithoutAnnotations(method.element, declaredDao)
+ private fun createRawQueryFunction(function: RawQueryFunction): XFunSpec {
+ return overrideWithoutAnnotations(function.element, declaredDao)
.addCode(
if (
- method.runtimeQueryParam == null ||
- method.queryResultBinder.usesCompatQueryWriter
+ function.runtimeQueryParam == null ||
+ function.queryResultBinder.usesCompatQueryWriter
) {
- compatCreateRawQueryMethodBody(method)
+ compatCreateRawQueryFunctionBody(function)
} else {
- createRawQueryMethodBody(method)
+ createRawQueryFunctionBody(function)
}
)
.build()
}
- private fun createRawQueryMethodBody(method: RawQueryMethod): XCodeBlock {
+ private fun createRawQueryFunctionBody(function: RawQueryFunction): XCodeBlock {
val scope = CodeGenScope(this@DaoWriter)
val sqlQueryVar = scope.getTmpVar("_sql")
val rawQueryParamName =
- if (method.runtimeQueryParam!!.isSupportQuery()) {
+ if (function.runtimeQueryParam!!.isSupportQuery()) {
val rawQueryVar = scope.getTmpVar("_rawQuery")
scope.builder.addLocalVariable(
name = rawQueryVar,
@@ -338,12 +338,12 @@
XCodeBlock.of(
format = "%T.copyFrom(%L).toRoomRawQuery()",
ROOM_SQL_QUERY,
- method.runtimeQueryParam.paramName
+ function.runtimeQueryParam.paramName
)
)
rawQueryVar
} else {
- method.runtimeQueryParam.paramName
+ function.runtimeQueryParam.paramName
}
scope.builder.addLocalVal(
@@ -354,8 +354,8 @@
XCodeBlock.ofString(java = "getSql()", kotlin = "sql")
)
- if (method.returnsValue) {
- method.queryResultBinder.convertAndReturn(
+ if (function.returnsValue) {
+ function.queryResultBinder.convertAndReturn(
sqlQueryVar = sqlQueryVar,
dbProperty = dbProperty,
bindStatement = { stmtVar ->
@@ -365,8 +365,8 @@
stmtVar
)
},
- returnTypeName = method.returnType.asTypeName(),
- inTransaction = method.inTransaction,
+ returnTypeName = function.returnType.asTypeName(),
+ inTransaction = function.inTransaction,
scope = scope
)
}
@@ -374,12 +374,12 @@
}
/** Used by the Non-KMP Paging3 binders and the Paging2 binders. */
- private fun compatCreateRawQueryMethodBody(method: RawQueryMethod): XCodeBlock =
+ private fun compatCreateRawQueryFunctionBody(function: RawQueryFunction): XCodeBlock =
XCodeBlock.builder()
.apply {
val scope = CodeGenScope(this@DaoWriter)
val roomSQLiteQueryVar: String
- val queryParam = method.runtimeQueryParam
+ val queryParam = function.runtimeQueryParam
if (queryParam?.isSupportQuery() == true) {
queryParam.paramName
} else if (queryParam?.isString() == true) {
@@ -408,10 +408,10 @@
),
)
}
- val rawQueryParamName = method.runtimeQueryParam?.paramName
+ val rawQueryParamName = function.runtimeQueryParam?.paramName
if (rawQueryParamName != null) {
- if (method.returnsValue) {
- method.queryResultBinder.convertAndReturn(
+ if (function.returnsValue) {
+ function.queryResultBinder.convertAndReturn(
sqlQueryVar = rawQueryParamName,
dbProperty = dbProperty,
bindStatement = { stmtVar ->
@@ -421,8 +421,8 @@
stmtVar
)
},
- returnTypeName = method.returnType.asTypeName(),
- inTransaction = method.inTransaction,
+ returnTypeName = function.returnType.asTypeName(),
+ inTransaction = function.inTransaction,
scope = scope
)
}
@@ -431,48 +431,48 @@
}
.build()
- private fun createPreparedQueryMethod(method: WriteQueryMethod): XFunSpec {
- return overrideWithoutAnnotations(method.element, declaredDao)
- .addCode(createPreparedQueryMethodBody(method))
+ private fun createPreparedQueryFunction(function: WriteQueryFunction): XFunSpec {
+ return overrideWithoutAnnotations(function.element, declaredDao)
+ .addCode(createPreparedQueryFunctionBody(function))
.build()
}
/**
- * Groups all insert methods based on the insert statement they will use then creates all field
- * specs, EntityInsertAdapterWriter and actual insert methods.
+ * Groups all insert functions based on the insert statement they will use then creates all
+ * field specs, EntityInsertAdapterWriter and actual insert functions.
*/
- private fun createInsertMethods(): List<PreparedStmtQuery> {
- return dao.insertMethods.map { insertMethod ->
- val onConflict = OnConflictProcessor.onConflictText(insertMethod.onConflict)
- val entities = insertMethod.entities
+ private fun createInsertFunctions(): List<PreparedStmtQuery> {
+ return dao.insertFunctions.map { insertFunction ->
+ val onConflict = OnConflictProcessor.onConflictText(insertFunction.onConflict)
+ val entities = insertFunction.entities
val fields =
entities.mapValues {
- val spec = getOrCreateProperty(InsertMethodProperty(it.value, onConflict))
+ val spec = getOrCreateProperty(InsertFunctionProperty(it.value, onConflict))
val impl =
EntityInsertAdapterWriter.create(it.value, onConflict)
.createAnonymous(this@DaoWriter)
spec to impl
}
- val methodImpl =
- overrideWithoutAnnotations(insertMethod.element, declaredDao)
- .apply { addCode(createInsertMethodBody(insertMethod, fields)) }
+ val functionImpl =
+ overrideWithoutAnnotations(insertFunction.element, declaredDao)
+ .apply { addCode(createInsertFunctionBody(insertFunction, fields)) }
.build()
- PreparedStmtQuery(fields, methodImpl)
+ PreparedStmtQuery(fields, functionImpl)
}
}
- private fun createInsertMethodBody(
- method: InsertMethod,
+ private fun createInsertFunctionBody(
+ function: InsertFunction,
insertAdapters: Map<String, Pair<XPropertySpec, XTypeSpec>>
): XCodeBlock {
- if (insertAdapters.isEmpty() || method.methodBinder == null) {
+ if (insertAdapters.isEmpty() || function.functionBinder == null) {
return XCodeBlock.builder().build()
}
val scope = CodeGenScope(writer = this)
- ShortcutQueryParameterWriter.addNullCheckValidation(scope, method.parameters)
- method.methodBinder.convertAndReturn(
- parameters = method.parameters,
+ ShortcutQueryParameterWriter.addNullCheckValidation(scope, function.parameters)
+ function.functionBinder.convertAndReturn(
+ parameters = function.parameters,
adapters = insertAdapters,
dbProperty = dbProperty,
scope = scope
@@ -480,34 +480,34 @@
return scope.generate()
}
- /** Creates EntityUpdateAdapter for each delete method. */
- private fun createDeleteMethods(): List<PreparedStmtQuery> {
- return createShortcutMethods(dao.deleteMethods, "delete") { _, entity ->
+ /** Creates EntityUpdateAdapter for each delete function. */
+ private fun createDeleteFunctions(): List<PreparedStmtQuery> {
+ return createShortcutFunctions(dao.deleteFunctions, "delete") { _, entity ->
EntityDeleteAdapterWriter.create(entity).createAnonymous(this@DaoWriter)
}
}
- /** Creates EntityUpdateAdapter for each @Update method. */
- private fun createUpdateMethods(): List<PreparedStmtQuery> {
- return createShortcutMethods(dao.updateMethods, "update") { update, entity ->
+ /** Creates EntityUpdateAdapter for each @Update function. */
+ private fun createUpdateFunctions(): List<PreparedStmtQuery> {
+ return createShortcutFunctions(dao.updateFunctions, "update") { update, entity ->
val onConflict = OnConflictProcessor.onConflictText(update.onConflictStrategy)
EntityUpdateAdapterWriter.create(entity, onConflict).createAnonymous(this@DaoWriter)
}
}
- private fun <T : DeleteOrUpdateShortcutMethod> createShortcutMethods(
- methods: List<T>,
- methodPrefix: String,
+ private fun <T : DeleteOrUpdateShortcutFunction> createShortcutFunctions(
+ functions: List<T>,
+ functionPrefix: String,
implCallback: (T, ShortcutEntity) -> XTypeSpec
): List<PreparedStmtQuery> {
- return methods.mapNotNull { method ->
- val entities = method.entities
+ return functions.mapNotNull { function ->
+ val entities = function.entities
if (entities.isEmpty()) {
null
} else {
val onConflict =
- if (method is UpdateMethod) {
- OnConflictProcessor.onConflictText(method.onConflictStrategy)
+ if (function is UpdateFunction) {
+ OnConflictProcessor.onConflictText(function.onConflictStrategy)
} else {
""
}
@@ -515,31 +515,31 @@
entities.mapValues {
val spec =
getOrCreateProperty(
- DeleteOrUpdateAdapterProperty(it.value, methodPrefix, onConflict)
+ DeleteOrUpdateAdapterProperty(it.value, functionPrefix, onConflict)
)
- val impl = implCallback(method, it.value)
+ val impl = implCallback(function, it.value)
spec to impl
}
- val methodSpec =
- overrideWithoutAnnotations(method.element, declaredDao)
- .apply { addCode(createDeleteOrUpdateMethodBody(method, fields)) }
+ val functionSpec =
+ overrideWithoutAnnotations(function.element, declaredDao)
+ .apply { addCode(createDeleteOrUpdateFunctionBody(function, fields)) }
.build()
- PreparedStmtQuery(fields, methodSpec)
+ PreparedStmtQuery(fields, functionSpec)
}
}
}
- private fun createDeleteOrUpdateMethodBody(
- method: DeleteOrUpdateShortcutMethod,
+ private fun createDeleteOrUpdateFunctionBody(
+ function: DeleteOrUpdateShortcutFunction,
adapters: Map<String, Pair<XPropertySpec, XTypeSpec>>
): XCodeBlock {
- if (adapters.isEmpty() || method.methodBinder == null) {
+ if (adapters.isEmpty() || function.functionBinder == null) {
return XCodeBlock.builder().build()
}
val scope = CodeGenScope(writer = this)
- ShortcutQueryParameterWriter.addNullCheckValidation(scope, method.parameters)
- method.methodBinder.convertAndReturn(
- parameters = method.parameters,
+ ShortcutQueryParameterWriter.addNullCheckValidation(scope, function.parameters)
+ function.functionBinder.convertAndReturn(
+ parameters = function.parameters,
adapters = adapters,
dbProperty = dbProperty,
scope = scope
@@ -548,12 +548,12 @@
}
/**
- * Groups all upsert methods based on the upsert statement they will use then creates all field
- * specs, EntityUpsertAdapterWriter and actual upsert methods.
+ * Groups all upsert functions based on the upsert statement they will use then creates all
+ * field specs, EntityUpsertAdapterWriter and actual upsert functions.
*/
- private fun createUpsertMethods(): List<PreparedStmtQuery> {
- return dao.upsertMethods.map { upsertMethod ->
- val entities = upsertMethod.entities
+ private fun createUpsertFunctions(): List<PreparedStmtQuery> {
+ return dao.upsertFunctions.map { upsertFunctions ->
+ val entities = upsertFunctions.entities
val fields =
entities.mapValues {
val spec = getOrCreateProperty(UpsertAdapterProperty(it.value))
@@ -562,25 +562,25 @@
.createConcrete(it.value, this@DaoWriter)
spec to impl
}
- val methodImpl =
- overrideWithoutAnnotations(upsertMethod.element, declaredDao)
- .apply { addCode(createUpsertMethodBody(upsertMethod, fields)) }
+ val functionImpl =
+ overrideWithoutAnnotations(upsertFunctions.element, declaredDao)
+ .apply { addCode(createUpsertFunctionBody(upsertFunctions, fields)) }
.build()
- PreparedStmtQuery(fields, methodImpl)
+ PreparedStmtQuery(fields, functionImpl)
}
}
- private fun createUpsertMethodBody(
- method: UpsertMethod,
+ private fun createUpsertFunctionBody(
+ function: UpsertFunction,
upsertAdapters: Map<String, Pair<XPropertySpec, XCodeBlock>>
): XCodeBlock {
- if (upsertAdapters.isEmpty() || method.methodBinder == null) {
+ if (upsertAdapters.isEmpty() || function.functionBinder == null) {
return XCodeBlock.builder().build()
}
val scope = CodeGenScope(writer = this)
- ShortcutQueryParameterWriter.addNullCheckValidation(scope, method.parameters)
- method.methodBinder.convertAndReturn(
- parameters = method.parameters,
+ ShortcutQueryParameterWriter.addNullCheckValidation(scope, function.parameters)
+ function.functionBinder.convertAndReturn(
+ parameters = function.parameters,
adapters = upsertAdapters,
dbProperty = dbProperty,
scope = scope
@@ -588,28 +588,28 @@
return scope.generate()
}
- private fun createPreparedQueryMethodBody(method: WriteQueryMethod): XCodeBlock {
+ private fun createPreparedQueryFunctionBody(function: WriteQueryFunction): XCodeBlock {
val scope = CodeGenScope(this)
- val queryWriter = QueryWriter(method)
+ val queryWriter = QueryWriter(function)
val sqlVar = scope.getTmpVar("_sql")
val listSizeArgs = queryWriter.prepareQuery(sqlVar, scope)
- method.preparedQueryResultBinder.executeAndReturn(
+ function.preparedQueryResultBinder.executeAndReturn(
sqlQueryVar = sqlVar,
dbProperty = dbProperty,
bindStatement = { stmtVar -> queryWriter.bindArgs(stmtVar, listSizeArgs, this) },
- returnTypeName = method.returnType.asTypeName(),
+ returnTypeName = function.returnType.asTypeName(),
scope = scope
)
return scope.generate()
}
- private fun createQueryMethodBody(method: ReadQueryMethod): XCodeBlock {
+ private fun createQueryFunctionBody(function: ReadQueryFunction): XCodeBlock {
val scope = CodeGenScope(this)
- val queryWriter = QueryWriter(method)
+ val queryWriter = QueryWriter(function)
val sqlStringVar = scope.getTmpVar("_sql")
val (sqlVar, listSizeArgs) =
- if (method.queryResultBinder.usesCompatQueryWriter) {
+ if (function.queryResultBinder.usesCompatQueryWriter) {
val roomSQLiteQueryVar = scope.getTmpVar("_statement")
queryWriter.prepareReadAndBind(sqlStringVar, roomSQLiteQueryVar, scope)
roomSQLiteQueryVar to emptyList()
@@ -624,12 +624,12 @@
null
}
- method.queryResultBinder.convertAndReturn(
+ function.queryResultBinder.convertAndReturn(
sqlQueryVar = sqlVar,
dbProperty = dbProperty,
bindStatement = bindStatement,
- returnTypeName = method.returnType.asTypeName(),
- inTransaction = method.inTransaction,
+ returnTypeName = function.returnType.asTypeName(),
+ inTransaction = function.inTransaction,
scope = scope
)
@@ -637,16 +637,18 @@
}
// TODO(b/251459654): Handle @JvmOverloads in delegating functions with Kotlin codegen.
- private fun createDefaultImplMethodDelegate(method: KotlinDefaultMethodDelegate): XFunSpec {
+ private fun createDefaultImplFunctionDelegate(
+ function: KotlinDefaultFunctionDelegate
+ ): XFunSpec {
val scope = CodeGenScope(this)
- return overrideWithoutAnnotations(method.element, declaredDao)
+ return overrideWithoutAnnotations(function.element, declaredDao)
.apply {
- KotlinDefaultMethodDelegateBinder.executeAndReturn(
+ KotlinDefaultFunctionDelegateBinder.executeAndReturn(
daoName = dao.typeName,
daoImplName = dao.implTypeName,
- methodName = method.element.jvmName,
- returnType = method.element.returnType,
- parameterNames = method.element.parameters.map { it.name },
+ functionName = function.element.jvmName,
+ returnType = function.element.returnType,
+ parameterNames = function.element.parameters.map { it.name },
scope = scope
)
addCode(scope.generate())
@@ -654,17 +656,19 @@
.build()
}
- private fun createBoxedPrimitiveBridgeMethodDelegate(
- method: KotlinBoxedPrimitiveMethodDelegate
+ private fun createBoxedPrimitiveBridgeFunctionDelegate(
+ function: KotlinBoxedPrimitiveFunctionDelegate
): XFunSpec {
val scope = CodeGenScope(this)
- return overrideWithoutAnnotations(method.element, declaredDao)
+ return overrideWithoutAnnotations(function.element, declaredDao)
.apply {
- KotlinBoxedPrimitiveMethodDelegateBinder.execute(
- methodName = method.element.jvmName,
- returnType = method.element.returnType,
+ KotlinBoxedPrimitiveFunctionDelegateBinder.execute(
+ functionName = function.element.jvmName,
+ returnType = function.element.returnType,
parameters =
- method.concreteMethod.parameters.map { it.type.asTypeName() to it.name },
+ function.concreteFunction.parameters.map {
+ it.type.asTypeName() to it.name
+ },
scope = scope
)
addCode(scope.generate())
@@ -680,22 +684,22 @@
* Represents a query statement prepared in Dao implementation.
*
* @param fields This map holds all the member properties necessary for this query. The key is
- * the corresponding parameter name in the defining query method. The value is a pair from the
- * property declaration to definition.
- * @param functionImpl The body of the query method implementation.
+ * the corresponding parameter name in the defining query function. The value is a pair from
+ * the property declaration to definition.
+ * @param functionImpl The body of the query function implementation.
*/
data class PreparedStmtQuery(
val fields: Map<String, Pair<XPropertySpec, Any>>,
val functionImpl: XFunSpec
) {
companion object {
- // The key to be used in `fields` where the method requires a field that is not
+ // The key to be used in `fields` where the function requires a field that is not
// associated with any of its parameters
const val NO_PARAM_FIELD = "-"
}
}
- private class InsertMethodProperty(
+ private class InsertFunctionProperty(
val shortcutEntity: ShortcutEntity,
val onConflictText: String,
) :
@@ -713,18 +717,18 @@
class DeleteOrUpdateAdapterProperty(
val shortcutEntity: ShortcutEntity,
- val methodPrefix: String,
+ val functionPrefix: String,
val onConflictText: String,
) :
SharedPropertySpec(
- baseName = "${methodPrefix}AdapterOf${shortcutEntityFieldNamePart(shortcutEntity)}",
+ baseName = "${functionPrefix}AdapterOf${shortcutEntityFieldNamePart(shortcutEntity)}",
type = DELETE_OR_UPDATE_ADAPTER.parametrizedBy(shortcutEntity.dataClass.typeName)
) {
override fun prepare(writer: TypeWriter, builder: XPropertySpec.Builder) {}
override fun getUniqueKey(): String {
return "${shortcutEntity.dataClass.typeName}-${shortcutEntity.entityTypeName}" +
- "$methodPrefix$onConflictText"
+ "$functionPrefix$onConflictText"
}
}
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/writer/DatabaseWriter.kt b/room/room-compiler/src/main/kotlin/androidx/room/writer/DatabaseWriter.kt
index 7d0e36f..f66b224 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/writer/DatabaseWriter.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/writer/DatabaseWriter.kt
@@ -40,7 +40,7 @@
import androidx.room.ext.decapitalize
import androidx.room.ext.stripNonJava
import androidx.room.solver.CodeGenScope
-import androidx.room.vo.DaoMethod
+import androidx.room.vo.DaoFunction
import androidx.room.vo.Database
import java.util.Locale
import javax.lang.model.element.Modifier
@@ -112,7 +112,7 @@
KotlinCollectionMemberNames.MUTABLE_MAP_OF
)
}
- database.daoMethods.forEach {
+ database.daoFunctions.forEach {
addStatement(
"%L.put(%L, %T.%L())",
typeConvertersVar,
@@ -121,7 +121,7 @@
CodeLanguage.KOTLIN -> XCodeBlock.ofKotlinClassLiteral(it.dao.typeName)
},
it.dao.implTypeName,
- DaoWriter.GET_LIST_OF_TYPE_CONVERTERS_METHOD
+ DaoWriter.GET_LIST_OF_TYPE_CONVERTERS_FUNCTION
)
}
addStatement("return %L", typeConvertersVar)
@@ -351,7 +351,7 @@
private fun addDaoImpls(builder: XTypeSpec.Builder) {
val scope = CodeGenScope(this)
- database.daoMethods.forEach { method ->
+ database.daoFunctions.forEach { method ->
val name =
method.dao.typeName.simpleNames.first().decapitalize(Locale.US).stripNonJava()
val privateDaoProperty =
@@ -411,7 +411,7 @@
}
}
- private fun createDaoGetter(method: DaoMethod, daoProperty: XPropertySpec): XFunSpec {
+ private fun createDaoGetter(method: DaoFunction, daoProperty: XPropertySpec): XFunSpec {
val body =
XCodeBlock.builder().applyTo { language ->
// For Java we implement the memoization logic in the Dao getter, meanwhile for
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/writer/QueryWriter.kt b/room/room-compiler/src/main/kotlin/androidx/room/writer/QueryWriter.kt
index 0869212..f152389 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/writer/QueryWriter.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/writer/QueryWriter.kt
@@ -28,7 +28,7 @@
import androidx.room.parser.ParsedQuery
import androidx.room.parser.Section
import androidx.room.solver.CodeGenScope
-import androidx.room.vo.QueryMethod
+import androidx.room.vo.QueryFunction
import androidx.room.vo.QueryParameter
/** Writes the SQL query and arguments for a QueryMethod. */
@@ -39,8 +39,8 @@
) {
constructor(
- queryMethod: QueryMethod
- ) : this(queryMethod.parameters, queryMethod.sectionToParamMapping, queryMethod.query)
+ queryFunction: QueryFunction
+ ) : this(queryFunction.parameters, queryFunction.sectionToParamMapping, queryFunction.query)
fun prepareReadAndBind(
outSqlQueryName: String,
diff --git a/room/room-compiler/src/main/kotlin/androidx/room/writer/RelationCollectorFunctionWriter.kt b/room/room-compiler/src/main/kotlin/androidx/room/writer/RelationCollectorFunctionWriter.kt
index 4d18e8a..c668ed4 100644
--- a/room/room-compiler/src/main/kotlin/androidx/room/writer/RelationCollectorFunctionWriter.kt
+++ b/room/room-compiler/src/main/kotlin/androidx/room/writer/RelationCollectorFunctionWriter.kt
@@ -56,7 +56,7 @@
override fun getUniqueKey(): String {
val relation = collector.relation
- return "RelationCollectorMethodWriter" +
+ return "RelationCollectorFunctionWriter" +
"-${collector.mapTypeName}" +
"-${relation.entity.typeName.toString(CodeLanguage.JAVA)}" +
"-${relation.entityField.columnName}" +
@@ -207,7 +207,7 @@
private fun XCodeBlock.Builder.addRecursiveFetchCall(
scope: CodeGenScope,
- methodName: String,
+ functionName: String,
) {
val utilFunction =
RELATION_UTIL.let {
@@ -239,7 +239,7 @@
val recursiveCall =
XCodeBlock.of(
"%L(%L, %L)",
- methodName,
+ functionName,
PARAM_CONNECTION_VARIABLE,
paramName
)
diff --git a/room/room-compiler/src/test/kotlin/androidx/room/processor/BaseDaoTest.kt b/room/room-compiler/src/test/kotlin/androidx/room/processor/BaseDaoTest.kt
index a8095c4..48fe74f 100644
--- a/room/room-compiler/src/test/kotlin/androidx/room/processor/BaseDaoTest.kt
+++ b/room/room-compiler/src/test/kotlin/androidx/room/processor/BaseDaoTest.kt
@@ -26,7 +26,7 @@
void insertMe(T t);
"""
) { dao ->
- assertThat(dao.insertMethods.size, `is`(1))
+ assertThat(dao.insertFunctions.size, `is`(1))
}
}
@@ -38,7 +38,7 @@
void insertMe(T[] t);
"""
) { dao ->
- assertThat(dao.insertMethods.size, `is`(1))
+ assertThat(dao.insertFunctions.size, `is`(1))
}
}
@@ -50,7 +50,7 @@
void insertMe(T... t);
"""
) { dao ->
- assertThat(dao.insertMethods.size, `is`(1))
+ assertThat(dao.insertFunctions.size, `is`(1))
}
}
@@ -62,7 +62,7 @@
void insertMe(List<T> t);
"""
) { dao ->
- assertThat(dao.insertMethods.size, `is`(1))
+ assertThat(dao.insertFunctions.size, `is`(1))
}
}
@@ -74,7 +74,7 @@
void deleteMe(T t);
"""
) { dao ->
- assertThat(dao.deleteMethods.size, `is`(1))
+ assertThat(dao.deleteFunctions.size, `is`(1))
}
}
@@ -86,7 +86,7 @@
void deleteMe(T[] t);
"""
) { dao ->
- assertThat(dao.deleteMethods.size, `is`(1))
+ assertThat(dao.deleteFunctions.size, `is`(1))
}
}
@@ -98,7 +98,7 @@
void deleteMe(T... t);
"""
) { dao ->
- assertThat(dao.deleteMethods.size, `is`(1))
+ assertThat(dao.deleteFunctions.size, `is`(1))
}
}
@@ -110,7 +110,7 @@
void deleteMe(List<T> t);
"""
) { dao ->
- assertThat(dao.deleteMethods.size, `is`(1))
+ assertThat(dao.deleteFunctions.size, `is`(1))
}
}
@@ -122,7 +122,7 @@
void updateMe(T t);
"""
) { dao ->
- assertThat(dao.updateMethods.size, `is`(1))
+ assertThat(dao.updateFunctions.size, `is`(1))
}
}
@@ -134,7 +134,7 @@
void updateMe(T[] t);
"""
) { dao ->
- assertThat(dao.updateMethods.size, `is`(1))
+ assertThat(dao.updateFunctions.size, `is`(1))
}
}
@@ -146,7 +146,7 @@
void updateMe(T... t);
"""
) { dao ->
- assertThat(dao.updateMethods.size, `is`(1))
+ assertThat(dao.updateFunctions.size, `is`(1))
}
}
@@ -158,7 +158,7 @@
void updateMe(List<T> t);
"""
) { dao ->
- assertThat(dao.updateMethods.size, `is`(1))
+ assertThat(dao.updateFunctions.size, `is`(1))
}
}
diff --git a/room/room-compiler/src/test/kotlin/androidx/room/processor/CustomConverterProcessorTest.kt b/room/room-compiler/src/test/kotlin/androidx/room/processor/CustomConverterProcessorTest.kt
index f4ff34f..5027258 100644
--- a/room/room-compiler/src/test/kotlin/androidx/room/processor/CustomConverterProcessorTest.kt
+++ b/room/room-compiler/src/test/kotlin/androidx/room/processor/CustomConverterProcessorTest.kt
@@ -286,7 +286,7 @@
.isEqualTo(XTypeName.BOXED_SHORT.copy(nullable = true))
assertThat(converter?.toTypeName).isEqualTo(XTypeName.BOXED_CHAR.copy(nullable = true))
invocation.assertCompilationResult {
- hasErrorContaining("Multiple methods define the same conversion")
+ hasErrorContaining("Multiple functions define the same conversion")
}
}
}
@@ -321,7 +321,7 @@
if (invocation.isKsp) {
// no error
} else {
- hasErrorContaining("Multiple methods define the same")
+ hasErrorContaining("Multiple functions define the same")
}
}
}
diff --git a/room/room-compiler/src/test/kotlin/androidx/room/processor/DaoProcessorTest.kt b/room/room-compiler/src/test/kotlin/androidx/room/processor/DaoProcessorTest.kt
index 6ebead5..c8303f2 100644
--- a/room/room-compiler/src/test/kotlin/androidx/room/processor/DaoProcessorTest.kt
+++ b/room/room-compiler/src/test/kotlin/androidx/room/processor/DaoProcessorTest.kt
@@ -23,13 +23,13 @@
import androidx.room.compiler.processing.util.XTestInvocation
import androidx.room.compiler.processing.util.compileFiles
import androidx.room.ext.RoomTypeNames.ROOM_DB
-import androidx.room.processor.ProcessorErrors.nullableCollectionOrArrayReturnTypeInDaoMethod
-import androidx.room.processor.ProcessorErrors.nullableComponentInDaoMethodReturnType
+import androidx.room.processor.ProcessorErrors.nullableCollectionOrArrayReturnTypeInDaoFunction
+import androidx.room.processor.ProcessorErrors.nullableComponentInDaoFunctionReturnType
import androidx.room.runKspTestWithK1
import androidx.room.runProcessorTestWithK1
import androidx.room.testing.context
import androidx.room.vo.Dao
-import androidx.room.vo.ReadQueryMethod
+import androidx.room.vo.ReadQueryFunction
import androidx.room.vo.Warning
import createVerifierFromEntitiesAndViews
import java.io.File
@@ -92,7 +92,7 @@
"""
) { _, invocation ->
invocation.assertCompilationResult {
- hasErrorContaining(ProcessorErrors.INVALID_ANNOTATION_COUNT_IN_DAO_METHOD)
+ hasErrorContaining(ProcessorErrors.INVALID_ANNOTATION_COUNT_IN_DAO_FUNCTION)
}
}
}
@@ -116,10 +116,10 @@
) { _, invocation ->
invocation.assertCompilationResult {
hasRawOutputContaining(
- ProcessorErrors.INVALID_ANNOTATION_COUNT_IN_DAO_METHOD +
+ ProcessorErrors.INVALID_ANNOTATION_COUNT_IN_DAO_FUNCTION +
" - test.library.MissingAnnotationsBaseDao.getFoo()"
)
- hasErrorContaining(ProcessorErrors.INVALID_ANNOTATION_COUNT_IN_DAO_METHOD)
+ hasErrorContaining(ProcessorErrors.INVALID_ANNOTATION_COUNT_IN_DAO_FUNCTION)
}
}
}
@@ -136,7 +136,8 @@
"""
) { _, invocation ->
invocation.assertCompilationResult {
- hasErrorContaining(ProcessorErrors.INVALID_ANNOTATION_COUNT_IN_DAO_METHOD).onLine(8)
+ hasErrorContaining(ProcessorErrors.INVALID_ANNOTATION_COUNT_IN_DAO_FUNCTION)
+ .onLine(8)
}
}
}
@@ -151,8 +152,8 @@
}
"""
) { dao, _ ->
- assertThat(dao.queryMethods.size, `is`(1))
- val method = dao.queryMethods.first()
+ assertThat(dao.queryFunctions.size, `is`(1))
+ val method = dao.queryFunctions.first()
assertThat(method.element.jvmName, `is`("getIds"))
}
}
@@ -167,8 +168,8 @@
}
"""
) { dao, _ ->
- assertThat(dao.queryMethods.size, `is`(1))
- val method = dao.queryMethods.first()
+ assertThat(dao.queryFunctions.size, `is`(1))
+ val method = dao.queryFunctions.first()
assertThat(method.element.jvmName, `is`("getIds"))
}
}
@@ -185,11 +186,11 @@
}
"""
) { dao, _ ->
- assertThat(dao.queryMethods.size, `is`(1))
- val method = dao.queryMethods.first()
+ assertThat(dao.queryFunctions.size, `is`(1))
+ val method = dao.queryFunctions.first()
assertThat(method.element.jvmName, `is`("getIds"))
- assertThat(dao.insertMethods.size, `is`(1))
- val insertMethod = dao.insertMethods.first()
+ assertThat(dao.insertFunctions.size, `is`(1))
+ val insertMethod = dao.insertFunctions.first()
assertThat(insertMethod.element.jvmName, `is`("insert"))
}
}
@@ -204,8 +205,8 @@
}
"""
) { dao, _ ->
- assertThat(dao.queryMethods.size, `is`(1))
- val method = dao.queryMethods.first()
+ assertThat(dao.queryFunctions.size, `is`(1))
+ val method = dao.queryFunctions.first()
assertThat(method.element.jvmName, `is`("getIds"))
}
}
@@ -229,9 +230,9 @@
`is`(setOf(Warning.ALL, Warning.QUERY_MISMATCH))
)
- dao.queryMethods.forEach {
+ dao.queryFunctions.forEach {
assertThat(
- QueryMethodProcessor(
+ QueryFunctionProcessor(
baseContext = daoProcessor.context,
containing = dao.element.type,
executableElement = it.element,
@@ -297,9 +298,9 @@
`is`(setOf(Warning.QUERY_MISMATCH))
)
- dao.queryMethods.forEach {
+ dao.queryFunctions.forEach {
assertThat(
- QueryMethodProcessor(
+ QueryFunctionProcessor(
baseContext = daoProcessor.context,
containing = dao.element.type,
executableElement = it.element,
@@ -332,9 +333,9 @@
}
"""
) { dao, invocation ->
- assertThat(dao.queryMethods.size, `is`(1))
+ assertThat(dao.queryFunctions.size, `is`(1))
assertThat(
- dao.queryMethods.filterIsInstance<ReadQueryMethod>().first().inTransaction,
+ dao.queryFunctions.filterIsInstance<ReadQueryFunction>().first().inTransaction,
`is`(false)
)
invocation.assertCompilationResult {
@@ -362,9 +363,9 @@
}
"""
) { dao, invocation ->
- assertThat(dao.queryMethods.size, `is`(1))
+ assertThat(dao.queryFunctions.size, `is`(1))
assertThat(
- dao.queryMethods.filterIsInstance<ReadQueryMethod>().first().inTransaction,
+ dao.queryFunctions.filterIsInstance<ReadQueryFunction>().first().inTransaction,
`is`(false)
)
invocation.assertCompilationResult { hasNoWarnings() }
@@ -391,9 +392,9 @@
"""
) { dao, invocation ->
// test sanity
- assertThat(dao.queryMethods.size, `is`(1))
+ assertThat(dao.queryFunctions.size, `is`(1))
assertThat(
- dao.queryMethods.filterIsInstance<ReadQueryMethod>().first().inTransaction,
+ dao.queryFunctions.filterIsInstance<ReadQueryFunction>().first().inTransaction,
`is`(true)
)
invocation.assertCompilationResult { hasNoWarnings() }
@@ -410,8 +411,8 @@
}
"""
) { dao, _ ->
- assertThat(dao.queryMethods.size, `is`(1))
- val method = dao.queryMethods.first()
+ assertThat(dao.queryFunctions.size, `is`(1))
+ val method = dao.queryFunctions.first()
assertThat(method.element.jvmName, `is`("deleteAllIds"))
}
}
@@ -426,8 +427,8 @@
}
"""
) { dao, invocation ->
- assertThat(dao.queryMethods.size, `is`(1))
- val method = dao.queryMethods.first()
+ assertThat(dao.queryFunctions.size, `is`(1))
+ val method = dao.queryFunctions.first()
assertThat(method.element.jvmName, `is`("getAllIds"))
invocation.assertCompilationResult {
hasErrorContaining(ProcessorErrors.cannotFindQueryResultAdapter("void"))
@@ -463,7 +464,7 @@
)
.process()
invocation.assertCompilationResult {
- hasWarningContaining(ProcessorErrors.JVM_NAME_ON_OVERRIDDEN_METHOD)
+ hasWarningContaining(ProcessorErrors.JVM_NAME_ON_OVERRIDDEN_FUNCTION)
}
}
}
@@ -656,55 +657,55 @@
.process()
invocation.assertCompilationResult {
hasWarningContaining(
- nullableCollectionOrArrayReturnTypeInDaoMethod(
+ nullableCollectionOrArrayReturnTypeInDaoFunction(
"kotlin.collections.List<MyEntity>?",
"Collection"
)
)
hasWarningContaining(
- nullableCollectionOrArrayReturnTypeInDaoMethod(
+ nullableCollectionOrArrayReturnTypeInDaoFunction(
"com.google.common.collect.ImmutableList<MyEntity>?",
"Collection"
)
)
hasWarningContaining(
- nullableCollectionOrArrayReturnTypeInDaoMethod(
+ nullableCollectionOrArrayReturnTypeInDaoFunction(
"kotlin.Array<MyEntity>?",
"Array"
)
)
hasWarningContaining(
- nullableCollectionOrArrayReturnTypeInDaoMethod(
+ nullableCollectionOrArrayReturnTypeInDaoFunction(
"java.util.Optional<MyEntity>?",
"Optional"
)
)
hasWarningContaining(
- nullableCollectionOrArrayReturnTypeInDaoMethod(
+ nullableCollectionOrArrayReturnTypeInDaoFunction(
"com.google.common.base.Optional<MyEntity>?",
"Optional"
)
)
hasWarningContaining(
- nullableCollectionOrArrayReturnTypeInDaoMethod(
+ nullableCollectionOrArrayReturnTypeInDaoFunction(
"kotlin.collections.Map<MyEntity, MyOtherEntity>?",
"Collection"
)
)
hasWarningContaining(
- nullableCollectionOrArrayReturnTypeInDaoMethod(
+ nullableCollectionOrArrayReturnTypeInDaoFunction(
"com.google.common.collect.ImmutableMap<MyEntity, MyOtherEntity>?",
"Collection"
)
)
hasWarningContaining(
- nullableCollectionOrArrayReturnTypeInDaoMethod(
+ nullableCollectionOrArrayReturnTypeInDaoFunction(
"com.google.common.collect.ImmutableSetMultimap<MyEntity, MyOtherEntity>?",
"Collection"
)
)
hasWarningContaining(
- nullableCollectionOrArrayReturnTypeInDaoMethod(
+ nullableCollectionOrArrayReturnTypeInDaoFunction(
"com.google.common.collect.ImmutableListMultimap<MyEntity, MyOtherEntity>?",
"Collection"
)
@@ -782,31 +783,31 @@
.process()
invocation.assertCompilationResult {
hasWarningContaining(
- nullableComponentInDaoMethodReturnType("kotlin.collections.List<MyEntity?>")
+ nullableComponentInDaoFunctionReturnType("kotlin.collections.List<MyEntity?>")
)
hasWarningContaining(
- nullableComponentInDaoMethodReturnType(
+ nullableComponentInDaoFunctionReturnType(
"com.google.common.collect.ImmutableList<MyEntity?>"
)
)
hasWarningContaining(
- nullableComponentInDaoMethodReturnType("kotlin.Array<MyEntity?>")
+ nullableComponentInDaoFunctionReturnType("kotlin.Array<MyEntity?>")
)
hasWarningContaining(
- nullableComponentInDaoMethodReturnType("java.util.Optional<MyEntity?>")
+ nullableComponentInDaoFunctionReturnType("java.util.Optional<MyEntity?>")
)
hasWarningContaining(
- nullableComponentInDaoMethodReturnType(
+ nullableComponentInDaoFunctionReturnType(
"com.google.common.base.Optional<MyEntity?>"
)
)
hasWarningContaining(
- nullableComponentInDaoMethodReturnType(
+ nullableComponentInDaoFunctionReturnType(
"kotlin.collections.Map<MyEntity?, MyOtherEntity>"
)
)
hasWarningContaining(
- nullableComponentInDaoMethodReturnType(
+ nullableComponentInDaoFunctionReturnType(
"com.google.common.collect.ImmutableMap<MyEntity?, MyOtherEntity>"
)
)
@@ -814,17 +815,17 @@
// convert the map to a mutable one and re-run the `findQueryResultAdapter`
// algorithm
hasWarningContaining(
- nullableComponentInDaoMethodReturnType(
+ nullableComponentInDaoFunctionReturnType(
"kotlin.collections.MutableMap<MyEntity?, MyOtherEntity>"
)
)
hasWarningContaining(
- nullableComponentInDaoMethodReturnType(
+ nullableComponentInDaoFunctionReturnType(
"com.google.common.collect.ImmutableSetMultimap<MyEntity?, MyOtherEntity>"
)
)
hasWarningContaining(
- nullableComponentInDaoMethodReturnType(
+ nullableComponentInDaoFunctionReturnType(
"com.google.common.collect.ImmutableListMultimap<MyEntity?, MyOtherEntity>"
)
)
diff --git a/room/room-compiler/src/test/kotlin/androidx/room/processor/DataClassProcessorTargetMethodTest.kt b/room/room-compiler/src/test/kotlin/androidx/room/processor/DataClassProcessorTargetFunctionTest.kt
similarity index 94%
rename from room/room-compiler/src/test/kotlin/androidx/room/processor/DataClassProcessorTargetMethodTest.kt
rename to room/room-compiler/src/test/kotlin/androidx/room/processor/DataClassProcessorTargetFunctionTest.kt
index 5fdb87b..3a1f875b 100644
--- a/room/room-compiler/src/test/kotlin/androidx/room/processor/DataClassProcessorTargetMethodTest.kt
+++ b/room/room-compiler/src/test/kotlin/androidx/room/processor/DataClassProcessorTargetFunctionTest.kt
@@ -26,7 +26,7 @@
import org.junit.runners.JUnit4
@RunWith(JUnit4::class)
-class DataClassProcessorTargetMethodTest {
+class DataClassProcessorTargetFunctionTest {
companion object {
val MY_DATA_CLASS = XClassName.get("foo.bar", "MyDataClass")
@@ -56,7 +56,7 @@
}
@Test
- fun invalidAnnotationInMethod() {
+ fun invalidAnnotationInFunction() {
val source =
Source.java(
MY_DATA_CLASS.canonicalName,
@@ -67,7 +67,7 @@
class MyDataClass {
@PrimaryKey
- void someRandomMethod() { }
+ void someRandomFunction() { }
}
"""
)
@@ -84,7 +84,7 @@
}
@Test
- fun invalidAnnotationInStaticMethod() {
+ fun invalidAnnotationInStaticFunction() {
val source =
Source.java(
MY_DATA_CLASS.canonicalName,
@@ -95,7 +95,7 @@
class MyDataClass {
@PrimaryKey
- static void someRandomMethod() { }
+ static void someRandomFunction() { }
}
"""
)
@@ -112,7 +112,7 @@
}
@Test
- fun invalidAnnotationInAbstractMethod() {
+ fun invalidAnnotationInAbstractFunction() {
val source =
Source.java(
MY_DATA_CLASS.canonicalName,
@@ -123,7 +123,7 @@
abstract class MyDataClass {
@PrimaryKey
- abstract void someRandomMethod();
+ abstract void someRandomFunction();
}
"""
)
@@ -140,14 +140,14 @@
}
@Test
- fun invalidAnnotationInAutoValueMethod() {
+ fun invalidAnnotationInAutoValueFunction() {
singleRun(
"""
@AutoValue.CopyAnnotations
@PrimaryKey
abstract long getId();
@ColumnInfo(name = "column_name")
- void someRandomMethod() { }
+ void someRandomFunction() { }
static MyDataClass create(long id) { return new AutoValue_MyDataClass(id); }
""",
"""
@@ -170,7 +170,7 @@
}
@Test
- fun invalidAnnotationInAutoValueParentMethod() {
+ fun invalidAnnotationInAutoValueParentFunction() {
val parent =
"""
package foo.bar;
@@ -181,7 +181,7 @@
@ColumnInfo(name = "column_name")
abstract String getValue();
@ColumnInfo(name = "another_column_name")
- void someRandomMethod() { }
+ void someRandomFunction() { }
}
"""
singleRunFullClass(
@@ -264,7 +264,7 @@
}
@Test
- fun validAnnotationInAutoValueAbstractMethod() {
+ fun validAnnotationInAutoValueAbstractFunction() {
singleRun(
"""
@AutoValue.CopyAnnotations
@@ -283,7 +283,7 @@
}
@Test
- fun validAnnotationInAutoValueParentMethod() {
+ fun validAnnotationInAutoValueParentFunction() {
val parent =
"""
package foo.bar;
@@ -328,7 +328,7 @@
}
@Test
- fun validAnnotationInAutoValueImplementedInterfaceMethod() {
+ fun validAnnotationInAutoValueImplementedInterfaceFunction() {
val parent =
"""
package foo.bar;
@@ -373,7 +373,7 @@
}
@Test
- fun validEmbeddedAnnotationInAutoValueAbstractMethod() {
+ fun validEmbeddedAnnotationInAutoValueAbstractFunction() {
val embeddedDataClass =
"""
package foo.bar;
@@ -415,7 +415,7 @@
}
@Test
- fun validRelationAnnotationInAutoValueAbstractMethod() {
+ fun validRelationAnnotationInAutoValueAbstractFunction() {
val embeddedDataClass =
"""
package foo.bar;
@@ -520,7 +520,7 @@
}
/**
- * KSP and JavaAP name methods different. To feel more native, we use the name based on the
+ * KSP and JavaAP name functions differently. To feel more native, we use the name based on the
* processor. It only matters for the test assertion
*/
private val XTestInvocation.functionKindName: String
diff --git a/room/room-compiler/src/test/kotlin/androidx/room/processor/DatabaseProcessorTest.kt b/room/room-compiler/src/test/kotlin/androidx/room/processor/DatabaseProcessorTest.kt
index bc483ad..be66f51a 100644
--- a/room/room-compiler/src/test/kotlin/androidx/room/processor/DatabaseProcessorTest.kt
+++ b/room/room-compiler/src/test/kotlin/androidx/room/processor/DatabaseProcessorTest.kt
@@ -40,7 +40,7 @@
import androidx.room.testing.context
import androidx.room.vo.Database
import androidx.room.vo.DatabaseView
-import androidx.room.vo.ReadQueryMethod
+import androidx.room.vo.ReadQueryFunction
import androidx.room.vo.Warning
import com.google.auto.service.processor.AutoServiceProcessor
import com.google.testing.junit.testparameterinjector.TestParameter
@@ -247,7 +247,7 @@
USER,
USER_DAO
) { db, _ ->
- assertThat(db.daoMethods.size, `is`(1))
+ assertThat(db.daoFunctions.size, `is`(1))
assertThat(db.entities.size, `is`(1))
}
}
@@ -267,9 +267,12 @@
BOOK,
BOOK_DAO
) { db, _ ->
- assertThat(db.daoMethods.size, `is`(2))
+ assertThat(db.daoFunctions.size, `is`(2))
assertThat(db.entities.size, `is`(2))
- assertThat(db.daoMethods.map { it.element.jvmName }, `is`(listOf("userDao", "bookDao")))
+ assertThat(
+ db.daoFunctions.map { it.element.jvmName },
+ `is`(listOf("userDao", "bookDao"))
+ )
assertThat(
db.entities.map { it.type.asTypeName().toString(CodeLanguage.JAVA) },
`is`(listOf("foo.bar.User", "foo.bar.Book"))
@@ -536,7 +539,7 @@
USER_DAO
) { _, invocation ->
invocation.assertCompilationResult {
- hasErrorContaining(ProcessorErrors.DAO_METHOD_CONFLICTS_WITH_OTHERS)
+ hasErrorContaining(ProcessorErrors.DAO_FUNCTION_CONFLICTS_WITH_OTHERS)
hasErrorContaining(
ProcessorErrors.duplicateDao("foo.bar.UserDao", listOf("userDao", "userDao2"))
)
@@ -924,11 +927,11 @@
USER,
USER_DAO
) { db, _ ->
- val userDao = db.daoMethods.first().dao
- val insertionMethod = userDao.insertMethods.find { it.element.jvmName == "insert" }
+ val userDao = db.daoFunctions.first().dao
+ val insertionMethod = userDao.insertFunctions.find { it.element.jvmName == "insert" }
assertThat(insertionMethod, notNullValue())
val loadOne =
- userDao.queryMethods.filterIsInstance<ReadQueryMethod>().find {
+ userDao.queryFunctions.filterIsInstance<ReadQueryFunction>().find {
it.element.jvmName == "loadOne"
}
assertThat(loadOne, notNullValue())
@@ -941,7 +944,7 @@
)
val withConverter =
- userDao.queryMethods.filterIsInstance<ReadQueryMethod>().find {
+ userDao.queryFunctions.filterIsInstance<ReadQueryFunction>().find {
it.element.jvmName == "loadWithConverter"
}
assertThat(withConverter, notNullValue())
@@ -970,9 +973,9 @@
USER,
USER_DAO
) { db, _ ->
- val userDao = db.daoMethods.first().dao
+ val userDao = db.daoFunctions.first().dao
val loadOne =
- userDao.queryMethods.filterIsInstance<ReadQueryMethod>().find {
+ userDao.queryFunctions.filterIsInstance<ReadQueryFunction>().find {
it.element.jvmName == "loadOneDataClass"
}
assertThat(loadOne, notNullValue())
@@ -981,7 +984,7 @@
val adapterDataClass = (adapter as DataClassRowAdapter).dataClass
val loadAll =
- userDao.queryMethods.filterIsInstance<ReadQueryMethod>().find {
+ userDao.queryFunctions.filterIsInstance<ReadQueryFunction>().find {
it.element.jvmName == "loadAllDataClasses"
}
assertThat(loadAll, notNullValue())
@@ -992,7 +995,7 @@
assertThat(adapterDataClass, sameInstance(loadAllDataClass))
val withConverter =
- userDao.queryMethods.filterIsInstance<ReadQueryMethod>().find {
+ userDao.queryFunctions.filterIsInstance<ReadQueryFunction>().find {
it.element.jvmName == "loadDataClassWithConverter"
}
assertThat(withConverter, notNullValue())
@@ -1261,9 +1264,9 @@
val element = invocation.processingEnv.requireTypeElement("foo.bar.MyDb")
val result =
DatabaseProcessor(baseContext = invocation.context, element = element).process()
- assertThat(result.daoMethods).hasSize(0)
+ assertThat(result.daoFunctions).hasSize(0)
invocation.assertCompilationResult {
- hasErrorContaining(ProcessorErrors.DATABASE_INVALID_DAO_METHOD_RETURN_TYPE)
+ hasErrorContaining(ProcessorErrors.DATABASE_INVALID_DAO_FUNCTION_RETURN_TYPE)
}
}
}
@@ -1598,7 +1601,7 @@
val element = invocation.processingEnv.requireTypeElement("foo.bar.MyDb")
DatabaseProcessor(baseContext = invocation.context, element = element).process()
invocation.assertCompilationResult {
- hasWarningContaining(ProcessorErrors.JVM_NAME_ON_OVERRIDDEN_METHOD)
+ hasWarningContaining(ProcessorErrors.JVM_NAME_ON_OVERRIDDEN_FUNCTION)
}
}
}
diff --git a/room/room-compiler/src/test/kotlin/androidx/room/processor/DeleteMethodProcessorTest.kt b/room/room-compiler/src/test/kotlin/androidx/room/processor/DeleteFunctionProcessorTest.kt
similarity index 83%
rename from room/room-compiler/src/test/kotlin/androidx/room/processor/DeleteMethodProcessorTest.kt
rename to room/room-compiler/src/test/kotlin/androidx/room/processor/DeleteFunctionProcessorTest.kt
index 0a78781..687a758 100644
--- a/room/room-compiler/src/test/kotlin/androidx/room/processor/DeleteMethodProcessorTest.kt
+++ b/room/room-compiler/src/test/kotlin/androidx/room/processor/DeleteFunctionProcessorTest.kt
@@ -20,14 +20,14 @@
import androidx.room.compiler.processing.XType
import androidx.room.processor.ProcessorErrors.CANNOT_FIND_DELETE_RESULT_ADAPTER
import androidx.room.processor.ProcessorErrors.DELETE_MISSING_PARAMS
-import androidx.room.vo.DeleteMethod
+import androidx.room.vo.DeleteFunction
import org.junit.runner.RunWith
import org.junit.runners.JUnit4
@Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN")
@RunWith(JUnit4::class)
-class DeleteMethodProcessorTest :
- DeleteOrUpdateShortcutMethodProcessorTest<DeleteMethod>(Delete::class) {
+class DeleteFunctionProcessorTest :
+ DeleteOrUpdateShortcutFunctionProcessorTest<DeleteFunction>(Delete::class) {
override fun invalidReturnTypeError(): String = CANNOT_FIND_DELETE_RESULT_ADAPTER
override fun noParamsError(): String = DELETE_MISSING_PARAMS
@@ -36,7 +36,7 @@
baseContext: Context,
containing: XType,
executableElement: XMethodElement
- ): DeleteMethod {
- return DeleteMethodProcessor(baseContext, containing, executableElement).process()
+ ): DeleteFunction {
+ return DeleteFunctionProcessor(baseContext, containing, executableElement).process()
}
}
diff --git a/room/room-compiler/src/test/kotlin/androidx/room/processor/DeleteOrUpdateShortcutMethodProcessorTest.kt b/room/room-compiler/src/test/kotlin/androidx/room/processor/DeleteOrUpdateShortcutFunctionProcessorTest.kt
similarity index 95%
rename from room/room-compiler/src/test/kotlin/androidx/room/processor/DeleteOrUpdateShortcutMethodProcessorTest.kt
rename to room/room-compiler/src/test/kotlin/androidx/room/processor/DeleteOrUpdateShortcutFunctionProcessorTest.kt
index 8c900a7..2fd3542 100644
--- a/room/room-compiler/src/test/kotlin/androidx/room/processor/DeleteOrUpdateShortcutMethodProcessorTest.kt
+++ b/room/room-compiler/src/test/kotlin/androidx/room/processor/DeleteOrUpdateShortcutFunctionProcessorTest.kt
@@ -37,12 +37,12 @@
import androidx.room.ext.RxJava3TypeNames
import androidx.room.runProcessorTestWithK1
import androidx.room.testing.context
-import androidx.room.vo.DeleteOrUpdateShortcutMethod
+import androidx.room.vo.DeleteOrUpdateShortcutFunction
import kotlin.reflect.KClass
import org.junit.Test
-/** Base test class for shortcut methods. */
-abstract class DeleteOrUpdateShortcutMethodProcessorTest<out T : DeleteOrUpdateShortcutMethod>(
+/** Base test class for shortcut functions. */
+abstract class DeleteOrUpdateShortcutFunctionProcessorTest<out T : DeleteOrUpdateShortcutFunction>(
val annotation: KClass<out Annotation>
) {
companion object {
@@ -113,14 +113,14 @@
@Test
fun singleNullableParamError() {
- singleShortcutMethodKotlin(
+ singleShortcutFunction(
"""
@${annotation.java.canonicalName}
abstract fun foo(user: User?)
"""
) { _, invocation ->
invocation.assertCompilationResult {
- hasErrorContaining(ProcessorErrors.nullableParamInShortcutMethod("foo.bar.User"))
+ hasErrorContaining(ProcessorErrors.nullableParamInShortcutFunction("foo.bar.User"))
}
}
}
@@ -169,14 +169,14 @@
@Test
fun twoNullableParamError() {
- singleShortcutMethodKotlin(
+ singleShortcutFunction(
"""
@${annotation.java.canonicalName}
abstract fun foo(user1: User?, user2: User?)
"""
) { _, invocation ->
invocation.assertCompilationResult {
- hasErrorContaining(ProcessorErrors.nullableParamInShortcutMethod("foo.bar.User"))
+ hasErrorContaining(ProcessorErrors.nullableParamInShortcutFunction("foo.bar.User"))
hasErrorCount(2)
}
}
@@ -224,7 +224,7 @@
@Test
fun nullableListParamError() {
- singleShortcutMethodKotlin(
+ singleShortcutFunction(
"""
@${annotation.java.canonicalName}
abstract fun foo(users: List<User?>)
@@ -232,7 +232,7 @@
) { _, invocation ->
invocation.assertCompilationResult {
hasErrorContaining(
- ProcessorErrors.nullableParamInShortcutMethod(
+ ProcessorErrors.nullableParamInShortcutFunction(
"java.util.List<? extends foo.bar.User>"
)
)
@@ -264,14 +264,16 @@
@Test
fun nullableArrayParamError() {
- singleShortcutMethodKotlin(
+ singleShortcutFunction(
"""
@${annotation.java.canonicalName}
abstract fun foo(users: Array<User?>)
"""
) { _, invocation ->
invocation.assertCompilationResult {
- hasErrorContaining(ProcessorErrors.nullableParamInShortcutMethod("foo.bar.User[]"))
+ hasErrorContaining(
+ ProcessorErrors.nullableParamInShortcutFunction("foo.bar.User[]")
+ )
}
}
}
@@ -302,7 +304,7 @@
@Test
fun nullableSetParamError() {
- singleShortcutMethodKotlin(
+ singleShortcutFunction(
"""
@${annotation.java.canonicalName}
abstract fun foo(users: Set<User?>)
@@ -310,7 +312,7 @@
) { _, invocation ->
invocation.assertCompilationResult {
hasErrorContaining(
- ProcessorErrors.nullableParamInShortcutMethod(
+ ProcessorErrors.nullableParamInShortcutFunction(
"java.util.Set<? extends foo.bar.User>"
)
)
@@ -370,7 +372,7 @@
@Test
fun nullableCustomCollectionParamError() {
- singleShortcutMethodKotlin(
+ singleShortcutFunction(
"""
class MyList<Irrelevant, Item> : ArrayList<Item> {}
@${annotation.java.canonicalName}
@@ -379,7 +381,7 @@
) { _, invocation ->
invocation.assertCompilationResult {
hasErrorContaining(
- ProcessorErrors.nullableParamInShortcutMethod(
+ ProcessorErrors.nullableParamInShortcutFunction(
"foo.bar.MyClass.MyList<java.lang.String, foo.bar.User>"
)
)
@@ -428,15 +430,15 @@
@Test
fun twoNullableDifferentParamError() {
- singleShortcutMethodKotlin(
+ singleShortcutFunction(
"""
@${annotation.java.canonicalName}
abstract fun foo(user1: User?, book1: Book?)
"""
) { _, invocation ->
invocation.assertCompilationResult {
- hasErrorContaining(ProcessorErrors.nullableParamInShortcutMethod("foo.bar.User"))
- hasErrorContaining(ProcessorErrors.nullableParamInShortcutMethod("foo.bar.Book"))
+ hasErrorContaining(ProcessorErrors.nullableParamInShortcutFunction("foo.bar.User"))
+ hasErrorContaining(ProcessorErrors.nullableParamInShortcutFunction("foo.bar.Book"))
hasErrorCount(2)
}
}
@@ -492,7 +494,7 @@
"${KotlinTypeNames.FLOW.canonicalName}<Int>"
)
.forEach { type ->
- singleShortcutMethodKotlin(
+ singleShortcutFunction(
"""
@${annotation.java.canonicalName}
abstract suspend fun foo(user: User): $type
@@ -703,7 +705,7 @@
""",
) { _, invocation ->
invocation.assertCompilationResult {
- hasErrorContaining(ProcessorErrors.shortcutMethodArgumentMustBeAClass("long"))
+ hasErrorContaining(ProcessorErrors.shortcutFunctionArgumentMustBeAClass("long"))
}
}
}
@@ -735,7 +737,7 @@
@Test
fun nonNullVoidGuava() {
- singleShortcutMethodKotlin(
+ singleShortcutFunction(
"""
@${annotation.java.canonicalName}
abstract fun foo(user: User): ListenableFuture<Void>
@@ -799,7 +801,7 @@
}
}
- protected fun singleShortcutMethodKotlin(
+ protected fun singleShortcutFunction(
vararg input: String,
additionalSources: List<Source> = emptyList(),
handler: (T, XTestInvocation) -> Unit
@@ -834,7 +836,7 @@
sources = commonSources + additionalSources + inputSource,
options = mapOf(Context.BooleanProcessorOptions.GENERATE_KOTLIN.argName to "false"),
) { invocation ->
- val (owner, methods) =
+ val (owner, functions) =
invocation.roundEnv
.getElementsAnnotatedWith(Dao::class.qualifiedName!!)
.filterIsInstance<XTypeElement>()
@@ -850,7 +852,7 @@
process(
baseContext = invocation.context,
containing = owner.type,
- executableElement = methods.first()
+ executableElement = functions.first()
)
handler(processed, invocation)
}
diff --git a/room/room-compiler/src/test/kotlin/androidx/room/processor/InsertMethodProcessorTest.kt b/room/room-compiler/src/test/kotlin/androidx/room/processor/InsertFunctionProcessorTest.kt
similarity index 92%
rename from room/room-compiler/src/test/kotlin/androidx/room/processor/InsertMethodProcessorTest.kt
rename to room/room-compiler/src/test/kotlin/androidx/room/processor/InsertFunctionProcessorTest.kt
index 8aba5ee..f44f14b 100644
--- a/room/room-compiler/src/test/kotlin/androidx/room/processor/InsertMethodProcessorTest.kt
+++ b/room/room-compiler/src/test/kotlin/androidx/room/processor/InsertFunctionProcessorTest.kt
@@ -25,15 +25,15 @@
import androidx.room.processor.ProcessorErrors.INSERT_DOES_NOT_HAVE_ANY_PARAMETERS_TO_INSERT
import androidx.room.processor.ProcessorErrors.INSERT_MULTI_PARAM_SINGLE_RETURN_MISMATCH
import androidx.room.processor.ProcessorErrors.INSERT_SINGLE_PARAM_MULTI_RETURN_MISMATCH
-import androidx.room.vo.InsertMethod
+import androidx.room.vo.InsertFunction
import org.junit.Test
import org.junit.runner.RunWith
import org.junit.runners.JUnit4
@Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN")
@RunWith(JUnit4::class)
-class InsertMethodProcessorTest :
- InsertOrUpsertShortcutMethodProcessorTest<InsertMethod>(Insert::class) {
+class InsertFunctionProcessorTest :
+ InsertOrUpsertShortcutFunctionProcessorTest<InsertFunction>(Insert::class) {
override fun noParamsError(): String = INSERT_DOES_NOT_HAVE_ANY_PARAMETERS_TO_INSERT
override fun missingPrimaryKey(
@@ -106,7 +106,7 @@
baseContext: Context,
containing: XType,
executableElement: XMethodElement
- ): InsertMethod {
- return InsertMethodProcessor(baseContext, containing, executableElement).process()
+ ): InsertFunction {
+ return InsertFunctionProcessor(baseContext, containing, executableElement).process()
}
}
diff --git a/room/room-compiler/src/test/kotlin/androidx/room/processor/InsertOrUpsertShortcutMethodProcessorTest.kt b/room/room-compiler/src/test/kotlin/androidx/room/processor/InsertOrUpsertShortcutFunctionProcessorTest.kt
similarity index 92%
rename from room/room-compiler/src/test/kotlin/androidx/room/processor/InsertOrUpsertShortcutMethodProcessorTest.kt
rename to room/room-compiler/src/test/kotlin/androidx/room/processor/InsertOrUpsertShortcutFunctionProcessorTest.kt
index 03be0b1..7857656 100644
--- a/room/room-compiler/src/test/kotlin/androidx/room/processor/InsertOrUpsertShortcutMethodProcessorTest.kt
+++ b/room/room-compiler/src/test/kotlin/androidx/room/processor/InsertOrUpsertShortcutFunctionProcessorTest.kt
@@ -36,14 +36,14 @@
import androidx.room.ext.RxJava2TypeNames
import androidx.room.ext.RxJava3TypeNames
import androidx.room.runProcessorTestWithK1
-import androidx.room.solver.shortcut.result.InsertOrUpsertMethodAdapter
+import androidx.room.solver.shortcut.result.InsertOrUpsertFunctionAdapter
import androidx.room.testing.context
-import androidx.room.vo.InsertOrUpsertShortcutMethod
+import androidx.room.vo.InsertOrUpsertShortcutFunction
import kotlin.reflect.KClass
import org.junit.Test
/** Base test class for insert and upsert methods. */
-abstract class InsertOrUpsertShortcutMethodProcessorTest<out T : InsertOrUpsertShortcutMethod>(
+abstract class InsertOrUpsertShortcutFunctionProcessorTest<out T : InsertOrUpsertShortcutFunction>(
val annotation: KClass<out Annotation>
) {
companion object {
@@ -139,14 +139,14 @@
@Test
fun singleNullableParamError() {
- singleInsertUpsertShortcutMethodKotlin(
+ singleInsertUpsertShortcutFunction(
"""
@${annotation.java.canonicalName}
abstract fun foo(user: User?)
"""
) { _, invocation ->
invocation.assertCompilationResult {
- hasErrorContaining(ProcessorErrors.nullableParamInShortcutMethod("foo.bar.User"))
+ hasErrorContaining(ProcessorErrors.nullableParamInShortcutFunction("foo.bar.User"))
}
}
}
@@ -183,14 +183,14 @@
@Test
fun twoNullableParamError() {
- singleInsertUpsertShortcutMethodKotlin(
+ singleInsertUpsertShortcutFunction(
"""
@${annotation.java.canonicalName}
abstract fun foo(user1: User?, user2: User?)
"""
) { _, invocation ->
invocation.assertCompilationResult {
- hasErrorContaining(ProcessorErrors.nullableParamInShortcutMethod("foo.bar.User"))
+ hasErrorContaining(ProcessorErrors.nullableParamInShortcutFunction("foo.bar.User"))
hasErrorCount(2)
}
}
@@ -234,7 +234,7 @@
@Test
fun nullableListParamError() {
- singleInsertUpsertShortcutMethodKotlin(
+ singleInsertUpsertShortcutFunction(
"""
@${annotation.java.canonicalName}
abstract fun foo(users: List<User?>)
@@ -242,7 +242,7 @@
) { _, invocation ->
invocation.assertCompilationResult {
hasErrorContaining(
- ProcessorErrors.nullableParamInShortcutMethod(
+ ProcessorErrors.nullableParamInShortcutFunction(
"java.util.List<? extends foo.bar.User>"
)
)
@@ -278,14 +278,16 @@
@Test
fun nullableArrayParamError() {
- singleInsertUpsertShortcutMethodKotlin(
+ singleInsertUpsertShortcutFunction(
"""
@${annotation.java.canonicalName}
abstract fun foo(users: Array<User?>)
"""
) { _, invocation ->
invocation.assertCompilationResult {
- hasErrorContaining(ProcessorErrors.nullableParamInShortcutMethod("foo.bar.User[]"))
+ hasErrorContaining(
+ ProcessorErrors.nullableParamInShortcutFunction("foo.bar.User[]")
+ )
}
}
}
@@ -320,7 +322,7 @@
@Test
fun nullableSetParamError() {
- singleInsertUpsertShortcutMethodKotlin(
+ singleInsertUpsertShortcutFunction(
"""
@${annotation.java.canonicalName}
abstract fun foo(users: Set<User?>)
@@ -328,7 +330,7 @@
) { _, invocation ->
invocation.assertCompilationResult {
hasErrorContaining(
- ProcessorErrors.nullableParamInShortcutMethod(
+ ProcessorErrors.nullableParamInShortcutFunction(
"java.util.Set<? extends foo.bar.User>"
)
)
@@ -422,7 +424,7 @@
@Test
fun nullableCustomCollectionParamError() {
- singleInsertUpsertShortcutMethodKotlin(
+ singleInsertUpsertShortcutFunction(
"""
class MyList<Irrelevant, Item> : ArrayList<Item> {}
@${annotation.java.canonicalName}
@@ -431,7 +433,7 @@
) { _, invocation ->
invocation.assertCompilationResult {
hasErrorContaining(
- ProcessorErrors.nullableParamInShortcutMethod(
+ ProcessorErrors.nullableParamInShortcutFunction(
"foo.bar.MyClass.MyList<java.lang.String, foo.bar.User>"
)
)
@@ -479,7 +481,7 @@
RxJava3TypeNames.COMPLETABLE.canonicalName
)
.forEach { type ->
- singleInsertUpsertShortcutMethodKotlin(
+ singleInsertUpsertShortcutFunction(
"""
@${annotation.java.canonicalName}
abstract fun bookUserCompletable(user: User, book: Book): $type
@@ -492,15 +494,15 @@
@Test
fun twoNullableDifferentParamError() {
- singleInsertUpsertShortcutMethodKotlin(
+ singleInsertUpsertShortcutFunction(
"""
@${annotation.java.canonicalName}
abstract fun foo(user1: User?, book1: Book?)
"""
) { _, invocation ->
invocation.assertCompilationResult {
- hasErrorContaining(ProcessorErrors.nullableParamInShortcutMethod("foo.bar.User"))
- hasErrorContaining(ProcessorErrors.nullableParamInShortcutMethod("foo.bar.Book"))
+ hasErrorContaining(ProcessorErrors.nullableParamInShortcutFunction("foo.bar.User"))
+ hasErrorContaining(ProcessorErrors.nullableParamInShortcutFunction("foo.bar.Book"))
hasErrorCount(2)
}
}
@@ -524,7 +526,7 @@
abstract public $type foo(User user);
"""
) { insertionUpsertion, invocation ->
- assertThat(insertionUpsertion.methodBinder?.adapter).isNull()
+ assertThat(insertionUpsertion.functionBinder?.adapter).isNull()
invocation.assertCompilationResult { hasErrorContaining(noAdapter()) }
}
@@ -547,7 +549,7 @@
abstract public $type foo(User user);
"""
) { insertionUpsertion, invocation ->
- assertThat(insertionUpsertion.methodBinder?.adapter).isNull()
+ assertThat(insertionUpsertion.functionBinder?.adapter).isNull()
invocation.assertCompilationResult {
hasErrorContaining(singleParamAndMultiReturnMismatchError())
@@ -571,7 +573,7 @@
abstract public $type foo(User... user);
"""
) { insertionUpsertion, invocation ->
- assertThat(insertionUpsertion.methodBinder?.adapter).isNull()
+ assertThat(insertionUpsertion.functionBinder?.adapter).isNull()
invocation.assertCompilationResult {
hasErrorContaining(multiParamAndSingleReturnMismatchError())
@@ -595,7 +597,7 @@
abstract public $type foo(User user1, User user2);
"""
) { insertionUpsertion, invocation ->
- assertThat(insertionUpsertion.methodBinder?.adapter).isNull()
+ assertThat(insertionUpsertion.functionBinder?.adapter).isNull()
invocation.assertCompilationResult { hasErrorContaining(noAdapter()) }
}
@@ -605,50 +607,50 @@
@Test
fun validReturnTypes() {
listOf(
- Pair("void", InsertOrUpsertMethodAdapter.ReturnInfo.VOID),
- Pair("long", InsertOrUpsertMethodAdapter.ReturnInfo.SINGLE_ID),
- Pair("long[]", InsertOrUpsertMethodAdapter.ReturnInfo.ID_ARRAY),
- Pair("Long[]", InsertOrUpsertMethodAdapter.ReturnInfo.ID_ARRAY_BOX),
- Pair("List<Long>", InsertOrUpsertMethodAdapter.ReturnInfo.ID_LIST),
+ Pair("void", InsertOrUpsertFunctionAdapter.ReturnInfo.VOID),
+ Pair("long", InsertOrUpsertFunctionAdapter.ReturnInfo.SINGLE_ID),
+ Pair("long[]", InsertOrUpsertFunctionAdapter.ReturnInfo.ID_ARRAY),
+ Pair("Long[]", InsertOrUpsertFunctionAdapter.ReturnInfo.ID_ARRAY_BOX),
+ Pair("List<Long>", InsertOrUpsertFunctionAdapter.ReturnInfo.ID_LIST),
Pair(
RxJava2TypeNames.COMPLETABLE.canonicalName,
- InsertOrUpsertMethodAdapter.ReturnInfo.VOID_OBJECT
+ InsertOrUpsertFunctionAdapter.ReturnInfo.VOID_OBJECT
),
Pair(
"${RxJava2TypeNames.SINGLE.canonicalName}<Long>",
- InsertOrUpsertMethodAdapter.ReturnInfo.SINGLE_ID
+ InsertOrUpsertFunctionAdapter.ReturnInfo.SINGLE_ID
),
Pair(
"${RxJava2TypeNames.SINGLE.canonicalName}<List<Long>>",
- InsertOrUpsertMethodAdapter.ReturnInfo.ID_LIST
+ InsertOrUpsertFunctionAdapter.ReturnInfo.ID_LIST
),
Pair(
"${RxJava2TypeNames.MAYBE.canonicalName}<Long>",
- InsertOrUpsertMethodAdapter.ReturnInfo.SINGLE_ID
+ InsertOrUpsertFunctionAdapter.ReturnInfo.SINGLE_ID
),
Pair(
"${RxJava2TypeNames.MAYBE.canonicalName}<List<Long>>",
- InsertOrUpsertMethodAdapter.ReturnInfo.ID_LIST
+ InsertOrUpsertFunctionAdapter.ReturnInfo.ID_LIST
),
Pair(
RxJava3TypeNames.COMPLETABLE.canonicalName,
- InsertOrUpsertMethodAdapter.ReturnInfo.VOID_OBJECT
+ InsertOrUpsertFunctionAdapter.ReturnInfo.VOID_OBJECT
),
Pair(
"${RxJava3TypeNames.SINGLE.canonicalName}<Long>",
- InsertOrUpsertMethodAdapter.ReturnInfo.SINGLE_ID
+ InsertOrUpsertFunctionAdapter.ReturnInfo.SINGLE_ID
),
Pair(
"${RxJava3TypeNames.SINGLE.canonicalName}<List<Long>>",
- InsertOrUpsertMethodAdapter.ReturnInfo.ID_LIST
+ InsertOrUpsertFunctionAdapter.ReturnInfo.ID_LIST
),
Pair(
"${RxJava3TypeNames.MAYBE.canonicalName}<Long>",
- InsertOrUpsertMethodAdapter.ReturnInfo.SINGLE_ID
+ InsertOrUpsertFunctionAdapter.ReturnInfo.SINGLE_ID
),
Pair(
"${RxJava3TypeNames.MAYBE.canonicalName}<List<Long>>",
- InsertOrUpsertMethodAdapter.ReturnInfo.ID_LIST
+ InsertOrUpsertFunctionAdapter.ReturnInfo.ID_LIST
)
)
.forEach { pair ->
@@ -656,9 +658,9 @@
if (
pair.second in
setOf(
- InsertOrUpsertMethodAdapter.ReturnInfo.ID_LIST,
- InsertOrUpsertMethodAdapter.ReturnInfo.ID_ARRAY,
- InsertOrUpsertMethodAdapter.ReturnInfo.ID_ARRAY_BOX
+ InsertOrUpsertFunctionAdapter.ReturnInfo.ID_LIST,
+ InsertOrUpsertFunctionAdapter.ReturnInfo.ID_ARRAY,
+ InsertOrUpsertFunctionAdapter.ReturnInfo.ID_ARRAY_BOX
)
) {
"..."
@@ -671,7 +673,7 @@
abstract public ${pair.first} foo(User$dots user);
"""
) { insertionUpsertion, _ ->
- assertThat(insertionUpsertion.methodBinder?.adapter).isNotNull()
+ assertThat(insertionUpsertion.functionBinder?.adapter).isNotNull()
}
}
}
@@ -1091,7 +1093,7 @@
"${KotlinTypeNames.FLOW.canonicalName}<Int>"
)
.forEach { type ->
- singleInsertUpsertShortcutMethodKotlin(
+ singleInsertUpsertShortcutFunction(
"""
@${annotation.java.canonicalName}
abstract suspend fun foo(user: User): $type
@@ -1107,7 +1109,7 @@
@Test
fun nonNullVoidGuava() {
- singleInsertUpsertShortcutMethodKotlin(
+ singleInsertUpsertShortcutFunction(
"""
@${annotation.java.canonicalName}
abstract fun foo(user: User): ListenableFuture<Void>
@@ -1168,7 +1170,7 @@
}
}
- protected fun singleInsertUpsertShortcutMethodKotlin(
+ protected fun singleInsertUpsertShortcutFunction(
vararg input: String,
additionalSources: List<Source> = emptyList(),
handler: (T, XTestInvocation) -> Unit
@@ -1202,7 +1204,7 @@
sources = commonSources + additionalSources + inputSource,
options = mapOf(Context.BooleanProcessorOptions.GENERATE_KOTLIN.argName to "false"),
) { invocation ->
- val (owner, methods) =
+ val (owner, functions) =
invocation.roundEnv
.getElementsAnnotatedWith(Dao::class.qualifiedName!!)
.filterIsInstance<XTypeElement>()
@@ -1217,7 +1219,7 @@
process(
baseContext = invocation.context,
containing = owner.type,
- executableElement = methods.first()
+ executableElement = functions.first()
)
handler(processed, invocation)
}
diff --git a/room/room-compiler/src/test/kotlin/androidx/room/processor/QueryMethodProcessorTest.kt b/room/room-compiler/src/test/kotlin/androidx/room/processor/QueryFunctionProcessorTest.kt
similarity index 94%
rename from room/room-compiler/src/test/kotlin/androidx/room/processor/QueryMethodProcessorTest.kt
rename to room/room-compiler/src/test/kotlin/androidx/room/processor/QueryFunctionProcessorTest.kt
index d00ef58..10f2366 100644
--- a/room/room-compiler/src/test/kotlin/androidx/room/processor/QueryMethodProcessorTest.kt
+++ b/room/room-compiler/src/test/kotlin/androidx/room/processor/QueryFunctionProcessorTest.kt
@@ -54,10 +54,10 @@
import androidx.room.solver.query.result.SingleItemQueryResultAdapter
import androidx.room.testing.context
import androidx.room.vo.Field
-import androidx.room.vo.QueryMethod
-import androidx.room.vo.ReadQueryMethod
+import androidx.room.vo.QueryFunction
+import androidx.room.vo.ReadQueryFunction
import androidx.room.vo.Warning
-import androidx.room.vo.WriteQueryMethod
+import androidx.room.vo.WriteQueryFunction
import createVerifierFromEntitiesAndViews
import mockElementAndType
import org.junit.AssumptionViolatedException
@@ -67,7 +67,7 @@
import org.mockito.Mockito
@RunWith(Parameterized::class)
-class QueryMethodProcessorTest(private val enableVerification: Boolean) {
+class QueryFunctionProcessorTest(private val enableVerification: Boolean) {
companion object {
const val DAO_PREFIX =
"""
@@ -115,7 +115,7 @@
@Test
fun testReadNoParams() {
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
@Query("SELECT uid from User")
abstract public int[] foo();
@@ -130,7 +130,7 @@
@Test
fun testSingleParam() {
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
@Query("SELECT * from User where uid = :x")
abstract public long foo(int x);
@@ -149,7 +149,7 @@
@Test
fun testVarArgs() {
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
@Query("SELECT * from User where uid in (:ids)")
abstract public long foo(int... ids);
@@ -168,7 +168,7 @@
@Test
fun testParamBindingMatchingNoName() {
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
@Query("SELECT uid from User where uid = :id")
abstract public long getIdById(int id);
@@ -184,7 +184,7 @@
@Test
fun testParamBindingMatchingSimpleBind() {
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
@Query("SELECT uid from User where uid = :id")
abstract public long getIdById(int id);
@@ -200,7 +200,7 @@
@Test
fun testParamBindingTwoBindVarsIntoTheSameParameter() {
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
@Query("SELECT uid from User where uid = :id OR uid = :id")
abstract public long getIdById(int id);
@@ -219,7 +219,7 @@
@Test
fun testMissingParameterForBinding() {
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
@Query("SELECT uid from User where uid = :id OR uid = :uid")
abstract public long getIdById(int id);
@@ -241,7 +241,7 @@
@Test
fun test2MissingParameterForBinding() {
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
@Query("SELECT uid from User where name = :bar AND uid = :id OR uid = :uid")
abstract public long getIdById(int id);
@@ -268,7 +268,7 @@
@Test
fun testUnusedParameters() {
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
@Query("SELECT uid from User where name = :bar")
abstract public long getIdById(int bar, int whyNotUseMe);
@@ -281,7 +281,7 @@
assertThat(parsedQuery.sectionToParamMapping).containsExactly(bar to barParam)
invocation.assertCompilationResult {
hasErrorContaining(
- ProcessorErrors.unusedQueryMethodParameter(listOf("whyNotUseMe"))
+ ProcessorErrors.unusedQueryFunctionParameter(listOf("whyNotUseMe"))
)
}
}
@@ -289,7 +289,7 @@
@Test
fun testNameWithUnderscore() {
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
@Query("select * from User where uid = :_blah")
abstract public long getSth(int _blah);
@@ -303,7 +303,7 @@
@Test
fun testGenericReturnType() {
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
@Query("select * from User")
abstract public <T> ${LIST.canonicalName}<T> foo(int x);
@@ -320,14 +320,14 @@
.copy(nullable = true)
assertThat(parsedQuery.returnType.asTypeName()).isEqualTo(expected)
invocation.assertCompilationResult {
- hasErrorContaining(ProcessorErrors.CANNOT_USE_UNBOUND_GENERICS_IN_QUERY_METHODS)
+ hasErrorContaining(ProcessorErrors.CANNOT_USE_UNBOUND_GENERICS_IN_QUERY_FUNCTIONS)
}
}
}
@Test
fun testBadQuery() {
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
@Query("select * from :1 :2")
abstract public long foo(int x);
@@ -340,7 +340,7 @@
@Test
fun testLiveDataWithWithClause() {
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
@Query("WITH RECURSIVE tempTable(n, fact) AS (SELECT 0, 1 UNION ALL SELECT n+1,"
+ " (n+1)*fact FROM tempTable WHERE n < 9) SELECT fact FROM tempTable, User")
@@ -356,7 +356,7 @@
@Test
fun testLiveDataWithNothingToObserve() {
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
@Query("SELECT 1")
abstract public ${LifecyclesTypeNames.LIVE_DATA.canonicalName}<Integer> getOne();
@@ -370,7 +370,7 @@
@Test
fun testLiveDataWithWithClauseAndNothingToObserve() {
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
@Query("WITH RECURSIVE tempTable(n, fact) AS (SELECT 0, 1 UNION ALL SELECT n+1,"
+ " (n+1)*fact FROM tempTable WHERE n < 9) SELECT fact FROM tempTable")
@@ -386,7 +386,7 @@
@Test
fun testBoundGeneric() {
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
static abstract class BaseModel<T> {
@Query("select COUNT(*) from User")
@@ -404,7 +404,7 @@
@Test
fun testBoundGenericParameter() {
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
static abstract class BaseModel<T> {
@Query("select COUNT(*) from User where :t")
@@ -422,7 +422,7 @@
@Test
fun testReadDeleteWithBadReturnType() {
- singleQueryMethod<WriteQueryMethod>(
+ singleQueryMethod<WriteQueryFunction>(
"""
@Query("DELETE from User where uid = :id")
abstract public float foo(int id);
@@ -438,7 +438,7 @@
@Test
fun testSimpleDelete() {
- singleQueryMethod<WriteQueryMethod>(
+ singleQueryMethod<WriteQueryFunction>(
"""
@Query("DELETE from User where uid = :id")
abstract public int foo(int id);
@@ -452,7 +452,7 @@
@Test
fun testVoidDeleteQuery() {
- singleQueryMethod<WriteQueryMethod>(
+ singleQueryMethod<WriteQueryFunction>(
"""
@Query("DELETE from User where uid = :id")
abstract public void foo(int id);
@@ -466,7 +466,7 @@
@Test
fun testVoidUpdateQuery() {
- singleQueryMethod<WriteQueryMethod>(
+ singleQueryMethod<WriteQueryFunction>(
"""
@Query("update user set name = :name")
abstract public void updateAllNames(String name);
@@ -482,7 +482,7 @@
@Test
fun testVoidInsertQuery() {
- singleQueryMethod<WriteQueryMethod>(
+ singleQueryMethod<WriteQueryFunction>(
"""
@Query("insert into user (name) values (:name)")
abstract public void insertUsername(String name);
@@ -498,7 +498,7 @@
@Test
fun testLongInsertQuery() {
- singleQueryMethod<WriteQueryMethod>(
+ singleQueryMethod<WriteQueryFunction>(
"""
@Query("insert into user (name) values (:name)")
abstract public long insertUsername(String name);
@@ -514,7 +514,7 @@
@Test
fun testInsertQueryWithBadReturnType() {
- singleQueryMethod<WriteQueryMethod>(
+ singleQueryMethod<WriteQueryFunction>(
"""
@Query("insert into user (name) values (:name)")
abstract public int insert(String name);
@@ -531,7 +531,7 @@
@Test
fun testLiveDataQuery() {
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
@Query("select name from user where uid = :id")
abstract ${LifecyclesTypeNames.LIVE_DATA.canonicalName}<String> nameLiveData(String id);
@@ -549,7 +549,7 @@
@Test
fun testBadReturnForDeleteQuery() {
- singleQueryMethod<WriteQueryMethod>(
+ singleQueryMethod<WriteQueryFunction>(
"""
@Query("delete from user where uid = :id")
abstract ${LifecyclesTypeNames.LIVE_DATA.canonicalName}<Integer> deleteLiveData(String id);
@@ -568,7 +568,7 @@
@Test
fun testBadReturnForUpdateQuery() {
- singleQueryMethod<WriteQueryMethod>(
+ singleQueryMethod<WriteQueryFunction>(
"""
@Query("update user set name = :name")
abstract ${LifecyclesTypeNames.LIVE_DATA.canonicalName}<Integer> updateNameLiveData(String name);
@@ -587,7 +587,7 @@
@Test
fun testDataSourceFactoryQuery() {
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
@Query("select name from user")
abstract ${PagingTypeNames.DATA_SOURCE_FACTORY.canonicalName}<Integer, String>
@@ -615,7 +615,7 @@
@Test
fun testMultiTableDataSourceFactoryQuery() {
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
@Query("select name from User u LEFT OUTER JOIN Book b ON u.uid == b.uid")
abstract ${PagingTypeNames.DATA_SOURCE_FACTORY.canonicalName}<Integer, String>
@@ -642,7 +642,7 @@
@Test
fun testBadChannelReturnForQuery() {
- singleQueryMethod<QueryMethod>(
+ singleQueryMethod<QueryFunction>(
"""
@Query("select * from user")
abstract ${KotlinTypeNames.CHANNEL.canonicalName}<User> getUsersChannel();
@@ -659,7 +659,7 @@
@Test
fun testBadSendChannelReturnForQuery() {
- singleQueryMethod<QueryMethod>(
+ singleQueryMethod<QueryFunction>(
"""
@Query("select * from user")
abstract ${KotlinTypeNames.SEND_CHANNEL.canonicalName}<User> getUsersChannel();
@@ -676,7 +676,7 @@
@Test
fun testBadReceiveChannelReturnForQuery() {
- singleQueryMethod<QueryMethod>(
+ singleQueryMethod<QueryFunction>(
"""
@Query("select * from user")
abstract ${KotlinTypeNames.RECEIVE_CHANNEL.canonicalName}<User> getUsersChannel();
@@ -695,7 +695,7 @@
@Test
fun query_detectTransaction_select() {
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
@Query("select * from user")
abstract int loadUsers();
@@ -707,7 +707,7 @@
@Test
fun query_detectTransaction_selectInTransaction() {
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
@Transaction
@Query("select * from user")
@@ -720,7 +720,7 @@
@Test
fun skipVerification() {
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
@SkipQueryVerification
@Query("SELECT foo from User")
@@ -736,7 +736,7 @@
@Test
fun skipVerificationDataClass() {
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
@SkipQueryVerification
@Query("SELECT bookId, uid FROM User")
@@ -758,7 +758,7 @@
@Test
fun suppressWarnings() {
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
@SuppressWarnings(RoomWarnings.QUERY_MISMATCH)
@Query("SELECT uid from User")
@@ -766,7 +766,7 @@
"""
) { method, invocation ->
assertThat(
- QueryMethodProcessor(
+ QueryFunctionProcessor(
baseContext = invocation.context,
containing = Mockito.mock(XType::class.java),
executableElement = method.element,
@@ -785,7 +785,7 @@
if (!enableVerification) {
return
}
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
static class Merged extends User {
@Relation(parentColumn = "name", entityColumn = "lastName",
@@ -865,7 +865,7 @@
if (!enableVerification) {
throw AssumptionViolatedException("nothing to test w/o db verification")
}
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
@RewriteQueriesToDropUnusedColumns
@Query("select 1 from user")
@@ -884,7 +884,7 @@
if (!enableVerification) {
throw AssumptionViolatedException("nothing to test w/o db verification")
}
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
public static class DataClass {
public String name;
@@ -923,7 +923,7 @@
"""
.trimIndent()
)
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
public static class Username {
public String name;
@@ -960,7 +960,7 @@
if (!enableVerification) {
throw AssumptionViolatedException("nothing to test w/o db verification")
}
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
public static class DataClass {
public String name;
@@ -1190,9 +1190,9 @@
dataClassFields: String,
queryColumns: List<String>,
options: Map<String, String> = emptyMap(),
- handler: (DataClassRowAdapter?, QueryMethod, XTestInvocation) -> Unit
+ handler: (DataClassRowAdapter?, QueryFunction, XTestInvocation) -> Unit
) {
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
static class DataClass {
$dataClassFields
@@ -1219,7 +1219,7 @@
}
}
- private fun <T : QueryMethod> singleQueryMethod(
+ private fun <T : QueryFunction> singleQueryMethod(
vararg input: String,
additionalSources: Iterable<Source> = emptyList(),
options: Map<String, String> = emptyMap(),
@@ -1269,7 +1269,7 @@
null
}
val parser =
- QueryMethodProcessor(
+ QueryFunctionProcessor(
baseContext = invocation.context,
containing = owner.type,
executableElement = methods.first(),
@@ -1280,7 +1280,7 @@
}
}
- private fun <T : QueryMethod> singleQueryMethodKotlin(
+ private fun <T : QueryFunction> singleQueryFunction(
vararg input: String,
additionalSources: Iterable<Source> = emptyList(),
options: Map<String, String> = emptyMap(),
@@ -1339,7 +1339,7 @@
null
}
val parser =
- QueryMethodProcessor(
+ QueryFunctionProcessor(
baseContext = invocation.context,
containing = owner.type,
executableElement = methods.first(),
@@ -1352,7 +1352,7 @@
@Test
fun testInvalidLinkedListCollectionInMultimapJoin() {
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
@Query("select * from User u JOIN Book b ON u.uid == b.uid")
abstract Map<User, LinkedList<Book>> getInvalidCollectionMultimap();
@@ -1362,7 +1362,7 @@
hasErrorCount(2)
hasErrorContaining("Multimap 'value' collection type must be a List, Set or Map.")
hasErrorContaining(
- "Not sure how to convert the query result to this method's return type"
+ "Not sure how to convert the query result to this function's return type"
)
}
}
@@ -1370,7 +1370,7 @@
@Test
fun testInvalidGenericMultimapJoin() {
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
@Query("select * from User u JOIN Book b ON u.uid == b.uid")
abstract com.google.common.collect.ImmutableMultimap<User, Book>
@@ -1381,7 +1381,7 @@
hasErrorCount(2)
hasErrorContaining(DO_NOT_USE_GENERIC_IMMUTABLE_MULTIMAP)
hasErrorContaining(
- "Not sure how to convert the query result to this method's return type"
+ "Not sure how to convert the query result to this function's return type"
)
}
}
@@ -1392,7 +1392,7 @@
if (!enableVerification) {
return
}
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
@MapInfo
@Query("select * from User u JOIN Book b ON u.uid == b.uid")
@@ -1411,7 +1411,7 @@
if (!enableVerification) {
return
}
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
@SuppressWarnings(
{RoomWarnings.QUERY_MISMATCH, RoomWarnings.AMBIGUOUS_COLUMN_IN_RESULT}
@@ -1430,7 +1430,7 @@
if (!enableVerification) {
return
}
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
@SuppressWarnings(
{RoomWarnings.QUERY_MISMATCH, RoomWarnings.AMBIGUOUS_COLUMN_IN_RESULT}
@@ -1449,7 +1449,7 @@
if (!enableVerification) {
return
}
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
@SuppressWarnings(RoomWarnings.QUERY_MISMATCH)
@MapInfo(keyColumn = "name", valueColumn = "bookCount")
@@ -1467,7 +1467,7 @@
if (!enableVerification) {
return
}
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
@SuppressWarnings(
{RoomWarnings.QUERY_MISMATCH, RoomWarnings.AMBIGUOUS_COLUMN_IN_RESULT}
@@ -1485,7 +1485,7 @@
if (!enableVerification) {
return
}
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
@SuppressWarnings(
{RoomWarnings.QUERY_MISMATCH, RoomWarnings.AMBIGUOUS_COLUMN_IN_RESULT}
@@ -1508,7 +1508,7 @@
if (!enableVerification) {
return
}
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
@SuppressWarnings(
{RoomWarnings.QUERY_MISMATCH, RoomWarnings.AMBIGUOUS_COLUMN_IN_RESULT}
@@ -1526,7 +1526,7 @@
if (!enableVerification) {
return
}
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
@SuppressWarnings(
{RoomWarnings.QUERY_MISMATCH, RoomWarnings.AMBIGUOUS_COLUMN_IN_RESULT}
@@ -1544,7 +1544,7 @@
if (!enableVerification) {
return
}
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
@SuppressWarnings(RoomWarnings.QUERY_MISMATCH)
@Query("SELECT name, (SELECT count(*) FROM User u JOIN Book b ON u.uid == b.uid) "
@@ -1561,7 +1561,7 @@
if (!enableVerification) {
return
}
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
@SuppressWarnings(
{RoomWarnings.QUERY_MISMATCH, RoomWarnings.AMBIGUOUS_COLUMN_IN_RESULT}
@@ -1579,7 +1579,7 @@
@Test
fun testDoesNotImplementEqualsAndHashcodeQuery() {
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
@Query("select * from User u JOIN Book b ON u.uid == b.uid")
abstract Map<User, Book> getMultimap();
@@ -1596,7 +1596,7 @@
@Test
fun testMissingMapInfoOneToOneString() {
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
@Query("select * from Artist JOIN Song ON Artist.mArtistName == Song.mArtist")
abstract Map<Artist, String> getAllArtistsWithAlbumCoverYear();
@@ -1610,7 +1610,7 @@
@Test
fun testOneToOneStringMapInfoForKeyInsteadOfColumn() {
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
@MapInfo(keyColumn = "mArtistName")
@Query("select * from Artist JOIN Song ON Artist.mArtistName == Song.mArtist")
@@ -1625,7 +1625,7 @@
@Test
fun testMissingMapInfoOneToManyString() {
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
@Query("select * from Artist JOIN Song ON Artist.mArtistName == Song.mArtist")
abstract Map<Artist, List<String>> getAllArtistsWithAlbumCoverYear();
@@ -1639,7 +1639,7 @@
@Test
fun testMissingMapInfoImmutableListMultimapOneToOneString() {
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
@Query("select * from Artist JOIN Song ON Artist.mArtistName == Song.mArtist")
abstract ImmutableListMultimap<Artist, String> getAllArtistsWithAlbumCoverYear();
@@ -1653,7 +1653,7 @@
@Test
fun testMissingMapInfoOneToOneLong() {
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
@Query("SELECT * FROM Artist JOIN Image ON Artist.mArtistName = Image.mArtistInImage")
Map<Artist, Long> getAllArtistsWithAlbumCoverYear();
@@ -1667,7 +1667,7 @@
@Test
fun testMissingMapInfoOneToManyLong() {
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
@Query("SELECT * FROM Artist JOIN Image ON Artist.mArtistName = Image.mArtistInImage")
Map<Artist, Set<Long>> getAllArtistsWithAlbumCoverYear();
@@ -1681,7 +1681,7 @@
@Test
fun testMissingMapInfoImmutableListMultimapOneToOneLong() {
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
@Query("SELECT * FROM Artist JOIN Image ON Artist.mArtistName = Image.mArtistInImage")
ImmutableListMultimap<Artist, Long> getAllArtistsWithAlbumCoverYear();
@@ -1695,7 +1695,7 @@
@Test
fun testMissingMapInfoImmutableListMultimapOneToOneTypeConverterKey() {
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
@TypeConverters(DateConverter.class)
@Query("SELECT * FROM Image JOIN Artist ON Artist.mArtistName = Image.mArtistInImage")
@@ -1710,7 +1710,7 @@
@Test
fun testMissingMapInfoImmutableListMultimapOneToOneTypeConverterValue() {
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
@TypeConverters(DateConverter.class)
@Query("SELECT * FROM Artist JOIN Image ON Artist.mArtistName = Image.mArtistInImage")
@@ -1728,7 +1728,7 @@
if (!enableVerification) {
return
}
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
@MapInfo(keyColumn="cat", valueColumn="dog")
@Query("select * from User u JOIN Book b ON u.uid == b.uid")
@@ -1759,7 +1759,7 @@
// No warning without verification, avoiding false positives
return
}
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
@SuppressWarnings(RoomWarnings.QUERY_MISMATCH)
@MapInfo(keyColumn = "uid")
@@ -1806,7 +1806,7 @@
"""
.trimIndent()
)
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
@SuppressWarnings(RoomWarnings.QUERY_MISMATCH)
@Query("SELECT * FROM User u JOIN Book b ON u.uid == b.uid")
@@ -1846,7 +1846,7 @@
"${KotlinTypeNames.FLOW.canonicalName}<Int>"
)
.forEach { type ->
- singleQueryMethodKotlin<WriteQueryMethod>(
+ singleQueryFunction<WriteQueryFunction>(
"""
@Query("DELETE from User where uid = :id")
abstract suspend fun foo(id: Int): $type
@@ -1862,7 +1862,7 @@
@Test
fun nonNullVoidGuava() {
- singleQueryMethodKotlin<WriteQueryMethod>(
+ singleQueryFunction<WriteQueryFunction>(
"""
@Query("DELETE from User where uid = :id")
abstract fun foo(id: Int): ListenableFuture<Void>
@@ -1874,7 +1874,7 @@
@Test
fun maybe() {
- singleQueryMethodKotlin<ReadQueryMethod>(
+ singleQueryFunction<ReadQueryFunction>(
"""
@Query("SELECT * FROM book WHERE bookId = :bookId")
abstract fun getBookMaybe(bookId: String): io.reactivex.Maybe<Book>
@@ -1886,7 +1886,7 @@
@Test
fun single() {
- singleQueryMethodKotlin<ReadQueryMethod>(
+ singleQueryFunction<ReadQueryFunction>(
"""
@Query("SELECT * FROM book WHERE bookId = :bookId")
abstract fun getBookSingle(bookId: String): io.reactivex.Single<Book>
@@ -1901,7 +1901,7 @@
if (!enableVerification) {
return
}
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
@Query("select * from User")
abstract String[] stringArray();
@@ -1920,7 +1920,7 @@
if (!enableVerification) {
return
}
- singleQueryMethod<ReadQueryMethod>(
+ singleQueryMethod<ReadQueryFunction>(
"""
@Query("select * from User")
abstract long[] longArray();
diff --git a/room/room-compiler/src/test/kotlin/androidx/room/processor/RawQueryMethodProcessorTest.kt b/room/room-compiler/src/test/kotlin/androidx/room/processor/RawQueryFunctionProcessorTest.kt
similarity index 95%
rename from room/room-compiler/src/test/kotlin/androidx/room/processor/RawQueryMethodProcessorTest.kt
rename to room/room-compiler/src/test/kotlin/androidx/room/processor/RawQueryFunctionProcessorTest.kt
index 7bacb42..5a851a5 100644
--- a/room/room-compiler/src/test/kotlin/androidx/room/processor/RawQueryMethodProcessorTest.kt
+++ b/room/room-compiler/src/test/kotlin/androidx/room/processor/RawQueryFunctionProcessorTest.kt
@@ -37,13 +37,13 @@
import androidx.room.processor.ProcessorErrors.RAW_QUERY_STRING_PARAMETER_REMOVED
import androidx.room.runProcessorTestWithK1
import androidx.room.testing.context
-import androidx.room.vo.RawQueryMethod
+import androidx.room.vo.RawQueryFunction
import androidx.sqlite.db.SupportSQLiteQuery
import org.hamcrest.CoreMatchers.`is`
import org.hamcrest.MatcherAssert.assertThat
import org.junit.Test
-class RawQueryMethodProcessorTest {
+class RawQueryFunctionProcessorTest {
@Test
fun supportRawQuery() {
singleQueryMethod(
@@ -56,7 +56,7 @@
assertThat(
query.runtimeQueryParam,
`is`(
- RawQueryMethod.RuntimeQueryParameter(
+ RawQueryFunction.RuntimeQueryParameter(
paramName = "query",
typeName = SupportDbTypeNames.QUERY
)
@@ -95,7 +95,7 @@
assertThat(
query.runtimeQueryParam,
`is`(
- RawQueryMethod.RuntimeQueryParameter(
+ RawQueryFunction.RuntimeQueryParameter(
paramName = "query",
typeName = SupportDbTypeNames.QUERY
)
@@ -118,7 +118,7 @@
assertThat(
query.runtimeQueryParam,
`is`(
- RawQueryMethod.RuntimeQueryParameter(
+ RawQueryFunction.RuntimeQueryParameter(
paramName = "query",
typeName = SupportDbTypeNames.QUERY
)
@@ -190,7 +190,7 @@
assertThat(
query.runtimeQueryParam,
`is`(
- RawQueryMethod.RuntimeQueryParameter(
+ RawQueryFunction.RuntimeQueryParameter(
paramName = "query",
typeName = SupportDbTypeNames.QUERY
)
@@ -225,7 +225,7 @@
val daoElement =
invocation.processingEnv.requireTypeElement(RawQuerySuspendUnitDao::class)
val daoFunctionElement = daoElement.getDeclaredMethods().first()
- RawQueryMethodProcessor(
+ RawQueryFunctionProcessor(
baseContext = invocation.context,
containing = daoElement.type,
executableElement = daoFunctionElement
@@ -341,8 +341,8 @@
@RawQuery(observedEntities = MyDataClass.class)
abstract public int[] foo(SupportSQLiteQuery query);
"""
- ) { method, _ ->
- assertThat(method.observedTableNames, `is`(setOf("User")))
+ ) { function, _ ->
+ assertThat(function.observedTableNames, `is`(setOf("User")))
}
}
@@ -358,8 +358,8 @@
@RawQuery(observedEntities = MyDataClass.class)
abstract public int[] foo(SupportSQLiteQuery query);
"""
- ) { method, _ ->
- assertThat(method.observedTableNames, `is`(setOf("User")))
+ ) { function, _ ->
+ assertThat(function.observedTableNames, `is`(setOf("User")))
}
}
@@ -598,7 +598,7 @@
"${KotlinTypeNames.FLOW.canonicalName}<Int>"
)
.forEach { type ->
- singleQueryMethodKotlin(
+ singleQueryFunction(
"""
@RawQuery
abstract suspend fun foo(query: SupportSQLiteQuery): $type
@@ -614,7 +614,7 @@
@Test
fun nonNullVoidGuava() {
- singleQueryMethodKotlin(
+ singleQueryFunction(
"""
@RawQuery
abstract fun foo(query: SupportSQLiteQuery): ListenableFuture<Void>
@@ -626,7 +626,7 @@
private fun singleQueryMethod(
vararg input: String,
- handler: (RawQueryMethod, XTestInvocation) -> Unit
+ handler: (RawQueryFunction, XTestInvocation) -> Unit
) {
val inputSource =
Source.java("foo.bar.MyClass", DAO_PREFIX + input.joinToString("\n") + DAO_SUFFIX)
@@ -649,7 +649,7 @@
sources = commonSources + inputSource,
options = mapOf(Context.BooleanProcessorOptions.GENERATE_KOTLIN.argName to "false"),
) { invocation ->
- val (owner, methods) =
+ val (owner, functions) =
invocation.roundEnv
.getElementsAnnotatedWith(Dao::class.qualifiedName!!)
.filterIsInstance<XTypeElement>()
@@ -661,19 +661,19 @@
}
.first { it.second.isNotEmpty() }
val parser =
- RawQueryMethodProcessor(
+ RawQueryFunctionProcessor(
baseContext = invocation.context,
containing = owner.type,
- executableElement = methods.first()
+ executableElement = functions.first()
)
val parsedQuery = parser.process()
handler(parsedQuery, invocation)
}
}
- private fun singleQueryMethodKotlin(
+ private fun singleQueryFunction(
vararg input: String,
- handler: (RawQueryMethod, XTestInvocation) -> Unit
+ handler: (RawQueryFunction, XTestInvocation) -> Unit
) {
val inputSource =
Source.kotlin("MyClass.kt", DAO_PREFIX_KT + input.joinToString("\n") + DAO_SUFFIX)
@@ -700,7 +700,7 @@
COMMON.GUAVA_ROOM
)
runProcessorTestWithK1(sources = commonSources + inputSource) { invocation ->
- val (owner, methods) =
+ val (owner, functions) =
invocation.roundEnv
.getElementsAnnotatedWith(Dao::class.qualifiedName!!)
.filterIsInstance<XTypeElement>()
@@ -712,10 +712,10 @@
}
.first { it.second.isNotEmpty() }
val parser =
- RawQueryMethodProcessor(
+ RawQueryFunctionProcessor(
baseContext = invocation.context,
containing = owner.type,
- executableElement = methods.first()
+ executableElement = functions.first()
)
val parsedQuery = parser.process()
handler(parsedQuery, invocation)
diff --git a/room/room-compiler/src/test/kotlin/androidx/room/processor/TransactionMethodProcessorTest.kt b/room/room-compiler/src/test/kotlin/androidx/room/processor/TransactionFunctionProcessorTest.kt
similarity index 91%
rename from room/room-compiler/src/test/kotlin/androidx/room/processor/TransactionMethodProcessorTest.kt
rename to room/room-compiler/src/test/kotlin/androidx/room/processor/TransactionFunctionProcessorTest.kt
index 9354625..6edea0d 100644
--- a/room/room-compiler/src/test/kotlin/androidx/room/processor/TransactionMethodProcessorTest.kt
+++ b/room/room-compiler/src/test/kotlin/androidx/room/processor/TransactionFunctionProcessorTest.kt
@@ -32,7 +32,7 @@
import androidx.room.ext.RxJava3TypeNames
import androidx.room.runProcessorTestWithK1
import androidx.room.testing.context
-import androidx.room.vo.TransactionMethod
+import androidx.room.vo.TransactionFunction
import org.hamcrest.CoreMatchers.`is`
import org.hamcrest.MatcherAssert.assertThat
import org.junit.Test
@@ -41,7 +41,7 @@
@Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN")
@RunWith(JUnit4::class)
-class TransactionMethodProcessorTest {
+class TransactionFunctionProcessorTest {
companion object {
const val DAO_PREFIX =
@@ -80,7 +80,7 @@
) { transaction, invocation ->
assertThat(transaction.jvmName, `is`("doInTransaction"))
invocation.assertCompilationResult {
- hasErrorContaining(ProcessorErrors.TRANSACTION_METHOD_MODIFIERS)
+ hasErrorContaining(ProcessorErrors.TRANSACTION_FUNCTION_MODIFIERS)
}
}
}
@@ -95,7 +95,7 @@
) { transaction, invocation ->
assertThat(transaction.jvmName, `is`("doInTransaction"))
invocation.assertCompilationResult {
- hasErrorContaining(ProcessorErrors.TRANSACTION_METHOD_MODIFIERS)
+ hasErrorContaining(ProcessorErrors.TRANSACTION_FUNCTION_MODIFIERS)
}
}
}
@@ -113,7 +113,7 @@
assertThat(transaction.jvmName, `is`("doInTransaction"))
invocation.assertCompilationResult {
hasErrorContaining(
- ProcessorErrors.transactionMethodAsync(
+ ProcessorErrors.transactionFunctionAsync(
FLOW.rawTypeName.toString(CodeLanguage.JAVA)
)
)
@@ -132,7 +132,7 @@
assertThat(transaction.jvmName, `is`("doInTransaction"))
invocation.assertCompilationResult {
hasErrorContaining(
- ProcessorErrors.transactionMethodAsync(
+ ProcessorErrors.transactionFunctionAsync(
LIVE_DATA.rawTypeName.toString(CodeLanguage.JAVA)
)
)
@@ -151,7 +151,7 @@
assertThat(transaction.jvmName, `is`("doInTransaction"))
invocation.assertCompilationResult {
hasErrorContaining(
- ProcessorErrors.transactionMethodAsync(
+ ProcessorErrors.transactionFunctionAsync(
COMPUTABLE_LIVE_DATA.rawTypeName.toString(CodeLanguage.JAVA)
)
)
@@ -170,7 +170,7 @@
assertThat(transaction.jvmName, `is`("doInTransaction"))
invocation.assertCompilationResult {
hasErrorContaining(
- ProcessorErrors.transactionMethodAsync(
+ ProcessorErrors.transactionFunctionAsync(
RxJava2TypeNames.FLOWABLE.rawTypeName.toString(CodeLanguage.JAVA)
)
)
@@ -191,7 +191,7 @@
assertThat(transaction.jvmName, `is`("doInTransaction"))
invocation.assertCompilationResult {
hasErrorContaining(
- ProcessorErrors.transactionMethodAsync(
+ ProcessorErrors.transactionFunctionAsync(
RxJava3TypeNames.FLOWABLE.rawTypeName.toString(CodeLanguage.JAVA)
)
)
@@ -210,7 +210,7 @@
assertThat(transaction.jvmName, `is`("doInTransaction"))
invocation.assertCompilationResult {
hasErrorContaining(
- ProcessorErrors.transactionMethodAsync(
+ ProcessorErrors.transactionFunctionAsync(
RxJava2TypeNames.COMPLETABLE.rawTypeName.toString(CodeLanguage.JAVA)
)
)
@@ -231,7 +231,7 @@
assertThat(transaction.jvmName, `is`("doInTransaction"))
invocation.assertCompilationResult {
hasErrorContaining(
- ProcessorErrors.transactionMethodAsync(
+ ProcessorErrors.transactionFunctionAsync(
RxJava3TypeNames.COMPLETABLE.rawTypeName.toString(CodeLanguage.JAVA)
)
)
@@ -250,7 +250,7 @@
assertThat(transaction.jvmName, `is`("doInTransaction"))
invocation.assertCompilationResult {
hasErrorContaining(
- ProcessorErrors.transactionMethodAsync(
+ ProcessorErrors.transactionFunctionAsync(
RxJava2TypeNames.SINGLE.rawTypeName.toString(CodeLanguage.JAVA)
)
)
@@ -271,7 +271,7 @@
assertThat(transaction.jvmName, `is`("doInTransaction"))
invocation.assertCompilationResult {
hasErrorContaining(
- ProcessorErrors.transactionMethodAsync(
+ ProcessorErrors.transactionFunctionAsync(
RxJava3TypeNames.SINGLE.rawTypeName.toString(CodeLanguage.JAVA)
)
)
@@ -290,7 +290,7 @@
assertThat(transaction.jvmName, `is`("doInTransaction"))
invocation.assertCompilationResult {
hasErrorContaining(
- ProcessorErrors.transactionMethodAsync(
+ ProcessorErrors.transactionFunctionAsync(
LISTENABLE_FUTURE.rawTypeName.toString(CodeLanguage.JAVA)
)
)
@@ -309,7 +309,7 @@
assertThat(transaction.jvmName, `is`("doInTransaction"))
invocation.assertCompilationResult {
hasErrorContaining(
- ProcessorErrors.transactionMethodAsync(
+ ProcessorErrors.transactionFunctionAsync(
PUBLISHER.rawTypeName.toString(CodeLanguage.JAVA)
)
)
@@ -317,12 +317,12 @@
}
}
- private val TransactionMethod.jvmName: String
+ private val TransactionFunction.jvmName: String
get() = element.jvmName
private fun singleTransactionMethod(
vararg input: String,
- handler: (TransactionMethod, XTestInvocation) -> Unit
+ handler: (TransactionFunction, XTestInvocation) -> Unit
) {
val inputSource =
listOf(
@@ -360,7 +360,7 @@
}
.first { it.second.isNotEmpty() }
val processor =
- TransactionMethodProcessor(
+ TransactionFunctionProcessor(
baseContext = invocation.context,
containingElement = owner,
containingType = owner.type,
diff --git a/room/room-compiler/src/test/kotlin/androidx/room/processor/UpdateMethodProcessorTest.kt b/room/room-compiler/src/test/kotlin/androidx/room/processor/UpdateFunctionProcessorTest.kt
similarity index 92%
rename from room/room-compiler/src/test/kotlin/androidx/room/processor/UpdateMethodProcessorTest.kt
rename to room/room-compiler/src/test/kotlin/androidx/room/processor/UpdateFunctionProcessorTest.kt
index f5a3a5a..b9b31bd 100644
--- a/room/room-compiler/src/test/kotlin/androidx/room/processor/UpdateMethodProcessorTest.kt
+++ b/room/room-compiler/src/test/kotlin/androidx/room/processor/UpdateFunctionProcessorTest.kt
@@ -22,7 +22,7 @@
import androidx.room.compiler.processing.util.Source
import androidx.room.processor.ProcessorErrors.CANNOT_FIND_UPDATE_RESULT_ADAPTER
import androidx.room.processor.ProcessorErrors.UPDATE_MISSING_PARAMS
-import androidx.room.vo.UpdateMethod
+import androidx.room.vo.UpdateFunction
import org.hamcrest.CoreMatchers.`is`
import org.hamcrest.MatcherAssert.assertThat
import org.junit.Test
@@ -31,8 +31,8 @@
@Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN")
@RunWith(JUnit4::class)
-class UpdateMethodProcessorTest :
- DeleteOrUpdateShortcutMethodProcessorTest<UpdateMethod>(Update::class) {
+class UpdateFunctionProcessorTest :
+ DeleteOrUpdateShortcutFunctionProcessorTest<UpdateFunction>(Update::class) {
override fun invalidReturnTypeError(): String = CANNOT_FIND_UPDATE_RESULT_ADAPTER
override fun noParamsError(): String = UPDATE_MISSING_PARAMS
@@ -41,8 +41,8 @@
baseContext: Context,
containing: XType,
executableElement: XMethodElement
- ): UpdateMethod {
- return UpdateMethodProcessor(baseContext, containing, executableElement).process()
+ ): UpdateFunction {
+ return UpdateFunctionProcessor(baseContext, containing, executableElement).process()
}
@Test
diff --git a/room/room-compiler/src/test/kotlin/androidx/room/processor/UpsertMethodProcessorTest.kt b/room/room-compiler/src/test/kotlin/androidx/room/processor/UpsertFunctionProcessorTest.kt
similarity index 88%
rename from room/room-compiler/src/test/kotlin/androidx/room/processor/UpsertMethodProcessorTest.kt
rename to room/room-compiler/src/test/kotlin/androidx/room/processor/UpsertFunctionProcessorTest.kt
index 25f9a07..e36bf35 100644
--- a/room/room-compiler/src/test/kotlin/androidx/room/processor/UpsertMethodProcessorTest.kt
+++ b/room/room-compiler/src/test/kotlin/androidx/room/processor/UpsertFunctionProcessorTest.kt
@@ -23,14 +23,14 @@
import androidx.room.processor.ProcessorErrors.UPSERT_DOES_NOT_HAVE_ANY_PARAMETERS_TO_UPSERT
import androidx.room.processor.ProcessorErrors.UPSERT_MULTI_PARAM_SINGLE_RETURN_MISMATCH
import androidx.room.processor.ProcessorErrors.UPSERT_SINGLE_PARAM_MULTI_RETURN_MISMATCH
-import androidx.room.vo.UpsertMethod
+import androidx.room.vo.UpsertFunction
import org.junit.runner.RunWith
import org.junit.runners.JUnit4
@Suppress("PLATFORM_CLASS_MAPPED_TO_KOTLIN")
@RunWith(JUnit4::class)
-class UpsertMethodProcessorTest :
- InsertOrUpsertShortcutMethodProcessorTest<UpsertMethod>(Upsert::class) {
+class UpsertFunctionProcessorTest :
+ InsertOrUpsertShortcutFunctionProcessorTest<UpsertFunction>(Upsert::class) {
override fun noParamsError(): String = UPSERT_DOES_NOT_HAVE_ANY_PARAMETERS_TO_UPSERT
override fun missingPrimaryKey(
@@ -55,7 +55,7 @@
baseContext: Context,
containing: XType,
executableElement: XMethodElement
- ): UpsertMethod {
- return UpsertMethodProcessor(baseContext, containing, executableElement).process()
+ ): UpsertFunction {
+ return UpsertFunctionProcessor(baseContext, containing, executableElement).process()
}
}
diff --git a/room/room-compiler/src/test/kotlin/androidx/room/solver/TypeAdapterStoreTest.kt b/room/room-compiler/src/test/kotlin/androidx/room/solver/TypeAdapterStoreTest.kt
index bf39ada..19a60fa 100644
--- a/room/room-compiler/src/test/kotlin/androidx/room/solver/TypeAdapterStoreTest.kt
+++ b/room/room-compiler/src/test/kotlin/androidx/room/solver/TypeAdapterStoreTest.kt
@@ -61,10 +61,10 @@
import androidx.room.solver.query.parameter.CollectionQueryParameterAdapter
import androidx.room.solver.query.result.MultiTypedPagingSourceQueryResultBinder
import androidx.room.solver.query.result.Paging3PagingSourceQueryResultBinder
-import androidx.room.solver.shortcut.binderprovider.GuavaListenableFutureDeleteOrUpdateMethodBinderProvider
-import androidx.room.solver.shortcut.binderprovider.GuavaListenableFutureInsertOrUpsertMethodBinderProvider
-import androidx.room.solver.shortcut.binderprovider.RxCallableDeleteOrUpdateMethodBinderProvider
-import androidx.room.solver.shortcut.binderprovider.RxCallableInsertOrUpsertMethodBinderProvider
+import androidx.room.solver.shortcut.binderprovider.GuavaListenableFutureDeleteOrUpdateFunctionBinderProvider
+import androidx.room.solver.shortcut.binderprovider.GuavaListenableFutureInsertOrUpsertFunctionBinderProvider
+import androidx.room.solver.shortcut.binderprovider.RxCallableDeleteOrUpdateFunctionBinderProvider
+import androidx.room.solver.shortcut.binderprovider.RxCallableInsertOrUpsertFunctionBinderProvider
import androidx.room.solver.types.BoxedPrimitiveColumnTypeAdapter
import androidx.room.solver.types.ByteBufferColumnTypeAdapter
import androidx.room.solver.types.ColumnTypeAdapter
@@ -79,7 +79,7 @@
import androidx.room.solver.types.ValueClassConverterWrapper
import androidx.room.testing.context
import androidx.room.vo.BuiltInConverterFlags
-import androidx.room.vo.ReadQueryMethod
+import androidx.room.vo.ReadQueryFunction
import org.hamcrest.CoreMatchers.instanceOf
import org.hamcrest.CoreMatchers.`is`
import org.hamcrest.CoreMatchers.notNullValue
@@ -880,7 +880,7 @@
val single = invocation.processingEnv.requireTypeElement(rxTypeClassName)
assertThat(single, notNullValue())
assertThat(
- RxCallableInsertOrUpsertMethodBinderProvider.getAll(invocation.context)
+ RxCallableInsertOrUpsertFunctionBinderProvider.getAll(invocation.context)
.any { it.matches(single.type) },
`is`(true)
)
@@ -898,7 +898,7 @@
runProcessorTestWithK1(sources = listOf(rxTypeSrc)) { invocation ->
val maybe = invocation.processingEnv.requireTypeElement(rxTypeClassName)
assertThat(
- RxCallableInsertOrUpsertMethodBinderProvider.getAll(invocation.context)
+ RxCallableInsertOrUpsertFunctionBinderProvider.getAll(invocation.context)
.any { it.matches(maybe.type) },
`is`(true)
)
@@ -916,7 +916,7 @@
runProcessorTestWithK1(sources = listOf(rxTypeSrc)) { invocation ->
val completable = invocation.processingEnv.requireTypeElement(rxTypeClassName)
assertThat(
- RxCallableInsertOrUpsertMethodBinderProvider.getAll(invocation.context)
+ RxCallableInsertOrUpsertFunctionBinderProvider.getAll(invocation.context)
.any { it.matches(completable.type) },
`is`(true)
)
@@ -932,7 +932,7 @@
GuavaUtilConcurrentTypeNames.LISTENABLE_FUTURE
)
assertThat(
- GuavaListenableFutureInsertOrUpsertMethodBinderProvider(invocation.context)
+ GuavaListenableFutureInsertOrUpsertFunctionBinderProvider(invocation.context)
.matches(future.type),
`is`(true)
)
@@ -945,7 +945,7 @@
val single = invocation.processingEnv.requireTypeElement(RxJava2TypeNames.SINGLE)
assertThat(single, notNullValue())
assertThat(
- RxCallableDeleteOrUpdateMethodBinderProvider.getAll(invocation.context).any {
+ RxCallableDeleteOrUpdateFunctionBinderProvider.getAll(invocation.context).any {
it.matches(single.type)
},
`is`(true)
@@ -959,7 +959,7 @@
val maybe = invocation.processingEnv.requireTypeElement(RxJava2TypeNames.MAYBE)
assertThat(maybe, notNullValue())
assertThat(
- RxCallableDeleteOrUpdateMethodBinderProvider.getAll(invocation.context).any {
+ RxCallableDeleteOrUpdateFunctionBinderProvider.getAll(invocation.context).any {
it.matches(maybe.type)
},
`is`(true)
@@ -974,7 +974,7 @@
invocation.processingEnv.requireTypeElement(RxJava2TypeNames.COMPLETABLE)
assertThat(completable, notNullValue())
assertThat(
- RxCallableDeleteOrUpdateMethodBinderProvider.getAll(invocation.context).any {
+ RxCallableDeleteOrUpdateFunctionBinderProvider.getAll(invocation.context).any {
it.matches(completable.type)
},
`is`(true)
@@ -991,7 +991,7 @@
)
assertThat(future, notNullValue())
assertThat(
- GuavaListenableFutureDeleteOrUpdateMethodBinderProvider(invocation.context)
+ GuavaListenableFutureDeleteOrUpdateFunctionBinderProvider(invocation.context)
.matches(future.type),
`is`(true)
)
@@ -1009,7 +1009,9 @@
val single = invocation.processingEnv.requireTypeElement(rxTypeClassName)
assertThat(single).isNotNull()
assertThat(
- RxCallableInsertOrUpsertMethodBinderProvider.getAll(invocation.context)
+ RxCallableInsertOrUpsertFunctionBinderProvider.getAll(
+ invocation.context
+ )
.any { it.matches(single.type) }
)
.isTrue()
@@ -1027,7 +1029,9 @@
runProcessorTestWithK1(sources = listOf(rxTypeSrc)) { invocation ->
val maybe = invocation.processingEnv.requireTypeElement(rxTypeClassName)
assertThat(
- RxCallableInsertOrUpsertMethodBinderProvider.getAll(invocation.context)
+ RxCallableInsertOrUpsertFunctionBinderProvider.getAll(
+ invocation.context
+ )
.any { it.matches(maybe.type) }
)
.isTrue()
@@ -1045,7 +1049,9 @@
runProcessorTestWithK1(sources = listOf(rxTypeSrc)) { invocation ->
val completable = invocation.processingEnv.requireTypeElement(rxTypeClassName)
assertThat(
- RxCallableInsertOrUpsertMethodBinderProvider.getAll(invocation.context)
+ RxCallableInsertOrUpsertFunctionBinderProvider.getAll(
+ invocation.context
+ )
.any { it.matches(completable.type) }
)
.isTrue()
@@ -1061,7 +1067,7 @@
GuavaUtilConcurrentTypeNames.LISTENABLE_FUTURE
)
assertThat(
- GuavaListenableFutureInsertOrUpsertMethodBinderProvider(invocation.context)
+ GuavaListenableFutureInsertOrUpsertFunctionBinderProvider(invocation.context)
.matches(future.type)
)
.isTrue()
@@ -1427,7 +1433,10 @@
)
val parsedDao = parser.process()
val binder =
- parsedDao.queryMethods.filterIsInstance<ReadQueryMethod>().first().queryResultBinder
+ parsedDao.queryFunctions
+ .filterIsInstance<ReadQueryFunction>()
+ .first()
+ .queryResultBinder
assertThat(binder is Paging3PagingSourceQueryResultBinder).isTrue()
val pagingSourceXRawType: XRawType? =
@@ -1435,8 +1444,8 @@
.findType(PagingTypeNames.PAGING_SOURCE.canonicalName)
?.rawType
val returnedXRawType =
- parsedDao.queryMethods
- .filterIsInstance<ReadQueryMethod>()
+ parsedDao.queryFunctions
+ .filterIsInstance<ReadQueryFunction>()
.first()
.returnType
.rawType
@@ -1490,7 +1499,10 @@
)
val parsedDao = parser.process()
val binder =
- parsedDao.queryMethods.filterIsInstance<ReadQueryMethod>().first().queryResultBinder
+ parsedDao.queryFunctions
+ .filterIsInstance<ReadQueryFunction>()
+ .first()
+ .queryResultBinder
// assert that room correctly binds to ListenableFuturePagingSource instead of
// its supertype PagingSource. ListenableFuturePagingSourceBinderProvider
@@ -1502,8 +1514,8 @@
.findType(PagingTypeNames.LISTENABLE_FUTURE_PAGING_SOURCE.canonicalName)
?.rawType
val returnedXRawType =
- parsedDao.queryMethods
- .filterIsInstance<ReadQueryMethod>()
+ parsedDao.queryFunctions
+ .filterIsInstance<ReadQueryFunction>()
.first()
.returnType
.rawType
@@ -1550,7 +1562,10 @@
)
val parsedDao = parser.process()
val binder =
- parsedDao.queryMethods.filterIsInstance<ReadQueryMethod>().first().queryResultBinder
+ parsedDao.queryFunctions
+ .filterIsInstance<ReadQueryFunction>()
+ .first()
+ .queryResultBinder
assertThat(binder is MultiTypedPagingSourceQueryResultBinder).isTrue()
val rxPagingSourceXRawType: XRawType? =
@@ -1558,8 +1573,8 @@
.findType(PagingTypeNames.RX2_PAGING_SOURCE.canonicalName)
?.rawType
val returnedXRawType =
- parsedDao.queryMethods
- .filterIsInstance<ReadQueryMethod>()
+ parsedDao.queryFunctions
+ .filterIsInstance<ReadQueryFunction>()
.first()
.returnType
.rawType
@@ -1606,7 +1621,10 @@
)
val parsedDao = parser.process()
val binder =
- parsedDao.queryMethods.filterIsInstance<ReadQueryMethod>().first().queryResultBinder
+ parsedDao.queryFunctions
+ .filterIsInstance<ReadQueryFunction>()
+ .first()
+ .queryResultBinder
assertThat(binder is MultiTypedPagingSourceQueryResultBinder).isTrue()
val rxPagingSourceXRawType: XRawType? =
@@ -1614,8 +1632,8 @@
.findType(PagingTypeNames.RX3_PAGING_SOURCE.canonicalName)
?.rawType
val returnedXRawType =
- parsedDao.queryMethods
- .filterIsInstance<ReadQueryMethod>()
+ parsedDao.queryFunctions
+ .filterIsInstance<ReadQueryFunction>()
.first()
.returnType
.rawType
diff --git a/room/room-compiler/src/test/kotlin/androidx/room/solver/query/QueryWriterTest.kt b/room/room-compiler/src/test/kotlin/androidx/room/solver/query/QueryWriterTest.kt
index ad513ea..23c72a0 100644
--- a/room/room-compiler/src/test/kotlin/androidx/room/solver/query/QueryWriterTest.kt
+++ b/room/room-compiler/src/test/kotlin/androidx/room/solver/query/QueryWriterTest.kt
@@ -25,7 +25,7 @@
import androidx.room.compiler.processing.util.Source
import androidx.room.ext.RoomTypeNames.ROOM_SQL_QUERY
import androidx.room.ext.RoomTypeNames.STRING_UTIL
-import androidx.room.processor.QueryMethodProcessor
+import androidx.room.processor.QueryFunctionProcessor
import androidx.room.runProcessorTestWithK1
import androidx.room.testing.context
import androidx.room.writer.QueryWriter
@@ -375,7 +375,7 @@
}
.first { it.second.isNotEmpty() }
val parser =
- QueryMethodProcessor(
+ QueryFunctionProcessor(
baseContext = invocation.context,
containing = owner.type,
executableElement = methods.first()
diff --git a/room/room-compiler/src/test/kotlin/androidx/room/verifier/DatabaseVerifierTest.kt b/room/room-compiler/src/test/kotlin/androidx/room/verifier/DatabaseVerifierTest.kt
index 421fb25..a730267 100644
--- a/room/room-compiler/src/test/kotlin/androidx/room/verifier/DatabaseVerifierTest.kt
+++ b/room/room-compiler/src/test/kotlin/androidx/room/verifier/DatabaseVerifierTest.kt
@@ -399,7 +399,7 @@
type = mock(XType::class.java),
entities = entities,
views = views,
- daoMethods = emptyList(),
+ daoFunctions = emptyList(),
version = -1,
exportSchema = false,
enableForeignKeys = false,
diff --git a/room/room-compiler/src/test/kotlin/androidx/room/vo/DatabaseTest.kt b/room/room-compiler/src/test/kotlin/androidx/room/vo/DatabaseTest.kt
index 536bc08..cc50bc3 100644
--- a/room/room-compiler/src/test/kotlin/androidx/room/vo/DatabaseTest.kt
+++ b/room/room-compiler/src/test/kotlin/androidx/room/vo/DatabaseTest.kt
@@ -67,7 +67,7 @@
)
),
views = emptyList(),
- daoMethods = emptyList(),
+ daoFunctions = emptyList(),
version = 1,
exportSchema = false,
enableForeignKeys = false,
diff --git a/room/room-compiler/src/test/kotlin/androidx/room/writer/DaoKotlinCodeGenTest.kt b/room/room-compiler/src/test/kotlin/androidx/room/writer/DaoKotlinCodeGenTest.kt
index ec8ee0d..55272a9 100644
--- a/room/room-compiler/src/test/kotlin/androidx/room/writer/DaoKotlinCodeGenTest.kt
+++ b/room/room-compiler/src/test/kotlin/androidx/room/writer/DaoKotlinCodeGenTest.kt
@@ -1109,7 +1109,7 @@
}
@Test
- fun transactionMethodAdapter_interface(
+ fun transactionFunctionAdapter_interface(
@TestParameter("disable", "all-compatibility", "all") jvmDefaultMode: String
) {
// For parametrized tests, use method name from reflection
@@ -1181,7 +1181,7 @@
}
@Test
- fun transactionMethodAdapter_abstractClass() {
+ fun transactionFunctionAdapter_abstractClass() {
val src =
Source.kotlin(
"MyDao.kt",
@@ -1236,7 +1236,7 @@
}
@Test
- fun deleteOrUpdateMethodAdapter() {
+ fun deleteOrUpdateFunctionAdapter() {
val src =
Source.kotlin(
"MyDao.kt",
@@ -1274,7 +1274,7 @@
}
@Test
- fun insertOrUpsertMethodAdapter() {
+ fun insertOrUpsertFunctionAdapter() {
val src =
Source.kotlin(
"MyDao.kt",
diff --git a/room/room-compiler/src/test/test-data/kotlinCodeGen/deleteOrUpdateMethodAdapter.kt b/room/room-compiler/src/test/test-data/kotlinCodeGen/deleteOrUpdateFunctionAdapter.kt
similarity index 100%
rename from room/room-compiler/src/test/test-data/kotlinCodeGen/deleteOrUpdateMethodAdapter.kt
rename to room/room-compiler/src/test/test-data/kotlinCodeGen/deleteOrUpdateFunctionAdapter.kt
diff --git a/room/room-compiler/src/test/test-data/kotlinCodeGen/insertOrUpsertMethodAdapter.kt b/room/room-compiler/src/test/test-data/kotlinCodeGen/insertOrUpsertFunctionAdapter.kt
similarity index 100%
rename from room/room-compiler/src/test/test-data/kotlinCodeGen/insertOrUpsertMethodAdapter.kt
rename to room/room-compiler/src/test/test-data/kotlinCodeGen/insertOrUpsertFunctionAdapter.kt
diff --git a/room/room-compiler/src/test/test-data/kotlinCodeGen/transactionMethodAdapter_abstractClass.kt b/room/room-compiler/src/test/test-data/kotlinCodeGen/transactionFunctionAdapter_abstractClass.kt
similarity index 100%
rename from room/room-compiler/src/test/test-data/kotlinCodeGen/transactionMethodAdapter_abstractClass.kt
rename to room/room-compiler/src/test/test-data/kotlinCodeGen/transactionFunctionAdapter_abstractClass.kt
diff --git a/room/room-compiler/src/test/test-data/kotlinCodeGen/transactionMethodAdapter_interface.kt b/room/room-compiler/src/test/test-data/kotlinCodeGen/transactionFunctionAdapter_interface.kt
similarity index 100%
rename from room/room-compiler/src/test/test-data/kotlinCodeGen/transactionMethodAdapter_interface.kt
rename to room/room-compiler/src/test/test-data/kotlinCodeGen/transactionFunctionAdapter_interface.kt
diff --git a/settings.gradle b/settings.gradle
index 2a0e494..ec60c4a 100644
--- a/settings.gradle
+++ b/settings.gradle
@@ -33,7 +33,7 @@
if (agpOverride != null) {
classpath("com.android.settings:com.android.settings.gradle.plugin:$agpOverride")
} else {
- classpath("com.android.settings:com.android.settings.gradle.plugin:8.9.0-alpha01")
+ classpath("com.android.settings:com.android.settings.gradle.plugin:8.9.0-alpha06")
}
// set guava version to be compatible with Depdendency analysis gradle plugin
classpath("com.google.guava:guava:33.3.1-jre")
diff --git a/test/uiautomator/integration-tests/testapp/src/androidTest/java/androidx/test/uiautomator/testapp/UiObject2Test.java b/test/uiautomator/integration-tests/testapp/src/androidTest/java/androidx/test/uiautomator/testapp/UiObject2Test.java
index 4573dd0..65f83a0 100644
--- a/test/uiautomator/integration-tests/testapp/src/androidTest/java/androidx/test/uiautomator/testapp/UiObject2Test.java
+++ b/test/uiautomator/integration-tests/testapp/src/androidTest/java/androidx/test/uiautomator/testapp/UiObject2Test.java
@@ -376,6 +376,7 @@
}
@Test
+ @SdkSuppress(maxSdkVersion = 34) // b/384973122: Failing on SDK 35
public void testGetVisibleCenter() {
launchTestActivity(VisibleBoundsTestActivity.class);
diff --git a/wear/compose/compose-foundation/src/main/java/androidx/wear/compose/foundation/lazy/TransformingLazyColumn.kt b/wear/compose/compose-foundation/src/main/java/androidx/wear/compose/foundation/lazy/TransformingLazyColumn.kt
index bee8429..2c1b95d 100644
--- a/wear/compose/compose-foundation/src/main/java/androidx/wear/compose/foundation/lazy/TransformingLazyColumn.kt
+++ b/wear/compose/compose-foundation/src/main/java/androidx/wear/compose/foundation/lazy/TransformingLazyColumn.kt
@@ -30,6 +30,7 @@
import androidx.compose.foundation.lazy.layout.LazyLayoutIntervalContent
import androidx.compose.foundation.lazy.layout.LazyLayoutItemProvider
import androidx.compose.foundation.lazy.layout.getDefaultLazyLayoutKey
+import androidx.compose.foundation.overscroll
import androidx.compose.runtime.Composable
import androidx.compose.runtime.CompositionLocalProvider
import androidx.compose.runtime.ProvidableCompositionLocal
@@ -228,6 +229,8 @@
reverseScrolling = false
)
val semanticState = remember(state) { TransformingLazyColumnSemanticState(state = state) }
+ // TODO: b/388191915 - Migrate to use rememberOverscrollEffect when updated to 1.8.0.
+ @Suppress("DEPRECATION") val overscrollEffect = ScrollableDefaults.overscrollEffect()
LazyLayout(
itemProvider = itemProviderLambda,
@@ -250,12 +253,14 @@
userScrollEnabled = userScrollEnabled,
reverseScrolling = false,
)
+ .overscroll(overscrollEffect)
.scrollable(
state = state,
reverseDirection = reverseDirection,
enabled = userScrollEnabled,
orientation = Orientation.Vertical,
flingBehavior = flingBehavior,
+ overscrollEffect = overscrollEffect,
),
measurePolicy = measurePolicy
)
diff --git a/wear/compose/compose-material-core/src/main/java/androidx/wear/compose/materialcore/Resources.kt b/wear/compose/compose-material-core/src/main/java/androidx/wear/compose/materialcore/Resources.kt
index f4933a4..441f0c2 100644
--- a/wear/compose/compose-material-core/src/main/java/androidx/wear/compose/materialcore/Resources.kt
+++ b/wear/compose/compose-material-core/src/main/java/androidx/wear/compose/materialcore/Resources.kt
@@ -78,6 +78,6 @@
@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP)
@Composable
public fun isSmallScreen(): Boolean =
- LocalContext.current.resources.configuration.screenWidthDp <= SMALL_SCREEN_WIDTH_DP
+ LocalConfiguration.current.screenWidthDp <= SMALL_SCREEN_WIDTH_DP
@RestrictTo(RestrictTo.Scope.LIBRARY_GROUP) public const val SMALL_SCREEN_WIDTH_DP: Int = 225
diff --git a/wear/compose/compose-material3/api/current.txt b/wear/compose/compose-material3/api/current.txt
index 4326ccb..7e3e1c2 100644
--- a/wear/compose/compose-material3/api/current.txt
+++ b/wear/compose/compose-material3/api/current.txt
@@ -8,7 +8,6 @@
method @androidx.compose.runtime.Composable public void GroupSeparator();
method @androidx.compose.runtime.Composable public androidx.compose.foundation.layout.PaddingValues confirmDismissContentPadding();
method @androidx.compose.runtime.Composable public androidx.compose.foundation.layout.PaddingValues contentPadding();
- method @androidx.compose.runtime.Composable public androidx.compose.foundation.layout.PaddingValues contentPaddingWithEdgeButton(optional float edgeButtonSize);
method public kotlin.jvm.functions.Function1<androidx.compose.foundation.layout.RowScope,kotlin.Unit> getConfirmIcon();
method public kotlin.jvm.functions.Function1<androidx.compose.foundation.layout.RowScope,kotlin.Unit> getDismissIcon();
method public androidx.compose.foundation.layout.Arrangement.Vertical getVerticalArrangement();
@@ -1010,17 +1009,26 @@
}
public final class ScreenScaffoldDefaults {
- method public androidx.compose.foundation.layout.PaddingValues contentPaddingWithEdgeButton(float edgeButtonSize, optional float start, optional float top, optional float end, optional float extraBottom);
+ method @Deprecated public androidx.compose.foundation.layout.PaddingValues contentPaddingWithEdgeButton(float edgeButtonSize, optional float start, optional float top, optional float end, optional float extraBottom);
+ method @androidx.compose.runtime.Composable public androidx.compose.foundation.layout.PaddingValues getContentPadding();
+ method public float getEdgeButtonMinSpacing();
+ method public float getEdgeButtonSpacing();
+ property public final float EdgeButtonMinSpacing;
+ property public final float EdgeButtonSpacing;
+ property @androidx.compose.runtime.Composable public final androidx.compose.foundation.layout.PaddingValues contentPadding;
field public static final androidx.wear.compose.material3.ScreenScaffoldDefaults INSTANCE;
}
public final class ScreenScaffoldKt {
- method @androidx.compose.runtime.Composable public static void ScreenScaffold(androidx.compose.foundation.lazy.LazyListState scrollState, optional androidx.compose.ui.Modifier modifier, optional kotlin.jvm.functions.Function0<kotlin.Unit>? timeText, optional kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit>? scrollIndicator, optional kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit>? edgeButton, kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit> content);
- method @androidx.compose.runtime.Composable public static void ScreenScaffold(androidx.compose.foundation.ScrollState scrollState, optional androidx.compose.ui.Modifier modifier, optional kotlin.jvm.functions.Function0<kotlin.Unit>? timeText, optional kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit>? scrollIndicator, kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit> content);
- method @androidx.compose.runtime.Composable public static void ScreenScaffold(optional androidx.compose.ui.Modifier modifier, optional kotlin.jvm.functions.Function0<kotlin.Unit>? timeText, optional androidx.wear.compose.foundation.ScrollInfoProvider? scrollInfoProvider, optional kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit>? scrollIndicator, kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit> content);
- method @androidx.compose.runtime.Composable public static void ScreenScaffold(androidx.wear.compose.foundation.lazy.ScalingLazyListState scrollState, optional androidx.compose.ui.Modifier modifier, optional kotlin.jvm.functions.Function0<kotlin.Unit>? timeText, optional kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit>? scrollIndicator, optional kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit>? edgeButton, kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit> content);
- method @androidx.compose.runtime.Composable public static void ScreenScaffold(androidx.wear.compose.foundation.lazy.TransformingLazyColumnState scrollState, optional androidx.compose.ui.Modifier modifier, optional kotlin.jvm.functions.Function0<kotlin.Unit>? timeText, optional kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit>? scrollIndicator, optional kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit>? edgeButton, kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit> content);
- method @androidx.compose.runtime.Composable public static void ScreenScaffold(kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit> edgeButton, androidx.wear.compose.foundation.ScrollInfoProvider scrollInfoProvider, optional androidx.compose.ui.Modifier modifier, optional kotlin.jvm.functions.Function0<kotlin.Unit>? timeText, optional kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit>? scrollIndicator, kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit> content);
+ method @androidx.compose.runtime.Composable public static void ScreenScaffold(androidx.compose.foundation.lazy.LazyListState scrollState, optional androidx.compose.ui.Modifier modifier, optional androidx.compose.foundation.layout.PaddingValues contentPadding, optional kotlin.jvm.functions.Function0<kotlin.Unit>? timeText, optional kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit>? scrollIndicator, kotlin.jvm.functions.Function2<? super androidx.compose.foundation.layout.BoxScope,? super androidx.compose.foundation.layout.PaddingValues,kotlin.Unit> content);
+ method @androidx.compose.runtime.Composable public static void ScreenScaffold(androidx.compose.foundation.lazy.LazyListState scrollState, kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit> edgeButton, optional androidx.compose.ui.Modifier modifier, optional androidx.compose.foundation.layout.PaddingValues contentPadding, optional kotlin.jvm.functions.Function0<kotlin.Unit>? timeText, optional kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit>? scrollIndicator, optional float edgeButtonSpacing, kotlin.jvm.functions.Function2<? super androidx.compose.foundation.layout.BoxScope,? super androidx.compose.foundation.layout.PaddingValues,kotlin.Unit> content);
+ method @androidx.compose.runtime.Composable public static void ScreenScaffold(androidx.compose.foundation.ScrollState scrollState, optional androidx.compose.ui.Modifier modifier, optional androidx.compose.foundation.layout.PaddingValues contentPadding, optional kotlin.jvm.functions.Function0<kotlin.Unit>? timeText, optional kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit>? scrollIndicator, kotlin.jvm.functions.Function2<? super androidx.compose.foundation.layout.BoxScope,? super androidx.compose.foundation.layout.PaddingValues,kotlin.Unit> content);
+ method @androidx.compose.runtime.Composable public static void ScreenScaffold(optional androidx.compose.ui.Modifier modifier, optional androidx.wear.compose.foundation.ScrollInfoProvider? scrollInfoProvider, optional androidx.compose.foundation.layout.PaddingValues contentPadding, optional kotlin.jvm.functions.Function0<kotlin.Unit>? timeText, optional kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit>? scrollIndicator, kotlin.jvm.functions.Function2<? super androidx.compose.foundation.layout.BoxScope,? super androidx.compose.foundation.layout.PaddingValues,kotlin.Unit> content);
+ method @androidx.compose.runtime.Composable public static void ScreenScaffold(androidx.wear.compose.foundation.lazy.ScalingLazyListState scrollState, optional androidx.compose.ui.Modifier modifier, optional androidx.compose.foundation.layout.PaddingValues contentPadding, optional kotlin.jvm.functions.Function0<kotlin.Unit>? timeText, optional kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit>? scrollIndicator, kotlin.jvm.functions.Function2<? super androidx.compose.foundation.layout.BoxScope,? super androidx.compose.foundation.layout.PaddingValues,kotlin.Unit> content);
+ method @androidx.compose.runtime.Composable public static void ScreenScaffold(androidx.wear.compose.foundation.lazy.ScalingLazyListState scrollState, kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit> edgeButton, optional androidx.compose.ui.Modifier modifier, optional androidx.compose.foundation.layout.PaddingValues contentPadding, optional kotlin.jvm.functions.Function0<kotlin.Unit>? timeText, optional kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit>? scrollIndicator, optional float edgeButtonSpacing, kotlin.jvm.functions.Function2<? super androidx.compose.foundation.layout.BoxScope,? super androidx.compose.foundation.layout.PaddingValues,kotlin.Unit> content);
+ method @androidx.compose.runtime.Composable public static void ScreenScaffold(androidx.wear.compose.foundation.lazy.TransformingLazyColumnState scrollState, optional androidx.compose.ui.Modifier modifier, optional androidx.compose.foundation.layout.PaddingValues contentPadding, optional kotlin.jvm.functions.Function0<kotlin.Unit>? timeText, optional kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit>? scrollIndicator, kotlin.jvm.functions.Function2<? super androidx.compose.foundation.layout.BoxScope,? super androidx.compose.foundation.layout.PaddingValues,kotlin.Unit> content);
+ method @androidx.compose.runtime.Composable public static void ScreenScaffold(androidx.wear.compose.foundation.lazy.TransformingLazyColumnState scrollState, kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit> edgeButton, optional androidx.compose.ui.Modifier modifier, optional androidx.compose.foundation.layout.PaddingValues contentPadding, optional kotlin.jvm.functions.Function0<kotlin.Unit>? timeText, optional kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit>? scrollIndicator, optional float edgeButtonSpacing, kotlin.jvm.functions.Function2<? super androidx.compose.foundation.layout.BoxScope,? super androidx.compose.foundation.layout.PaddingValues,kotlin.Unit> content);
+ method @androidx.compose.runtime.Composable public static void ScreenScaffold(androidx.wear.compose.foundation.ScrollInfoProvider scrollInfoProvider, kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit> edgeButton, optional androidx.compose.ui.Modifier modifier, optional androidx.compose.foundation.layout.PaddingValues contentPadding, optional kotlin.jvm.functions.Function0<kotlin.Unit>? timeText, optional kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit>? scrollIndicator, optional float edgeButtonSpacing, kotlin.jvm.functions.Function2<? super androidx.compose.foundation.layout.BoxScope,? super androidx.compose.foundation.layout.PaddingValues,kotlin.Unit> content);
}
@androidx.compose.runtime.Immutable @kotlin.jvm.JvmInline public final value class ScreenStage {
diff --git a/wear/compose/compose-material3/api/restricted_current.txt b/wear/compose/compose-material3/api/restricted_current.txt
index 4326ccb..7e3e1c2 100644
--- a/wear/compose/compose-material3/api/restricted_current.txt
+++ b/wear/compose/compose-material3/api/restricted_current.txt
@@ -8,7 +8,6 @@
method @androidx.compose.runtime.Composable public void GroupSeparator();
method @androidx.compose.runtime.Composable public androidx.compose.foundation.layout.PaddingValues confirmDismissContentPadding();
method @androidx.compose.runtime.Composable public androidx.compose.foundation.layout.PaddingValues contentPadding();
- method @androidx.compose.runtime.Composable public androidx.compose.foundation.layout.PaddingValues contentPaddingWithEdgeButton(optional float edgeButtonSize);
method public kotlin.jvm.functions.Function1<androidx.compose.foundation.layout.RowScope,kotlin.Unit> getConfirmIcon();
method public kotlin.jvm.functions.Function1<androidx.compose.foundation.layout.RowScope,kotlin.Unit> getDismissIcon();
method public androidx.compose.foundation.layout.Arrangement.Vertical getVerticalArrangement();
@@ -1010,17 +1009,26 @@
}
public final class ScreenScaffoldDefaults {
- method public androidx.compose.foundation.layout.PaddingValues contentPaddingWithEdgeButton(float edgeButtonSize, optional float start, optional float top, optional float end, optional float extraBottom);
+ method @Deprecated public androidx.compose.foundation.layout.PaddingValues contentPaddingWithEdgeButton(float edgeButtonSize, optional float start, optional float top, optional float end, optional float extraBottom);
+ method @androidx.compose.runtime.Composable public androidx.compose.foundation.layout.PaddingValues getContentPadding();
+ method public float getEdgeButtonMinSpacing();
+ method public float getEdgeButtonSpacing();
+ property public final float EdgeButtonMinSpacing;
+ property public final float EdgeButtonSpacing;
+ property @androidx.compose.runtime.Composable public final androidx.compose.foundation.layout.PaddingValues contentPadding;
field public static final androidx.wear.compose.material3.ScreenScaffoldDefaults INSTANCE;
}
public final class ScreenScaffoldKt {
- method @androidx.compose.runtime.Composable public static void ScreenScaffold(androidx.compose.foundation.lazy.LazyListState scrollState, optional androidx.compose.ui.Modifier modifier, optional kotlin.jvm.functions.Function0<kotlin.Unit>? timeText, optional kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit>? scrollIndicator, optional kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit>? edgeButton, kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit> content);
- method @androidx.compose.runtime.Composable public static void ScreenScaffold(androidx.compose.foundation.ScrollState scrollState, optional androidx.compose.ui.Modifier modifier, optional kotlin.jvm.functions.Function0<kotlin.Unit>? timeText, optional kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit>? scrollIndicator, kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit> content);
- method @androidx.compose.runtime.Composable public static void ScreenScaffold(optional androidx.compose.ui.Modifier modifier, optional kotlin.jvm.functions.Function0<kotlin.Unit>? timeText, optional androidx.wear.compose.foundation.ScrollInfoProvider? scrollInfoProvider, optional kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit>? scrollIndicator, kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit> content);
- method @androidx.compose.runtime.Composable public static void ScreenScaffold(androidx.wear.compose.foundation.lazy.ScalingLazyListState scrollState, optional androidx.compose.ui.Modifier modifier, optional kotlin.jvm.functions.Function0<kotlin.Unit>? timeText, optional kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit>? scrollIndicator, optional kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit>? edgeButton, kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit> content);
- method @androidx.compose.runtime.Composable public static void ScreenScaffold(androidx.wear.compose.foundation.lazy.TransformingLazyColumnState scrollState, optional androidx.compose.ui.Modifier modifier, optional kotlin.jvm.functions.Function0<kotlin.Unit>? timeText, optional kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit>? scrollIndicator, optional kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit>? edgeButton, kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit> content);
- method @androidx.compose.runtime.Composable public static void ScreenScaffold(kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit> edgeButton, androidx.wear.compose.foundation.ScrollInfoProvider scrollInfoProvider, optional androidx.compose.ui.Modifier modifier, optional kotlin.jvm.functions.Function0<kotlin.Unit>? timeText, optional kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit>? scrollIndicator, kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit> content);
+ method @androidx.compose.runtime.Composable public static void ScreenScaffold(androidx.compose.foundation.lazy.LazyListState scrollState, optional androidx.compose.ui.Modifier modifier, optional androidx.compose.foundation.layout.PaddingValues contentPadding, optional kotlin.jvm.functions.Function0<kotlin.Unit>? timeText, optional kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit>? scrollIndicator, kotlin.jvm.functions.Function2<? super androidx.compose.foundation.layout.BoxScope,? super androidx.compose.foundation.layout.PaddingValues,kotlin.Unit> content);
+ method @androidx.compose.runtime.Composable public static void ScreenScaffold(androidx.compose.foundation.lazy.LazyListState scrollState, kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit> edgeButton, optional androidx.compose.ui.Modifier modifier, optional androidx.compose.foundation.layout.PaddingValues contentPadding, optional kotlin.jvm.functions.Function0<kotlin.Unit>? timeText, optional kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit>? scrollIndicator, optional float edgeButtonSpacing, kotlin.jvm.functions.Function2<? super androidx.compose.foundation.layout.BoxScope,? super androidx.compose.foundation.layout.PaddingValues,kotlin.Unit> content);
+ method @androidx.compose.runtime.Composable public static void ScreenScaffold(androidx.compose.foundation.ScrollState scrollState, optional androidx.compose.ui.Modifier modifier, optional androidx.compose.foundation.layout.PaddingValues contentPadding, optional kotlin.jvm.functions.Function0<kotlin.Unit>? timeText, optional kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit>? scrollIndicator, kotlin.jvm.functions.Function2<? super androidx.compose.foundation.layout.BoxScope,? super androidx.compose.foundation.layout.PaddingValues,kotlin.Unit> content);
+ method @androidx.compose.runtime.Composable public static void ScreenScaffold(optional androidx.compose.ui.Modifier modifier, optional androidx.wear.compose.foundation.ScrollInfoProvider? scrollInfoProvider, optional androidx.compose.foundation.layout.PaddingValues contentPadding, optional kotlin.jvm.functions.Function0<kotlin.Unit>? timeText, optional kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit>? scrollIndicator, kotlin.jvm.functions.Function2<? super androidx.compose.foundation.layout.BoxScope,? super androidx.compose.foundation.layout.PaddingValues,kotlin.Unit> content);
+ method @androidx.compose.runtime.Composable public static void ScreenScaffold(androidx.wear.compose.foundation.lazy.ScalingLazyListState scrollState, optional androidx.compose.ui.Modifier modifier, optional androidx.compose.foundation.layout.PaddingValues contentPadding, optional kotlin.jvm.functions.Function0<kotlin.Unit>? timeText, optional kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit>? scrollIndicator, kotlin.jvm.functions.Function2<? super androidx.compose.foundation.layout.BoxScope,? super androidx.compose.foundation.layout.PaddingValues,kotlin.Unit> content);
+ method @androidx.compose.runtime.Composable public static void ScreenScaffold(androidx.wear.compose.foundation.lazy.ScalingLazyListState scrollState, kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit> edgeButton, optional androidx.compose.ui.Modifier modifier, optional androidx.compose.foundation.layout.PaddingValues contentPadding, optional kotlin.jvm.functions.Function0<kotlin.Unit>? timeText, optional kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit>? scrollIndicator, optional float edgeButtonSpacing, kotlin.jvm.functions.Function2<? super androidx.compose.foundation.layout.BoxScope,? super androidx.compose.foundation.layout.PaddingValues,kotlin.Unit> content);
+ method @androidx.compose.runtime.Composable public static void ScreenScaffold(androidx.wear.compose.foundation.lazy.TransformingLazyColumnState scrollState, optional androidx.compose.ui.Modifier modifier, optional androidx.compose.foundation.layout.PaddingValues contentPadding, optional kotlin.jvm.functions.Function0<kotlin.Unit>? timeText, optional kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit>? scrollIndicator, kotlin.jvm.functions.Function2<? super androidx.compose.foundation.layout.BoxScope,? super androidx.compose.foundation.layout.PaddingValues,kotlin.Unit> content);
+ method @androidx.compose.runtime.Composable public static void ScreenScaffold(androidx.wear.compose.foundation.lazy.TransformingLazyColumnState scrollState, kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit> edgeButton, optional androidx.compose.ui.Modifier modifier, optional androidx.compose.foundation.layout.PaddingValues contentPadding, optional kotlin.jvm.functions.Function0<kotlin.Unit>? timeText, optional kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit>? scrollIndicator, optional float edgeButtonSpacing, kotlin.jvm.functions.Function2<? super androidx.compose.foundation.layout.BoxScope,? super androidx.compose.foundation.layout.PaddingValues,kotlin.Unit> content);
+ method @androidx.compose.runtime.Composable public static void ScreenScaffold(androidx.wear.compose.foundation.ScrollInfoProvider scrollInfoProvider, kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit> edgeButton, optional androidx.compose.ui.Modifier modifier, optional androidx.compose.foundation.layout.PaddingValues contentPadding, optional kotlin.jvm.functions.Function0<kotlin.Unit>? timeText, optional kotlin.jvm.functions.Function1<? super androidx.compose.foundation.layout.BoxScope,kotlin.Unit>? scrollIndicator, optional float edgeButtonSpacing, kotlin.jvm.functions.Function2<? super androidx.compose.foundation.layout.BoxScope,? super androidx.compose.foundation.layout.PaddingValues,kotlin.Unit> content);
}
@androidx.compose.runtime.Immutable @kotlin.jvm.JvmInline public final value class ScreenStage {
diff --git a/wear/compose/compose-material3/integration-tests/src/main/java/androidx/wear/compose/material3/demos/EdgeButtonDemo.kt b/wear/compose/compose-material3/integration-tests/src/main/java/androidx/wear/compose/material3/demos/EdgeButtonDemo.kt
index d5cc344..a82e444 100644
--- a/wear/compose/compose-material3/integration-tests/src/main/java/androidx/wear/compose/material3/demos/EdgeButtonDemo.kt
+++ b/wear/compose/compose-material3/integration-tests/src/main/java/androidx/wear/compose/material3/demos/EdgeButtonDemo.kt
@@ -18,6 +18,7 @@
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.PaddingValues
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
@@ -48,7 +49,6 @@
import androidx.wear.compose.material3.EdgeButtonSize
import androidx.wear.compose.material3.RadioButton
import androidx.wear.compose.material3.ScreenScaffold
-import androidx.wear.compose.material3.ScreenScaffoldDefaults
import androidx.wear.compose.material3.Text
import androidx.wear.compose.material3.TextButton
import androidx.wear.compose.material3.TextButtonDefaults
@@ -71,6 +71,7 @@
val state = rememberLazyListState()
ScreenScaffold(
scrollState = state,
+ contentPadding = PaddingValues(horizontal = 10.dp, vertical = 20.dp),
edgeButton = {
EdgeButton(
onClick = {},
@@ -80,19 +81,12 @@
Text(labels[selectedLabel.intValue], color = Color.White)
}
}
- ) {
+ ) { contentPadding ->
LazyColumn(
state = state,
modifier = Modifier.fillMaxSize(),
verticalArrangement = Arrangement.spacedBy(4.dp),
- contentPadding =
- ScreenScaffoldDefaults.contentPaddingWithEdgeButton(
- edgeButtonSize = EdgeButtonSize.Large,
- 10.dp,
- 20.dp,
- 10.dp,
- 10.dp
- ),
+ contentPadding = contentPadding,
horizontalAlignment = Alignment.CenterHorizontally
) {
items(labels.size) {
@@ -126,6 +120,7 @@
val state = rememberScalingLazyListState()
ScreenScaffold(
scrollState = state,
+ contentPadding = PaddingValues(horizontal = 10.dp, vertical = 20.dp),
edgeButton = {
EdgeButton(
onClick = {},
@@ -135,19 +130,12 @@
Text(labels[selectedLabel.intValue], color = Color.White)
}
}
- ) {
+ ) { contentPadding ->
ScalingLazyColumn(
state = state,
modifier = Modifier.fillMaxSize(),
autoCentering = null,
- contentPadding =
- ScreenScaffoldDefaults.contentPaddingWithEdgeButton(
- edgeButtonSize = EdgeButtonSize.Medium,
- 10.dp,
- 20.dp,
- 10.dp,
- 10.dp
- ),
+ contentPadding = contentPadding,
horizontalAlignment = Alignment.CenterHorizontally
) {
items(labels.size) {
@@ -270,6 +258,7 @@
val state = rememberScalingLazyListState()
ScreenScaffold(
scrollState = state,
+ contentPadding = PaddingValues(horizontal = 10.dp, vertical = 20.dp),
edgeButton = {
EdgeButton(
onClick = {},
@@ -293,18 +282,12 @@
}
}
}
- ) {
+ ) { contentPadding ->
ScalingLazyColumn(
state = state,
modifier = Modifier.fillMaxSize(),
autoCentering = null,
- contentPadding =
- ScreenScaffoldDefaults.contentPaddingWithEdgeButton(
- sizes[selectedSize].second,
- 10.dp,
- 20.dp,
- 10.dp
- ),
+ contentPadding = contentPadding,
horizontalAlignment = Alignment.CenterHorizontally
) {
selection(
diff --git a/wear/compose/compose-material3/integration-tests/src/main/java/androidx/wear/compose/material3/demos/WearMaterial3Demos.kt b/wear/compose/compose-material3/integration-tests/src/main/java/androidx/wear/compose/material3/demos/WearMaterial3Demos.kt
index b70eeef..a30a8f5 100644
--- a/wear/compose/compose-material3/integration-tests/src/main/java/androidx/wear/compose/material3/demos/WearMaterial3Demos.kt
+++ b/wear/compose/compose-material3/integration-tests/src/main/java/androidx/wear/compose/material3/demos/WearMaterial3Demos.kt
@@ -31,7 +31,7 @@
import androidx.wear.compose.material3.samples.EdgeSwipeForSwipeToDismiss
import androidx.wear.compose.material3.samples.HorizontalPagerScaffoldSample
import androidx.wear.compose.material3.samples.ListHeaderSample
-import androidx.wear.compose.material3.samples.ScaffoldSample
+import androidx.wear.compose.material3.samples.ScaffoldWithEdgeButtonSample
import androidx.wear.compose.material3.samples.SimpleSwipeToDismissBox
import androidx.wear.compose.material3.samples.StatefulSwipeToDismissBox
import androidx.wear.compose.material3.samples.SwipeToRevealNonAnchoredSample
@@ -74,7 +74,7 @@
Material3DemoCategory(
"Scaffold",
listOf(
- ComposableDemo("Screen Scaffold") { ScaffoldSample() },
+ ComposableDemo("Screen Scaffold") { ScaffoldWithEdgeButtonSample() },
ComposableDemo("Horizontal Pager Scaffold") {
HorizontalPagerScaffoldSample()
},
diff --git a/wear/compose/compose-material3/macrobenchmark-common/src/main/java/androidx/wear/compose/material3/macrobenchmark/common/TransformingLazyColumnBenchmark.kt b/wear/compose/compose-material3/macrobenchmark-common/src/main/java/androidx/wear/compose/material3/macrobenchmark/common/TransformingLazyColumnBenchmark.kt
index ccf678d..bc24b82 100644
--- a/wear/compose/compose-material3/macrobenchmark-common/src/main/java/androidx/wear/compose/material3/macrobenchmark/common/TransformingLazyColumnBenchmark.kt
+++ b/wear/compose/compose-material3/macrobenchmark-common/src/main/java/androidx/wear/compose/material3/macrobenchmark/common/TransformingLazyColumnBenchmark.kt
@@ -20,6 +20,7 @@
import androidx.benchmark.macro.MacrobenchmarkScope
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.BoxScope
+import androidx.compose.foundation.layout.PaddingValues
import androidx.compose.foundation.layout.fillMaxWidth
import androidx.compose.foundation.layout.padding
import androidx.compose.runtime.Composable
@@ -33,10 +34,8 @@
import androidx.wear.compose.foundation.lazy.rememberTransformingLazyColumnState
import androidx.wear.compose.material3.AppScaffold
import androidx.wear.compose.material3.EdgeButton
-import androidx.wear.compose.material3.EdgeButtonSize
import androidx.wear.compose.material3.MaterialTheme
import androidx.wear.compose.material3.ScreenScaffold
-import androidx.wear.compose.material3.ScreenScaffoldDefaults
import androidx.wear.compose.material3.Text
import androidx.wear.compose.material3.lazy.scrollTransform
import kotlinx.coroutines.launch
@@ -50,6 +49,7 @@
AppScaffold {
ScreenScaffold(
state,
+ contentPadding = PaddingValues(horizontal = 10.dp, vertical = 20.dp),
edgeButton = {
EdgeButton(
onClick = { coroutineScope.launch { state.scrollToItem(1) } }
@@ -57,17 +57,10 @@
Text("To top")
}
}
- ) {
+ ) { contentPadding ->
TransformingLazyColumn(
state = state,
- contentPadding =
- ScreenScaffoldDefaults.contentPaddingWithEdgeButton(
- EdgeButtonSize.Small,
- start = 10.dp,
- end = 10.dp,
- top = 20.dp,
- extraBottom = 20.dp
- ),
+ contentPadding = contentPadding,
modifier =
Modifier.background(MaterialTheme.colorScheme.background)
.semantics { contentDescription = CONTENT_DESCRIPTION }
diff --git a/wear/compose/compose-material3/macrobenchmark-common/src/main/java/androidx/wear/compose/material3/macrobenchmark/common/baselineprofile/ScaffoldScreen.kt b/wear/compose/compose-material3/macrobenchmark-common/src/main/java/androidx/wear/compose/material3/macrobenchmark/common/baselineprofile/ScaffoldScreen.kt
index 462a87f..4a2c779 100644
--- a/wear/compose/compose-material3/macrobenchmark-common/src/main/java/androidx/wear/compose/material3/macrobenchmark/common/baselineprofile/ScaffoldScreen.kt
+++ b/wear/compose/compose-material3/macrobenchmark-common/src/main/java/androidx/wear/compose/material3/macrobenchmark/common/baselineprofile/ScaffoldScreen.kt
@@ -19,11 +19,11 @@
import androidx.compose.foundation.layout.BoxScope
import androidx.compose.runtime.Composable
import androidx.wear.compose.material3.macrobenchmark.common.MacrobenchmarkScreen
-import androidx.wear.compose.material3.samples.ScaffoldSample
+import androidx.wear.compose.material3.samples.ScaffoldWithEdgeButtonSample
val ScaffoldScreen =
object : MacrobenchmarkScreen {
override val content: @Composable BoxScope.() -> Unit
- get() = { ScaffoldSample() }
+ get() = { ScaffoldWithEdgeButtonSample() }
}
diff --git a/wear/compose/compose-material3/samples/src/main/java/androidx/wear/compose/material3/samples/AlertDialogSample.kt b/wear/compose/compose-material3/samples/src/main/java/androidx/wear/compose/material3/samples/AlertDialogSample.kt
index 7d0accb..064fe5d 100644
--- a/wear/compose/compose-material3/samples/src/main/java/androidx/wear/compose/material3/samples/AlertDialogSample.kt
+++ b/wear/compose/compose-material3/samples/src/main/java/androidx/wear/compose/material3/samples/AlertDialogSample.kt
@@ -30,6 +30,7 @@
import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
+import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import androidx.wear.compose.material3.AlertDialog
import androidx.wear.compose.material3.AlertDialogDefaults
@@ -39,6 +40,7 @@
import androidx.wear.compose.material3.SwitchButton
import androidx.wear.compose.material3.Text
+@Preview
@Sampled
@Composable
fun AlertDialogWithConfirmAndDismissSample() {
@@ -83,6 +85,7 @@
)
}
+@Preview
@Sampled
@Composable
fun AlertDialogWithEdgeButtonSample() {
@@ -119,6 +122,7 @@
)
}
+@Preview
@Sampled
@Composable
fun AlertDialogWithContentGroupsSample() {
diff --git a/wear/compose/compose-material3/samples/src/main/java/androidx/wear/compose/material3/samples/EdgeButtonSample.kt b/wear/compose/compose-material3/samples/src/main/java/androidx/wear/compose/material3/samples/EdgeButtonSample.kt
index da9e81b..fbf7a8d 100644
--- a/wear/compose/compose-material3/samples/src/main/java/androidx/wear/compose/material3/samples/EdgeButtonSample.kt
+++ b/wear/compose/compose-material3/samples/src/main/java/androidx/wear/compose/material3/samples/EdgeButtonSample.kt
@@ -20,6 +20,7 @@
import androidx.compose.foundation.layout.Arrangement
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.PaddingValues
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.Spacer
import androidx.compose.foundation.layout.fillMaxSize
@@ -39,6 +40,7 @@
import androidx.compose.ui.Modifier
import androidx.compose.ui.platform.LocalConfiguration
import androidx.compose.ui.text.style.TextAlign
+import androidx.compose.ui.tooling.preview.Preview
import androidx.compose.ui.unit.dp
import androidx.wear.compose.foundation.lazy.ScalingLazyColumn
import androidx.wear.compose.foundation.lazy.rememberScalingLazyListState
@@ -48,7 +50,6 @@
import androidx.wear.compose.material3.Icon
import androidx.wear.compose.material3.RadioButton
import androidx.wear.compose.material3.ScreenScaffold
-import androidx.wear.compose.material3.ScreenScaffoldDefaults
import androidx.wear.compose.material3.Text
import androidx.wear.compose.material3.TextButton
import androidx.wear.compose.material3.TextButtonDefaults
@@ -106,6 +107,7 @@
}
}
+@Preview
@Sampled
@Composable
fun EdgeButtonListSample() {
@@ -126,6 +128,7 @@
ScreenScaffold(
scrollState = state,
+ contentPadding = PaddingValues(horizontal = horizontalPadding, vertical = verticalPadding),
edgeButton = {
EdgeButton(
onClick = {},
@@ -143,19 +146,13 @@
Text("Ok")
}
}
- }
- ) {
+ },
+ ) { contentPadding ->
ScalingLazyColumn(
state = state,
modifier = Modifier.fillMaxSize().selectableGroup(),
autoCentering = null,
- contentPadding =
- ScreenScaffoldDefaults.contentPaddingWithEdgeButton(
- edgeButtonSize = EdgeButtonSize.Medium,
- start = horizontalPadding,
- end = horizontalPadding,
- top = verticalPadding,
- ),
+ contentPadding = contentPadding,
horizontalAlignment = Alignment.CenterHorizontally
) {
item { Text("Color") }
diff --git a/wear/compose/compose-material3/samples/src/main/java/androidx/wear/compose/material3/samples/ScaffoldSample.kt b/wear/compose/compose-material3/samples/src/main/java/androidx/wear/compose/material3/samples/ScaffoldSample.kt
index 6db4fb0..49fa6e6 100644
--- a/wear/compose/compose-material3/samples/src/main/java/androidx/wear/compose/material3/samples/ScaffoldSample.kt
+++ b/wear/compose/compose-material3/samples/src/main/java/androidx/wear/compose/material3/samples/ScaffoldSample.kt
@@ -17,16 +17,21 @@
package androidx.wear.compose.material3.samples
import androidx.annotation.Sampled
+import androidx.compose.foundation.layout.PaddingValues
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.runtime.Composable
import androidx.compose.ui.Modifier
+import androidx.compose.ui.tooling.preview.Preview
+import androidx.compose.ui.unit.dp
import androidx.wear.compose.foundation.lazy.ScalingLazyColumn
import androidx.wear.compose.foundation.lazy.rememberScalingLazyListState
import androidx.wear.compose.material3.AppScaffold
import androidx.wear.compose.material3.Button
+import androidx.wear.compose.material3.EdgeButton
import androidx.wear.compose.material3.ScreenScaffold
import androidx.wear.compose.material3.Text
+@Preview
@Sampled
@Composable
fun ScaffoldSample() {
@@ -39,10 +44,54 @@
// For this sample, we will define a single screen inline.
val listState = rememberScalingLazyListState()
- // By default, ScreenScaffold will handle transitions showing/hiding ScrollIndicator
- // and showing/hiding/scrolling away TimeText.
- ScreenScaffold(scrollState = listState) {
- ScalingLazyColumn(state = listState, modifier = Modifier.fillMaxSize()) {
+ // By default, ScreenScaffold will handle transitions showing/hiding ScrollIndicator,
+ // showing/hiding/scrolling away TimeText and optionally hosting the EdgeButton.
+ ScreenScaffold(scrollState = listState, contentPadding = PaddingValues(10.dp)) {
+ contentPadding ->
+ ScalingLazyColumn(
+ state = listState,
+ contentPadding = contentPadding,
+ modifier = Modifier.fillMaxSize()
+ ) {
+ items(10) {
+ Button(
+ onClick = {},
+ label = { Text("Item ${it + 1}") },
+ )
+ }
+ }
+ }
+ }
+}
+
+@Preview
+@Sampled
+@Composable
+fun ScaffoldWithEdgeButtonSample() {
+ // Declare just one [AppScaffold] per app such as in the activity.
+ // [AppScaffold] allows static screen elements (i.e. [TimeText]) to remain visible
+ // during in-app transitions such as swipe-to-dismiss.
+ AppScaffold {
+ // Define the navigation hierarchy within the AppScaffold,
+ // such as using SwipeDismissableNavHost.
+ // For this sample, we will define a single screen inline.
+ val listState = rememberScalingLazyListState()
+
+ // By default, ScreenScaffold will handle transitions showing/hiding ScrollIndicator,
+ // showing/hiding/scrolling away TimeText and optionally hosting the EdgeButton.
+ ScreenScaffold(
+ scrollState = listState,
+ // Define custom spacing between [EdgeButton] and [ScalingLazyColumn].
+ edgeButtonSpacing = 15.dp,
+ edgeButton = { EdgeButton(onClick = {}) { Text("Clear All") } },
+ ) { contentPadding ->
+ ScalingLazyColumn(
+ state = listState,
+ modifier = Modifier.fillMaxSize(),
+ autoCentering = null,
+ // Bottom spacing is derived from [ScreenScaffold.edgeButtonSpacing].
+ contentPadding = contentPadding
+ ) {
items(10) {
Button(
onClick = {},
diff --git a/wear/compose/compose-material3/samples/src/main/java/androidx/wear/compose/material3/samples/TransformingLazyColumnSample.kt b/wear/compose/compose-material3/samples/src/main/java/androidx/wear/compose/material3/samples/TransformingLazyColumnSample.kt
index 0f7005f..20d4a21 100644
--- a/wear/compose/compose-material3/samples/src/main/java/androidx/wear/compose/material3/samples/TransformingLazyColumnSample.kt
+++ b/wear/compose/compose-material3/samples/src/main/java/androidx/wear/compose/material3/samples/TransformingLazyColumnSample.kt
@@ -23,6 +23,7 @@
import androidx.compose.foundation.layout.Arrangement.spacedBy
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.Column
+import androidx.compose.foundation.layout.PaddingValues
import androidx.compose.foundation.layout.Row
import androidx.compose.foundation.layout.fillMaxHeight
import androidx.compose.foundation.layout.fillMaxWidth
@@ -49,11 +50,9 @@
import androidx.wear.compose.foundation.lazy.rememberTransformingLazyColumnState
import androidx.wear.compose.material3.AppScaffold
import androidx.wear.compose.material3.EdgeButton
-import androidx.wear.compose.material3.EdgeButtonSize
import androidx.wear.compose.material3.ListHeader
import androidx.wear.compose.material3.MaterialTheme
import androidx.wear.compose.material3.ScreenScaffold
-import androidx.wear.compose.material3.ScreenScaffoldDefaults
import androidx.wear.compose.material3.Text
import androidx.wear.compose.material3.lazy.scrollTransform
import androidx.wear.compose.material3.lazy.targetMorphingHeight
@@ -61,6 +60,7 @@
import kotlinx.coroutines.launch
@Preview
+@Sampled
@Composable
fun TransformingLazyColumnScrollingSample() {
val state = rememberTransformingLazyColumnState()
@@ -76,6 +76,14 @@
elements.subList(index, elements.count())
}
+ fun rainbowColor(progress: Float): Color {
+ val hue = progress * 360f
+ val saturation = 1f
+ val value = 1f
+
+ return Color(android.graphics.Color.HSVToColor(floatArrayOf(hue, saturation, value)))
+ }
+
AppScaffold {
ScreenScaffold(
state,
@@ -89,18 +97,11 @@
Text("Add item")
}
}
- ) {
+ ) { contentPadding ->
val random = remember { Random }
TransformingLazyColumn(
state = state,
- contentPadding =
- ScreenScaffoldDefaults.contentPaddingWithEdgeButton(
- EdgeButtonSize.Small,
- start = 10.dp,
- end = 10.dp,
- top = 20.dp,
- extraBottom = 20.dp
- ),
+ contentPadding = contentPadding,
modifier = Modifier.background(MaterialTheme.colorScheme.background)
) {
items(elements, key = { it }) {
@@ -185,22 +186,16 @@
AppScaffold {
ScreenScaffold(
state,
+ contentPadding = PaddingValues(horizontal = 10.dp, vertical = 20.dp),
edgeButton = {
EdgeButton(onClick = { coroutineScope.launch { state.scrollToItem(1) } }) {
Text("To top")
}
}
- ) {
+ ) { contentPadding ->
TransformingLazyColumn(
state = state,
- contentPadding =
- ScreenScaffoldDefaults.contentPaddingWithEdgeButton(
- EdgeButtonSize.Small,
- start = 10.dp,
- end = 10.dp,
- top = 20.dp,
- extraBottom = 20.dp
- ),
+ contentPadding = contentPadding,
modifier = Modifier.background(MaterialTheme.colorScheme.background)
) {
item(contentType = "header") {
@@ -249,6 +244,7 @@
AppScaffold {
ScreenScaffold(
state,
+ contentPadding = PaddingValues(horizontal = 10.dp),
edgeButton = {
EdgeButton(
onClick = {
@@ -261,15 +257,10 @@
Text("To top")
}
}
- ) {
+ ) { contentPadding ->
TransformingLazyColumn(
state = state,
- contentPadding =
- ScreenScaffoldDefaults.contentPaddingWithEdgeButton(
- EdgeButtonSize.Medium,
- start = 10.dp,
- end = 10.dp
- ),
+ contentPadding = contentPadding,
modifier = Modifier.background(MaterialTheme.colorScheme.background),
) {
item(contentType = "header") {
@@ -303,11 +294,3 @@
}
}
}
-
-private fun rainbowColor(progress: Float): Color {
- val hue = progress * 360f
- val saturation = 1f
- val value = 1f
-
- return Color(android.graphics.Color.HSVToColor(floatArrayOf(hue, saturation, value)))
-}
diff --git a/wear/compose/compose-material3/src/androidTest/kotlin/androidx/wear/compose/material3/ScaffoldTest.kt b/wear/compose/compose-material3/src/androidTest/kotlin/androidx/wear/compose/material3/ScaffoldTest.kt
index c8d82af..4dfb9d5 100644
--- a/wear/compose/compose-material3/src/androidTest/kotlin/androidx/wear/compose/material3/ScaffoldTest.kt
+++ b/wear/compose/compose-material3/src/androidTest/kotlin/androidx/wear/compose/material3/ScaffoldTest.kt
@@ -20,7 +20,6 @@
import androidx.compose.foundation.background
import androidx.compose.foundation.layout.Box
import androidx.compose.foundation.layout.BoxScope
-import androidx.compose.foundation.layout.BoxWithConstraints
import androidx.compose.foundation.layout.PaddingValues
import androidx.compose.foundation.layout.fillMaxSize
import androidx.compose.foundation.layout.size
@@ -32,6 +31,7 @@
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.graphics.Color
+import androidx.compose.ui.layout.layout
import androidx.compose.ui.platform.LocalDensity
import androidx.compose.ui.platform.testTag
import androidx.compose.ui.test.assertIsDisplayed
@@ -41,6 +41,7 @@
import androidx.compose.ui.test.onNodeWithText
import androidx.compose.ui.test.performTouchInput
import androidx.compose.ui.test.swipeUp
+import androidx.compose.ui.unit.Constraints
import androidx.compose.ui.unit.Dp
import androidx.compose.ui.unit.dp
import androidx.test.filters.SdkSuppress
@@ -129,7 +130,7 @@
val scrollIndicatorColor = Color.Red
rule.setContentWithTheme {
- TestScreenScaffoldWithLazyColumn(
+ TestScreenScaffoldWithTransformingLazyColumn(
scrollIndicatorColor = scrollIndicatorColor,
timeTextColor = Color.Blue
)
@@ -167,7 +168,7 @@
val scrollIndicatorColor = Color.Red
rule.setContentWithTheme {
- TestScreenScaffoldWithLazyColumn(
+ TestScreenScaffoldWithTransformingLazyColumn(
scrollIndicatorColor = scrollIndicatorColor,
timeTextColor = Color.Blue
)
@@ -209,7 +210,7 @@
val timeTextColor = Color.Red
rule.setContentWithTheme {
- TestScreenScaffoldWithLazyColumn(
+ TestScreenScaffoldWithTransformingLazyColumn(
scrollIndicatorColor = Color.Blue,
timeTextColor = timeTextColor
)
@@ -251,7 +252,7 @@
rule.setContentWithTheme {
// Ensure we use the same size no mater where this is run.
Box(Modifier.size(300.dp)) {
- TestScreenScaffoldWithLazyColumn(
+ TestScreenScaffoldWithTransformingLazyColumn(
scrollIndicatorColor = Color.Blue,
timeTextColor = Color.Red
) {
@@ -289,8 +290,9 @@
rule.onNodeWithTag(SCROLL_TAG).performTouchInput { repeat(5) { swipeUp() } }
rule.waitForIdle()
- // Use floats so we can specify a pixel of tolerance.
- assertThat(spaceAvailable.toFloat()).isWithin(1f).of(expectedSpace)
+ // Use floats so we can specify a pixel of tolerance. SLC is less precise with respect to
+ // contentPadding, hence the tolerance is higher.
+ assertThat(spaceAvailable.toFloat()).isWithin(1.5f).of(expectedSpace)
}
@Test
@@ -300,7 +302,7 @@
rule.setContentWithTheme {
// Ensure we use the same size no mater where this is run.
Box(Modifier.size(300.dp)) {
- TestBottomButtonLC {
+ TestBottomButtonLazyColumn {
BoxWithConstraints {
// Check how much space we have for the bottom button
spaceAvailable = constraints.maxHeight
@@ -322,10 +324,10 @@
val screenSize = 300.dp
rule.setContentWithTheme {
- expectedSpace = with(LocalDensity.current) { verticalPadding.toPx() }
+ expectedSpace = with(LocalDensity.current) { verticalPadding.toPx().coerceAtLeast(0f) }
Box(Modifier.size(screenSize)) {
- TestBottomButtonLC(verticalPadding) {
+ TestBottomButtonLazyColumn(verticalPadding) {
// Check how much space we have for the bottom button
BoxWithConstraints { spaceAvailable = constraints.maxHeight }
}
@@ -343,7 +345,7 @@
private fun TestScreenScaffold(
scrollIndicatorColor: Color,
timeTextColor: Color,
- bottomButton: @Composable BoxScope.() -> Unit = {}
+ bottomButton: @Composable BoxScope.() -> Unit
) {
AppScaffold {
val scrollState = rememberScalingLazyListState()
@@ -359,7 +361,44 @@
)
},
timeText = { Box(Modifier.size(20.dp).background(timeTextColor)) },
- edgeButton = bottomButton
+ edgeButton = bottomButton,
+ edgeButtonSpacing = ScreenScaffoldDefaults.EdgeButtonMinSpacing,
+ ) {
+ ScalingLazyColumn(
+ state = scrollState,
+ contentPadding = PaddingValues(horizontal = 0.dp),
+ modifier = Modifier.fillMaxSize().background(Color.Black).testTag(SCROLL_TAG)
+ ) {
+ items(10) {
+ Button(
+ onClick = {},
+ label = { Text("Item ${it + 1}") },
+ )
+ }
+ }
+ }
+ }
+ }
+
+ @Composable
+ private fun TestScreenScaffold(
+ scrollIndicatorColor: Color,
+ timeTextColor: Color,
+ ) {
+ AppScaffold {
+ val scrollState = rememberScalingLazyListState()
+ ScreenScaffold(
+ modifier = Modifier.testTag(TEST_TAG),
+ scrollState = scrollState,
+ scrollIndicator = {
+ Box(
+ modifier =
+ Modifier.size(20.dp)
+ .align(Alignment.CenterEnd)
+ .background(scrollIndicatorColor)
+ )
+ },
+ timeText = { Box(Modifier.size(20.dp).background(timeTextColor)) },
) {
ScalingLazyColumn(
state = scrollState,
@@ -377,10 +416,10 @@
}
@Composable
- private fun TestScreenScaffoldWithLazyColumn(
+ private fun TestScreenScaffoldWithTransformingLazyColumn(
scrollIndicatorColor: Color,
timeTextColor: Color,
- bottomButton: @Composable BoxScope.() -> Unit = {}
+ edgeButton: @Composable BoxScope.() -> Unit = {}
) {
AppScaffold {
val scrollState = rememberTransformingLazyColumnState()
@@ -396,10 +435,12 @@
)
},
timeText = { Box(Modifier.size(20.dp).background(timeTextColor)) },
- edgeButton = bottomButton
+ edgeButton = edgeButton,
+ edgeButtonSpacing = 0.dp,
) {
TransformingLazyColumn(
state = scrollState,
+ contentPadding = it,
modifier = Modifier.fillMaxSize().background(Color.Black).testTag(SCROLL_TAG)
) {
items(10) {
@@ -414,7 +455,7 @@
}
@Composable
- private fun TestBottomButtonLC(
+ private fun TestBottomButtonLazyColumn(
verticalPadding: Dp = 0.dp,
bottomButton: @Composable BoxScope.() -> Unit = {}
) {
@@ -423,7 +464,8 @@
ScreenScaffold(
modifier = Modifier.testTag(TEST_TAG),
scrollState = scrollState,
- edgeButton = bottomButton
+ edgeButton = bottomButton,
+ edgeButtonSpacing = 0.dp,
) {
LazyColumn(
state = scrollState,
@@ -440,6 +482,21 @@
}
}
}
+
+ data class TestConstraintsScope(val constraints: Constraints)
+
+ @Composable
+ fun BoxWithConstraints(onPlaced: TestConstraintsScope.() -> Unit) {
+
+ Box(
+ modifier =
+ Modifier.fillMaxSize().layout { measurable, constraints ->
+ val placeable = measurable.measure(constraints)
+ onPlaced(TestConstraintsScope(constraints))
+ layout(placeable.width, placeable.height) { placeable.place(0, 0) }
+ }
+ )
+ }
}
private const val CONTENT_MESSAGE = "The Content"
diff --git a/wear/compose/compose-material3/src/main/java/androidx/wear/compose/material3/AlertDialog.kt b/wear/compose/compose-material3/src/main/java/androidx/wear/compose/material3/AlertDialog.kt
index e6da9c8..426de7e 100644
--- a/wear/compose/compose-material3/src/main/java/androidx/wear/compose/material3/AlertDialog.kt
+++ b/wear/compose/compose-material3/src/main/java/androidx/wear/compose/material3/AlertDialog.kt
@@ -46,7 +46,6 @@
import androidx.wear.compose.foundation.lazy.ScalingLazyColumn
import androidx.wear.compose.foundation.lazy.ScalingLazyListScope
import androidx.wear.compose.foundation.lazy.rememberScalingLazyListState
-import androidx.wear.compose.material3.AlertDialogDefaults.edgeButtonExtraTopPadding
import androidx.wear.compose.material3.PaddingDefaults.horizontalContentPadding
import androidx.wear.compose.material3.PaddingDefaults.verticalContentPadding
import androidx.wear.compose.material3.internal.Strings
@@ -226,9 +225,8 @@
* @param verticalArrangement The vertical arrangement of the dialog's children. There is a default
* padding between icon, title, and text, which will be added to the spacing specified in this
* [verticalArrangement] parameter.
- * @param contentPadding The padding to apply around the entire dialog's contents. Ensure there is
- * enough space for the [EdgeButton], for example, using
- * [AlertDialogDefaults.contentPaddingWithEdgeButton]
+ * @param contentPadding The padding to apply around the entire dialog's contents. Bottom padding
+ * will be ignored and default spacing for the [EdgeButton] will be used.
* @param properties An optional [DialogProperties] object for configuring the dialog's behavior.
* @param content A slot for additional content, displayed within a scrollable [ScalingLazyColumn].
*/
@@ -242,7 +240,7 @@
icon: @Composable (() -> Unit)? = null,
text: @Composable (() -> Unit)? = null,
verticalArrangement: Arrangement.Vertical = AlertDialogDefaults.VerticalArrangement,
- contentPadding: PaddingValues = AlertDialogDefaults.contentPaddingWithEdgeButton(),
+ contentPadding: PaddingValues = AlertDialogDefaults.contentPadding(),
properties: DialogProperties = DialogProperties(),
content: (ScalingLazyListScope.() -> Unit)? = null
) {
@@ -302,16 +300,28 @@
contentPadding: PaddingValues = AlertDialogDefaults.confirmDismissContentPadding(),
content: (ScalingLazyListScope.() -> Unit)? = null
) {
- AlertDialogImpl(
+ val state = rememberScalingLazyListState(initialCenterItemIndex = 0)
+
+ ScreenScaffold(
+ scrollState = state,
modifier = modifier,
- verticalArrangement = verticalArrangement,
contentPadding = contentPadding,
- title = title,
- icon = icon,
- text = text,
- alertButtonsParams = AlertButtonsParams.ConfirmDismissButtons(confirmButton, dismissButton),
- content = content
- )
+ ) {
+ ScalingLazyColumn(
+ state = state,
+ contentPadding = it,
+ horizontalAlignment = Alignment.CenterHorizontally,
+ verticalArrangement = verticalArrangement,
+ autoCentering = null,
+ modifier = Modifier.fillMaxSize(),
+ ) {
+ alertDialogCommonContent(icon = icon, title = title, text = text, content = content)
+
+ item {
+ ConfirmDismissButtons(confirmButton = confirmButton, dismissButton = dismissButton)
+ }
+ }
+ }
}
/**
@@ -344,16 +354,24 @@
contentPadding: PaddingValues = AlertDialogDefaults.contentPadding(),
content: (ScalingLazyListScope.() -> Unit)? = null
) {
- AlertDialogImpl(
+ val state = rememberScalingLazyListState(initialCenterItemIndex = 0)
+
+ ScreenScaffold(
+ scrollState = state,
modifier = modifier,
- verticalArrangement = verticalArrangement,
contentPadding = contentPadding,
- title = title,
- icon = icon,
- text = text,
- alertButtonsParams = AlertButtonsParams.NoButtons,
- content = content
- )
+ ) {
+ ScalingLazyColumn(
+ state = state,
+ contentPadding = it,
+ horizontalAlignment = Alignment.CenterHorizontally,
+ verticalArrangement = verticalArrangement,
+ autoCentering = null,
+ modifier = Modifier.fillMaxSize(),
+ ) {
+ alertDialogCommonContent(icon, title, text, content)
+ }
+ }
}
/**
@@ -377,9 +395,8 @@
* @param verticalArrangement The vertical arrangement of the dialog's children. There is a default
* padding between icon, title, and text, which will be added to the spacing specified in this
* [verticalArrangement] parameter.
- * @param contentPadding The padding to apply around the entire dialog's contents. Ensure there is
- * enough space for the [EdgeButton], for example, using
- * [AlertDialogDefaults.contentPaddingWithEdgeButton]
+ * @param contentPadding The padding to apply around the entire dialog's contents. Bottom padding
+ * will be ignored and default spacing for the [EdgeButton] will be used.
* @param content A slot for additional content, displayed within a scrollable [ScalingLazyColumn].
*/
@Composable
@@ -390,19 +407,29 @@
icon: @Composable (() -> Unit)? = null,
text: @Composable (() -> Unit)? = null,
verticalArrangement: Arrangement.Vertical = AlertDialogDefaults.VerticalArrangement,
- contentPadding: PaddingValues = AlertDialogDefaults.contentPaddingWithEdgeButton(),
+ contentPadding: PaddingValues = AlertDialogDefaults.contentPadding(),
content: (ScalingLazyListScope.() -> Unit)? = null
) {
- AlertDialogImpl(
+ val state = rememberScalingLazyListState(initialCenterItemIndex = 0)
+
+ ScreenScaffold(
+ scrollState = state,
+ edgeButton = edgeButton,
modifier = modifier,
- verticalArrangement = verticalArrangement,
contentPadding = contentPadding,
- title = title,
- icon = icon,
- text = text,
- alertButtonsParams = AlertButtonsParams.EdgeButton(edgeButton),
- content = content
- )
+ edgeButtonSpacing = AlertEdgeButtonSpacing,
+ ) {
+ ScalingLazyColumn(
+ state = state,
+ contentPadding = it,
+ horizontalAlignment = Alignment.CenterHorizontally,
+ verticalArrangement = verticalArrangement,
+ autoCentering = null,
+ modifier = Modifier.fillMaxSize(),
+ ) {
+ alertDialogCommonContent(icon, title, text, content)
+ }
+ }
}
/** Contains the default values used by [AlertDialog] */
@@ -510,26 +537,6 @@
}
/**
- * The padding to apply around the content for the [AlertDialog] variation with a bottom button.
- * If you need to configure custom paddings, consider using
- * [ScreenScaffoldDefaults.contentPaddingWithEdgeButton]
- */
- @Composable
- public fun contentPaddingWithEdgeButton(
- edgeButtonSize: EdgeButtonSize = EdgeButtonSize.Medium
- ): PaddingValues {
- val topPadding = verticalContentPadding()
- val horizontalPadding = horizontalContentPadding()
- return ScreenScaffoldDefaults.contentPaddingWithEdgeButton(
- edgeButtonSize,
- top = topPadding,
- start = horizontalPadding,
- end = horizontalPadding,
- extraBottom = edgeButtonExtraTopPadding
- )
- }
-
- /**
* The padding to apply around the content for the [AlertDialog] variation with a stack of
* options and no buttons at the end.
*/
@@ -582,61 +589,22 @@
internal val cancelButtonPadding = 1.dp
}
-@Composable
-private fun AlertDialogImpl(
- modifier: Modifier = Modifier,
- verticalArrangement: Arrangement.Vertical,
- contentPadding: PaddingValues,
+private fun ScalingLazyListScope.alertDialogCommonContent(
+ icon: @Composable (() -> Unit)? = null,
title: @Composable () -> Unit,
- icon: @Composable (() -> Unit)?,
text: @Composable (() -> Unit)? = null,
- alertButtonsParams: AlertButtonsParams,
- content: (ScalingLazyListScope.() -> Unit)?
+ content: (ScalingLazyListScope.() -> Unit)? = null
) {
- val state = rememberScalingLazyListState(initialCenterItemIndex = 0)
- ScreenScaffold(
- scrollState = state,
- modifier = modifier,
- edgeButton =
- if (alertButtonsParams is AlertButtonsParams.EdgeButton) {
- {
- Box(
- Modifier.padding(top = edgeButtonExtraTopPadding),
- content = alertButtonsParams.edgeButton
- )
- }
- } else null
- ) {
- ScalingLazyColumn(
- state = state,
- contentPadding = contentPadding,
- horizontalAlignment = Alignment.CenterHorizontally,
- verticalArrangement = verticalArrangement,
- autoCentering = null,
- modifier = Modifier.fillMaxSize(),
- ) {
- if (icon != null) {
- item { IconAlert(icon) }
- }
- item { Title(title) }
- if (text != null) {
- item { TextMessage(text) }
- }
- if (content != null) {
- item { Spacer(Modifier.height(ContentTopSpacing)) }
- content()
- }
-
- when (alertButtonsParams) {
- is AlertButtonsParams.ConfirmDismissButtons ->
- item { ConfirmDismissButtons(alertButtonsParams) }
- is AlertButtonsParams.EdgeButton ->
- if (content == null) {
- item { Spacer(Modifier.height(BottomButtonSpacing)) }
- }
- is AlertButtonsParams.NoButtons -> Unit
- }
- }
+ if (icon != null) {
+ item { IconAlert(icon) }
+ }
+ item { Title(title) }
+ if (text != null) {
+ item { TextMessage(text) }
+ }
+ if (content != null) {
+ item { Spacer(Modifier.height(ContentTopSpacing)) }
+ content()
}
}
@@ -667,7 +635,10 @@
}
@Composable
-private fun ConfirmDismissButtons(alertButtonsParams: AlertButtonsParams.ConfirmDismissButtons) {
+private fun ConfirmDismissButtons(
+ confirmButton: @Composable RowScope.() -> Unit,
+ dismissButton: @Composable RowScope.() -> Unit
+) {
Column {
Spacer(modifier = Modifier.height(ConfirmDismissButtonsTopSpacing))
Row(
@@ -675,12 +646,12 @@
verticalAlignment = Alignment.CenterVertically
) {
Spacer(modifier = Modifier.width(6.dp))
- alertButtonsParams.dismissButton(this)
+ dismissButton(this)
Spacer(
modifier =
Modifier.width(screenWidthDp().dp * ConfirmDismissBetweenButtonsPaddingFraction)
)
- alertButtonsParams.confirmButton(this)
+ confirmButton(this)
Spacer(modifier = Modifier.width(2.dp))
}
Spacer(
@@ -709,20 +680,8 @@
}
}
-private sealed interface AlertButtonsParams {
- object NoButtons : AlertButtonsParams
-
- class EdgeButton(
- val edgeButton: @Composable BoxScope.() -> Unit,
- ) : AlertButtonsParams
-
- class ConfirmDismissButtons(
- val confirmButton: @Composable RowScope.() -> Unit,
- val dismissButton: @Composable RowScope.() -> Unit
- ) : AlertButtonsParams
-}
-
internal val AlertIconBottomSpacing = 4.dp
+internal val AlertEdgeButtonSpacing = 4.dp
internal val AlertTextMessageTopSpacing = 8.dp
internal val ConfirmDismissButtonsTopSpacing = 12.dp
internal const val ConfirmDismissButtonsBottomSpacingFraction = 0.045f
diff --git a/wear/compose/compose-material3/src/main/java/androidx/wear/compose/material3/Button.kt b/wear/compose/compose-material3/src/main/java/androidx/wear/compose/material3/Button.kt
index 7ef944f2..5a3f11e 100644
--- a/wear/compose/compose-material3/src/main/java/androidx/wear/compose/material3/Button.kt
+++ b/wear/compose/compose-material3/src/main/java/androidx/wear/compose/material3/Button.kt
@@ -1442,13 +1442,13 @@
bottom = ButtonVerticalPadding
)
- /** The size of the icon when used with text inside a "[CompactButton]. */
+ /** The recommended icon size when used in [CompactButton]s containing both icon and text. */
public val ExtraSmallIconSize: Dp = CompactButtonTokens.IconSize
- /** The icon size for use with a CompactButton that has icon-only content. */
+ /** The recommended icon size when used in [CompactButton]s containing icon-only content. */
public val SmallIconSize: Dp = CompactButtonTokens.IconOnlyIconSize
- /** The default size of the icon when used inside a [Button]. */
+ /** The recommended default size for icons when used inside a [Button]. */
public val IconSize: Dp = FilledButtonTokens.IconSize
/** The recommended icon size when used in [Button]s for icons such as an app icon */
@@ -1494,7 +1494,7 @@
/**
* The default size of the spacing between an icon and a text when they are used inside a
- * [Button].
+ * [Button] or [CompactButton].
*/
public val IconSpacing: Dp = 6.dp
diff --git a/wear/compose/compose-material3/src/main/java/androidx/wear/compose/material3/EdgeButton.kt b/wear/compose/compose-material3/src/main/java/androidx/wear/compose/material3/EdgeButton.kt
index 6a7f6d8..c24dbc95 100644
--- a/wear/compose/compose-material3/src/main/java/androidx/wear/compose/material3/EdgeButton.kt
+++ b/wear/compose/compose-material3/src/main/java/androidx/wear/compose/material3/EdgeButton.kt
@@ -49,6 +49,8 @@
import androidx.compose.ui.graphics.TransformOrigin
import androidx.compose.ui.graphics.graphicsLayer
import androidx.compose.ui.layout.ContentScale
+import androidx.compose.ui.layout.IntrinsicMeasurable
+import androidx.compose.ui.layout.IntrinsicMeasureScope
import androidx.compose.ui.layout.Measurable
import androidx.compose.ui.layout.MeasureResult
import androidx.compose.ui.layout.MeasureScope
@@ -165,7 +167,7 @@
horizontalArrangement = Arrangement.Center,
modifier =
modifier
- .padding(vertical = VERTICAL_PADDING)
+ .padding(vertical = EdgeButtonVerticalPadding)
.layout { measurable, constraints ->
// Compute the actual size of the button, and save it for later.
// We take the max width available, and the height is determined by the
@@ -280,9 +282,11 @@
*/
@JvmInline
public value class EdgeButtonSize internal constructor(internal val maximumHeight: Dp) {
+ /** Size of the Edge button surrounded by default paddings. */
internal fun maximumHeightPlusPadding() = maximumHeight + VERTICAL_PADDING * 2
- internal fun verticalPadding() =
+ /** Inner padding inside [EdgeButton]. */
+ internal fun verticalContentPadding() =
when (this) {
ExtraSmall -> Pair(10.dp, 12.dp)
Small -> Pair(8.dp, 12.dp)
@@ -361,7 +365,7 @@
internal class ShapeHelper(private val density: Density) {
private val extraSmallHeightPx =
with(density) { EdgeButtonSize.ExtraSmall.maximumHeight.toPx() }
- private val bottomPaddingPx = with(density) { VERTICAL_PADDING.toPx() }
+ private val bottomPaddingPx = with(density) { EdgeButtonVerticalPadding.toPx() }
private val extraSmallEllipsisHeightPx = with(density) { EXTRA_SMALL_ELLIPSIS_HEIGHT.toPx() }
private val targetSidePadding = with(density) { TARGET_SIDE_PADDING.toPx() }
@@ -504,7 +508,7 @@
val scale = (wrapperWidth.toFloat() / placeable.width.coerceAtLeast(1)).coerceAtMost(1f)
- val verticalPadding = buttonSize.verticalPadding()
+ val verticalPadding = buttonSize.verticalContentPadding()
val topPadding = verticalPadding.top().roundToPx()
val bottomPadding = verticalPadding.bottom().roundToPx()
@@ -528,8 +532,16 @@
}
}
}
+
+ override fun IntrinsicMeasureScope.maxIntrinsicHeight(
+ measurable: IntrinsicMeasurable,
+ width: Int
+ ): Int = buttonSize.maximumHeightPlusPadding().roundToPx()
}
+// Padding around the Edge Button on it's top and bottom.
+internal val EdgeButtonVerticalPadding = 3.dp
+
// Syntactic sugar for Pair<Dp, Dp> when used to extra values for top and bottom vertical padding.
private fun Pair<Dp, Dp>.top() = first
diff --git a/wear/compose/compose-material3/src/main/java/androidx/wear/compose/material3/ScreenScaffold.kt b/wear/compose/compose-material3/src/main/java/androidx/wear/compose/material3/ScreenScaffold.kt
index cceea5d..cc231dd 100644
--- a/wear/compose/compose-material3/src/main/java/androidx/wear/compose/material3/ScreenScaffold.kt
+++ b/wear/compose/compose-material3/src/main/java/androidx/wear/compose/material3/ScreenScaffold.kt
@@ -24,8 +24,11 @@
import androidx.compose.foundation.lazy.LazyListState
import androidx.compose.runtime.Composable
import androidx.compose.runtime.DisposableEffect
+import androidx.compose.runtime.getValue
import androidx.compose.runtime.key
+import androidx.compose.runtime.mutableStateOf
import androidx.compose.runtime.remember
+import androidx.compose.runtime.setValue
import androidx.compose.ui.Alignment
import androidx.compose.ui.Modifier
import androidx.compose.ui.layout.Measurable
@@ -34,9 +37,11 @@
import androidx.compose.ui.node.LayoutModifierNode
import androidx.compose.ui.node.ModifierNodeElement
import androidx.compose.ui.platform.InspectorInfo
+import androidx.compose.ui.platform.LocalDensity
import androidx.compose.ui.unit.Constraints
import androidx.compose.ui.unit.Dp
import androidx.compose.ui.unit.IntOffset
+import androidx.compose.ui.unit.coerceAtLeast
import androidx.compose.ui.unit.dp
import androidx.wear.compose.foundation.ActiveFocusListener
import androidx.wear.compose.foundation.ScrollInfoProvider
@@ -64,50 +69,104 @@
*
* Example of using AppScaffold and ScreenScaffold:
*
- * @sample androidx.wear.compose.material3.samples.ScaffoldSample
+ * @sample androidx.wear.compose.material3.samples.ScaffoldWithEdgeButtonSample
* @param scrollState The scroll state for [ScalingLazyColumn], used to drive screen transitions
* such as [TimeText] scroll away and showing/hiding [ScrollIndicator].
+ * @param edgeButton Slot for an [EdgeButton] that takes the available space below a scrolling list.
+ * It will scale up and fade in when the user scrolls to the end of the list, and scale down and
+ * fade out as the user scrolls up.
* @param modifier The modifier for the screen scaffold.
+ * @param contentPadding The padding to apply around the entire content. This contentPadding is then
+ * received by the [content] and should be consumed by using [Modifier.padding] or contentPadding
+ * parameter of the lazy lists. The bottom padding value is always ignored because we instead use
+ * [edgeButtonSpacing] to specify the gap between edge button and content - and the [EdgeButton]
+ * hugs the bottom of the screen.
* @param timeText Time text (both time and potentially status message) for this screen, if
* different to the time text at the [AppScaffold] level. When null, the time text from the
* [AppScaffold] is displayed for this screen.
* @param scrollIndicator The [ScrollIndicator] to display on this screen, which is expected to be
* aligned to Center-End. It is recommended to use the Material3 [ScrollIndicator] which is
* provided by default. No scroll indicator is displayed if null is passed.
- * @param edgeButton Optional slot for a [EdgeButton] that takes the available space below a
- * scrolling list. It will scale up and fade in when the user scrolls to the end of the list, and
- * scale down and fade out as the user scrolls up.
- * @param content The body content for this screen.
+ * @param edgeButtonSpacing The space between [EdgeButton] and the list content.
+ * @param content The body content for this screen. The lambda receives a [PaddingValues] that
+ * should be applied to the content root via [Modifier.padding] or contentPadding parameter when
+ * used with lists to properly offset the [EdgeButton].
+ */
+@Composable
+public fun ScreenScaffold(
+ scrollState: ScalingLazyListState,
+ edgeButton: @Composable BoxScope.() -> Unit,
+ modifier: Modifier = Modifier,
+ contentPadding: PaddingValues = ScreenScaffoldDefaults.contentPadding,
+ timeText: (@Composable () -> Unit)? = null,
+ scrollIndicator: (@Composable BoxScope.() -> Unit)? = {
+ ScrollIndicator(scrollState, modifier = Modifier.align(Alignment.CenterEnd))
+ },
+ edgeButtonSpacing: Dp = ScreenScaffoldDefaults.EdgeButtonSpacing,
+ content: @Composable BoxScope.(PaddingValues) -> Unit,
+): Unit =
+ ScreenScaffold(
+ edgeButton = edgeButton,
+ scrollInfoProvider = ScrollInfoProvider(scrollState),
+ modifier = modifier,
+ contentPadding = contentPadding,
+ edgeButtonSpacing = edgeButtonSpacing,
+ timeText = timeText,
+ scrollIndicator = scrollIndicator,
+ content = content
+ )
+
+/**
+ * [ScreenScaffold] is one of the Wear Material3 scaffold components.
+ *
+ * The scaffold components [AppScaffold] and [ScreenScaffold] lay out the structure of a screen and
+ * coordinate transitions of the [ScrollIndicator] and [TimeText] components. [AppScaffold] should
+ * be at the top of the composition (because it provides [ScaffoldState] and layers [TimeText] on
+ * top of all other content) and [ScreenScaffold] should be part of [AppScaffold]'s content. When
+ * used in conjunction with SwipeDismissableNavHost, [AppScaffold] remains at the top of the
+ * composition, whilst [ScreenScaffold] will be placed for each individual composable route.
+ *
+ * [ScreenScaffold] displays the [ScrollIndicator] at the center-end of the screen by default and
+ * coordinates showing/hiding [TimeText] and [ScrollIndicator] according to [scrollState].
+ *
+ * Example of using AppScaffold and ScreenScaffold:
+ *
+ * @sample androidx.wear.compose.material3.samples.ScaffoldSample
+ * @param scrollState The scroll state for [ScalingLazyColumn], used to drive screen transitions
+ * such as [TimeText] scroll away and showing/hiding [ScrollIndicator].
+ * @param modifier The modifier for the screen scaffold.
+ * @param contentPadding The padding to apply around the entire content. This contentPadding is then
+ * received by the [content] and should be consumed by using [Modifier.padding] or contentPadding
+ * parameter of the lazy lists.
+ * @param timeText Time text (both time and potentially status message) for this screen, if
+ * different to the time text at the [AppScaffold] level. When null, the time text from the
+ * [AppScaffold] is displayed for this screen.
+ * @param scrollIndicator The [ScrollIndicator] to display on this screen, which is expected to be
+ * aligned to Center-End. It is recommended to use the Material3 [ScrollIndicator] which is
+ * provided by default. No scroll indicator is displayed if null is passed.
+ * @param content The body content for this screen. The lambda receives a [PaddingValues] that
+ * should be applied to the content root via [Modifier.padding] or contentPadding parameter when
+ * used with lists to properly offset the [EdgeButton].
*/
@Composable
public fun ScreenScaffold(
scrollState: ScalingLazyListState,
modifier: Modifier = Modifier,
+ contentPadding: PaddingValues = ScreenScaffoldDefaults.contentPadding,
timeText: (@Composable () -> Unit)? = null,
scrollIndicator: (@Composable BoxScope.() -> Unit)? = {
ScrollIndicator(scrollState, modifier = Modifier.align(Alignment.CenterEnd))
},
- edgeButton: (@Composable BoxScope.() -> Unit)? = null,
- content: @Composable BoxScope.() -> Unit,
+ content: @Composable BoxScope.(PaddingValues) -> Unit,
): Unit =
- if (edgeButton != null) {
- ScreenScaffold(
- edgeButton,
- ScrollInfoProvider(scrollState),
- modifier,
- timeText,
- scrollIndicator,
- content
- )
- } else {
- ScreenScaffold(
- modifier,
- timeText,
- ScrollInfoProvider(scrollState),
- scrollIndicator,
- content
- )
- }
+ ScreenScaffold(
+ modifier = modifier,
+ contentPadding = contentPadding,
+ timeText = timeText,
+ scrollInfoProvider = ScrollInfoProvider(scrollState),
+ scrollIndicator = scrollIndicator,
+ content = content
+ )
/**
* [ScreenScaffold] is one of the Wear Material3 scaffold components.
@@ -127,6 +186,72 @@
*
* Example of using AppScaffold and ScreenScaffold:
*
+ * @sample androidx.wear.compose.material3.samples.ScaffoldWithEdgeButtonSample
+ *
+ * Example of using ScreenScaffold with a [EdgeButton]:
+ *
+ * @sample androidx.wear.compose.material3.samples.EdgeButtonListSample
+ * @param scrollState The scroll state for [TransformingLazyColumn], used to drive screen
+ * transitions such as [TimeText] scroll away and showing/hiding [ScrollIndicator].
+ * @param edgeButton Slot for an [EdgeButton] that takes the available space below a scrolling list.
+ * It will scale up and fade in when the user scrolls to the end of the list, and scale down and
+ * fade out as the user scrolls up.
+ * @param modifier The modifier for the screen scaffold.
+ * @param contentPadding The padding to apply around the entire content. This contentPadding is then
+ * received by the [content] and should be consumed by using [Modifier.padding] or contentPadding
+ * parameter of the lazy lists. The bottom padding value is always ignored because we instead use
+ * [edgeButtonSpacing] to specify the gap between edge button and content - and the [EdgeButton]
+ * hugs the bottom of the screen.
+ * @param timeText Time text (both time and potentially status message) for this screen, if
+ * different to the time text at the [AppScaffold] level. When null, the time text from the
+ * [AppScaffold] is displayed for this screen.
+ * @param scrollIndicator The [ScrollIndicator] to display on this screen, which is expected to be
+ * aligned to Center-End. It is recommended to use the Material3 [ScrollIndicator] which is
+ * provided by default. No scroll indicator is displayed if null is passed.
+ * @param edgeButtonSpacing The space between [EdgeButton] and the list content.
+ * @param content The body content for this screen. The lambda receives a [PaddingValues] that
+ * should be applied to the content root via [Modifier.padding] or contentPadding parameter when
+ * used with lists to properly offset the [EdgeButton].
+ */
+@Composable
+public fun ScreenScaffold(
+ scrollState: TransformingLazyColumnState,
+ edgeButton: @Composable BoxScope.() -> Unit,
+ modifier: Modifier = Modifier,
+ contentPadding: PaddingValues = ScreenScaffoldDefaults.contentPadding,
+ timeText: (@Composable () -> Unit)? = null,
+ scrollIndicator: (@Composable BoxScope.() -> Unit)? = {
+ ScrollIndicator(scrollState, modifier = Modifier.align(Alignment.CenterEnd))
+ },
+ edgeButtonSpacing: Dp = ScreenScaffoldDefaults.EdgeButtonSpacing,
+ content: @Composable BoxScope.(PaddingValues) -> Unit,
+): Unit =
+ ScreenScaffold(
+ scrollInfoProvider = ScrollInfoProvider(scrollState),
+ edgeButton = edgeButton,
+ modifier = modifier,
+ contentPadding = contentPadding,
+ timeText = timeText,
+ scrollIndicator = scrollIndicator,
+ edgeButtonSpacing = edgeButtonSpacing,
+ content = content
+ )
+
+/**
+ * [ScreenScaffold] is one of the Wear Material3 scaffold components.
+ *
+ * The scaffold components [AppScaffold] and [ScreenScaffold] lay out the structure of a screen and
+ * coordinate transitions of the [ScrollIndicator] and [TimeText] components. [AppScaffold] should
+ * be at the top of the composition (because it provides [ScaffoldState] and layers [TimeText] on
+ * top of all other content) and [ScreenScaffold] should be part of [AppScaffold]'s content. When
+ * used in conjunction with SwipeDismissableNavHost, [AppScaffold] remains at the top of the
+ * composition, whilst [ScreenScaffold] will be placed for each individual composable route.
+ *
+ * [ScreenScaffold] displays the [ScrollIndicator] at the center-end of the screen by default and
+ * coordinates showing/hiding [TimeText] and [ScrollIndicator] according to [scrollState].
+ *
+ * Example of using AppScaffold and ScreenScaffold:
+ *
* @sample androidx.wear.compose.material3.samples.ScaffoldSample
*
* Example of using ScreenScaffold with a [EdgeButton]:
@@ -135,46 +260,38 @@
* @param scrollState The scroll state for [TransformingLazyColumn], used to drive screen
* transitions such as [TimeText] scroll away and showing/hiding [ScrollIndicator].
* @param modifier The modifier for the screen scaffold.
+ * @param contentPadding The padding to apply around the entire content. This contentPadding is then
+ * received by the [content] and should be consumed by using [Modifier.padding] or contentPadding
+ * parameter of the lazy lists.
* @param timeText Time text (both time and potentially status message) for this screen, if
* different to the time text at the [AppScaffold] level. When null, the time text from the
* [AppScaffold] is displayed for this screen.
* @param scrollIndicator The [ScrollIndicator] to display on this screen, which is expected to be
* aligned to Center-End. It is recommended to use the Material3 [ScrollIndicator] which is
* provided by default. No scroll indicator is displayed if null is passed.
- * @param edgeButton Optional slot for a [EdgeButton] that takes the available space below a
- * scrolling list. It will scale up and fade in when the user scrolls to the end of the list, and
- * scale down and fade out as the user scrolls up.
- * @param content The body content for this screen.
+ * @param content The body content for this screen. The lambda receives a [PaddingValues] that
+ * should be applied to the content root via [Modifier.padding] or contentPadding parameter when
+ * used with lists.
*/
@Composable
public fun ScreenScaffold(
scrollState: TransformingLazyColumnState,
modifier: Modifier = Modifier,
+ contentPadding: PaddingValues = ScreenScaffoldDefaults.contentPadding,
timeText: (@Composable () -> Unit)? = null,
scrollIndicator: (@Composable BoxScope.() -> Unit)? = {
ScrollIndicator(scrollState, modifier = Modifier.align(Alignment.CenterEnd))
},
- edgeButton: (@Composable BoxScope.() -> Unit)? = null,
- content: @Composable BoxScope.() -> Unit,
+ content: @Composable BoxScope.(PaddingValues) -> Unit,
): Unit =
- if (edgeButton != null) {
- ScreenScaffold(
- edgeButton,
- ScrollInfoProvider(scrollState),
- modifier,
- timeText,
- scrollIndicator,
- content
- )
- } else {
- ScreenScaffold(
- modifier,
- timeText,
- ScrollInfoProvider(scrollState),
- scrollIndicator,
- content
- )
- }
+ ScreenScaffold(
+ scrollInfoProvider = ScrollInfoProvider(scrollState),
+ modifier = modifier,
+ contentPadding = contentPadding,
+ timeText = timeText,
+ scrollIndicator = scrollIndicator,
+ content = content
+ )
/**
* [ScreenScaffold] is one of the Wear Material3 scaffold components.
@@ -194,50 +311,104 @@
*
* Example of using AppScaffold and ScreenScaffold:
*
- * @sample androidx.wear.compose.material3.samples.ScaffoldSample
+ * @sample androidx.wear.compose.material3.samples.ScaffoldWithEdgeButtonSample
* @param scrollState The scroll state for [androidx.compose.foundation.lazy.LazyColumn], used to
* drive screen transitions such as [TimeText] scroll away and showing/hiding [ScrollIndicator].
+ * @param edgeButton Slot for an [EdgeButton] that takes the available space below a scrolling list.
+ * It will scale up and fade in when the user scrolls to the end of the list, and scale down and
+ * fade out as the user scrolls up.
* @param modifier The modifier for the screen scaffold.
+ * @param contentPadding The padding to apply around the entire content. This contentPadding is then
+ * received by the [content] and should be consumed by using [Modifier.padding] or contentPadding
+ * parameter of the lazy lists. The bottom padding value is always ignored because we instead use
+ * [edgeButtonSpacing] to specify the gap between edge button and content - and the [EdgeButton]
+ * hugs the bottom of the screen.
* @param timeText Time text (both time and potentially status message) for this screen, if
* different to the time text at the [AppScaffold] level. When null, the time text from the
* [AppScaffold] is displayed for this screen.
* @param scrollIndicator The [ScrollIndicator] to display on this screen, which is expected to be
* aligned to Center-End. It is recommended to use the Material3 [ScrollIndicator] which is
* provided by default. No scroll indicator is displayed if null is passed.
- * @param edgeButton Optional slot for a [EdgeButton] that takes the available space below a
- * scrolling list. It will scale up and fade in when the user scrolls to the end of the list, and
- * scale down and fade out as the user scrolls up.
- * @param content The body content for this screen.
+ * @param edgeButtonSpacing The space between [EdgeButton] and the list content.
+ * @param content The body content for this screen. The lambda receives a [PaddingValues] that
+ * should be applied to the content root via [Modifier.padding] or contentPadding parameter when
+ * used with lists to properly offset the [EdgeButton].
+ */
+@Composable
+public fun ScreenScaffold(
+ scrollState: LazyListState,
+ edgeButton: @Composable BoxScope.() -> Unit,
+ modifier: Modifier = Modifier,
+ contentPadding: PaddingValues = ScreenScaffoldDefaults.contentPadding,
+ timeText: (@Composable () -> Unit)? = null,
+ scrollIndicator: (@Composable BoxScope.() -> Unit)? = {
+ ScrollIndicator(scrollState, modifier = Modifier.align(Alignment.CenterEnd))
+ },
+ edgeButtonSpacing: Dp = ScreenScaffoldDefaults.EdgeButtonSpacing,
+ content: @Composable BoxScope.(PaddingValues) -> Unit,
+): Unit =
+ ScreenScaffold(
+ scrollInfoProvider = ScrollInfoProvider(scrollState),
+ edgeButton = edgeButton,
+ modifier = modifier,
+ contentPadding = contentPadding,
+ timeText = timeText,
+ scrollIndicator = scrollIndicator,
+ edgeButtonSpacing = edgeButtonSpacing,
+ content = content
+ )
+
+/**
+ * [ScreenScaffold] is one of the Wear Material3 scaffold components.
+ *
+ * The scaffold components [AppScaffold] and [ScreenScaffold] lay out the structure of a screen and
+ * coordinate transitions of the [ScrollIndicator] and [TimeText] components. [AppScaffold] should
+ * be at the top of the composition (because it provides [ScaffoldState] and layers [TimeText] on
+ * top of all other content) and [ScreenScaffold] should be part of [AppScaffold]'s content. When
+ * used in conjunction with SwipeDismissableNavHost, [AppScaffold] remains at the top of the
+ * composition, whilst [ScreenScaffold] will be placed for each individual composable route.
+ *
+ * [ScreenScaffold] displays the [ScrollIndicator] at the center-end of the screen by default and
+ * coordinates showing/hiding [TimeText] and [ScrollIndicator] according to [scrollState].
+ *
+ * Example of using AppScaffold and ScreenScaffold:
+ *
+ * @sample androidx.wear.compose.material3.samples.ScaffoldSample
+ * @param scrollState The scroll state for [androidx.compose.foundation.lazy.LazyColumn], used to
+ * drive screen transitions such as [TimeText] scroll away and showing/hiding [ScrollIndicator].
+ * @param modifier The modifier for the screen scaffold.
+ * @param contentPadding The padding to apply around the entire content. This contentPadding is then
+ * received by the [content] and should be consumed by using [Modifier.padding] or contentPadding
+ * parameter of the lazy lists.
+ * @param timeText Time text (both time and potentially status message) for this screen, if
+ * different to the time text at the [AppScaffold] level. When null, the time text from the
+ * [AppScaffold] is displayed for this screen.
+ * @param scrollIndicator The [ScrollIndicator] to display on this screen, which is expected to be
+ * aligned to Center-End. It is recommended to use the Material3 [ScrollIndicator] which is
+ * provided by default. No scroll indicator is displayed if null is passed.
+ * @param content The body content for this screen. The lambda receives a [PaddingValues] that
+ * should be applied to the content root via [Modifier.padding] or contentPadding parameter when
+ * used with lists.
*/
@Composable
public fun ScreenScaffold(
scrollState: LazyListState,
modifier: Modifier = Modifier,
+ contentPadding: PaddingValues = ScreenScaffoldDefaults.contentPadding,
timeText: (@Composable () -> Unit)? = null,
scrollIndicator: (@Composable BoxScope.() -> Unit)? = {
ScrollIndicator(scrollState, modifier = Modifier.align(Alignment.CenterEnd))
},
- edgeButton: (@Composable BoxScope.() -> Unit)? = null,
- content: @Composable BoxScope.() -> Unit,
+ content: @Composable BoxScope.(PaddingValues) -> Unit,
): Unit =
- if (edgeButton != null) {
- ScreenScaffold(
- edgeButton,
- ScrollInfoProvider(scrollState),
- modifier,
- timeText,
- scrollIndicator,
- content
- )
- } else {
- ScreenScaffold(
- modifier,
- timeText,
- ScrollInfoProvider(scrollState),
- scrollIndicator,
- content
- )
- }
+ ScreenScaffold(
+ scrollInfoProvider = ScrollInfoProvider(scrollState),
+ modifier = modifier,
+ contentPadding = contentPadding,
+ timeText = timeText,
+ scrollIndicator = scrollIndicator,
+ content = content
+ )
/**
* [ScreenScaffold] is one of the Wear Material3 scaffold components.
@@ -260,25 +431,38 @@
* @param scrollState The scroll state for a Column, used to drive screen transitions such as
* [TimeText] scroll away and showing/hiding [ScrollIndicator].
* @param modifier The modifier for the screen scaffold.
+ * @param contentPadding The padding to apply around the entire content. This contentPadding is then
+ * received by the [content] and should be consumed by using [Modifier.padding] or contentPadding
+ * parameter of the lazy lists.
* @param timeText Time text (both time and potentially status message) for this screen, if
* different to the time text at the [AppScaffold] level. When null, the time text from the
* [AppScaffold] is displayed for this screen.
* @param scrollIndicator The [ScrollIndicator] to display on this screen, which is expected to be
* aligned to Center-End. It is recommended to use the Material3 [ScrollIndicator] which is
* provided by default. No scroll indicator is displayed if null is passed.
- * @param content The body content for this screen.
+ * @param content The body content for this screen. The lambda receives a [PaddingValues] that
+ * should be applied to the content root via [Modifier.padding] or contentPadding parameter when
+ * used with lists.
*/
@Composable
public fun ScreenScaffold(
scrollState: ScrollState,
modifier: Modifier = Modifier,
+ contentPadding: PaddingValues = ScreenScaffoldDefaults.contentPadding,
timeText: (@Composable () -> Unit)? = null,
scrollIndicator: (@Composable BoxScope.() -> Unit)? = {
ScrollIndicator(scrollState, modifier = Modifier.align(Alignment.CenterEnd))
},
- content: @Composable BoxScope.() -> Unit,
+ content: @Composable BoxScope.(PaddingValues) -> Unit,
): Unit =
- ScreenScaffold(modifier, timeText, ScrollInfoProvider(scrollState), scrollIndicator, content)
+ ScreenScaffold(
+ scrollInfoProvider = ScrollInfoProvider(scrollState),
+ modifier = modifier,
+ contentPadding = contentPadding,
+ timeText = timeText,
+ scrollIndicator = scrollIndicator,
+ content = content
+ )
/**
* [ScreenScaffold] is one of the Wear Material3 scaffold components.
@@ -300,47 +484,84 @@
*
* Example of using AppScaffold and ScreenScaffold:
*
- * @sample androidx.wear.compose.material3.samples.ScaffoldSample
- * @param edgeButton slot for a [EdgeButton] that takes the available space below a scrolling list.
- * It will scale up and fade in when the user scrolls to the end of the list, and scale down and
- * fade out as the user scrolls up.
+ * @sample androidx.wear.compose.material3.samples.ScaffoldWithEdgeButtonSample
* @param scrollInfoProvider Provider for scroll information used to scroll away screen elements
* such as [TimeText] and coordinate showing/hiding the [ScrollIndicator], this needs to be a
* [ScrollInfoProvider].
+ * @param edgeButton slot for a [EdgeButton] that takes the available space below a scrolling list.
+ * It will scale up and fade in when the user scrolls to the end of the list, and scale down and
+ * fade out as the user scrolls up.
* @param modifier The modifier for the screen scaffold.
+ * @param contentPadding The padding to apply around the entire content. This contentPadding is then
+ * received by the [content] and should be consumed by using [Modifier.padding] or contentPadding
+ * parameter of the lazy lists. The bottom padding value is always ignored because we instead use
+ * [edgeButtonSpacing] to specify the gap between edge button and content - and the [EdgeButton]
+ * hugs the bottom of the screen.
* @param timeText Time text (both time and potentially status message) for this screen, if
* different to the time text at the [AppScaffold] level. When null, the time text from the
* [AppScaffold] is displayed for this screen.
* @param scrollIndicator The [ScrollIndicator] to display on this screen, which is expected to be
* aligned to Center-End. It is recommended to use the Material3 [ScrollIndicator] which is
* provided by default. No scroll indicator is displayed if null is passed.
- * @param content The body content for this screen.
+ * @param edgeButtonSpacing The space between [EdgeButton] and the list content. This gap size could
+ * not be smaller then [ScreenScaffoldDefaults.EdgeButtonMinSpacing].
+ * @param content The body content for this screen. The lambda receives a [PaddingValues] that
+ * should be applied to the content root via [Modifier.padding] or contentPadding parameter when
+ * used with lists to properly offset the [EdgeButton].
*/
@Composable
public fun ScreenScaffold(
- edgeButton: @Composable BoxScope.() -> Unit,
scrollInfoProvider: ScrollInfoProvider,
+ edgeButton: @Composable BoxScope.() -> Unit,
modifier: Modifier = Modifier,
+ contentPadding: PaddingValues = ScreenScaffoldDefaults.contentPadding,
timeText: (@Composable () -> Unit)? = null,
scrollIndicator: (@Composable BoxScope.() -> Unit)? = null,
- content: @Composable BoxScope.() -> Unit,
-): Unit =
+ edgeButtonSpacing: Dp = ScreenScaffoldDefaults.EdgeButtonSpacing,
+ content: @Composable BoxScope.(PaddingValues) -> Unit,
+): Unit {
+ val effectiveEdgeButtonSpacing =
+ (edgeButtonSpacing - ScreenScaffoldDefaults.EdgeButtonMinSpacing).coerceAtLeast(0.dp)
+ // Adds the gap between content and edge button.
+ val lastItemOffsetCorrection = with(LocalDensity.current) { effectiveEdgeButtonSpacing.toPx() }
+ val localDensity = LocalDensity.current
+
ScreenScaffold(
- modifier,
- timeText,
- scrollInfoProvider,
- scrollIndicator,
+ modifier = modifier,
+ contentPadding = contentPadding,
+ timeText = timeText,
+ scrollInfoProvider = scrollInfoProvider,
+ scrollIndicator = scrollIndicator,
content = {
- content()
+ var intrinsicButtonHeight by remember(edgeButton) { mutableStateOf<Float?>(null) }
+
+ content(
+ // Replace bottom content padding adjusted for the edge button.
+ ReplacePaddingValues(
+ contentPadding,
+ with(localDensity) {
+ (intrinsicButtonHeight?.toDp() ?: 0.dp) + effectiveEdgeButtonSpacing
+ }
+ )
+ )
Box(
- Modifier.align(Alignment.BottomCenter).dynamicHeight {
- scrollInfoProvider.lastItemOffset.coerceAtLeast(0f)
- },
contentAlignment = Alignment.BottomCenter,
- content = edgeButton
+ content = edgeButton,
+ modifier =
+ Modifier.align(Alignment.BottomCenter).dynamicHeight(
+ onIntrinsicHeightMeasured = {
+ if (intrinsicButtonHeight != it) {
+ intrinsicButtonHeight = it
+ }
+ }
+ ) {
+ (scrollInfoProvider.lastItemOffset - lastItemOffsetCorrection)
+ .coerceAtLeast(0f)
+ },
)
}
)
+}
/**
* [ScreenScaffold] is one of the Wear Material3 scaffold components.
@@ -359,24 +580,30 @@
*
* @sample androidx.wear.compose.material3.samples.ScaffoldSample
* @param modifier The modifier for the screen scaffold.
+ * @param scrollInfoProvider Provider for scroll information used to scroll away screen elements
+ * such as [TimeText] and coordinate showing/hiding the [ScrollIndicator].
+ * @param contentPadding The padding to apply around the entire content. This contentPadding is then
+ * received by the [content] and should be consumed by using [Modifier.padding] or contentPadding
+ * parameter of the lazy lists.
* @param timeText Time text (both time and potentially status message) for this screen, if
* different to the time text at the [AppScaffold] level. When null, the time text from the
* [AppScaffold] is displayed for this screen.
- * @param scrollInfoProvider Provider for scroll information used to scroll away screen elements
- * such as [TimeText] and coordinate showing/hiding the [ScrollIndicator].
* @param scrollIndicator The [ScrollIndicator] to display on this screen, which is expected to be
* aligned to Center-End. It is recommended to use the Material3 [ScrollIndicator] which is
* provided by default. No scroll indicator is displayed if null is passed.
- * @param content The body content for this screen.
+ * @param content The body content for this screen. The lambda receives a [PaddingValues] that
+ * should be applied to the content root via [Modifier.padding] or contentPadding parameter when
+ * used with lists.
*/
@Composable
public fun ScreenScaffold(
modifier: Modifier = Modifier,
- timeText: (@Composable () -> Unit)? = null,
scrollInfoProvider: ScrollInfoProvider? = null,
+ contentPadding: PaddingValues = ScreenScaffoldDefaults.contentPadding,
+ timeText: (@Composable () -> Unit)? = null,
scrollIndicator: (@Composable BoxScope.() -> Unit)? = null,
- content: @Composable BoxScope.() -> Unit,
-) {
+ content: @Composable BoxScope.(PaddingValues) -> Unit,
+): Unit {
val scaffoldState = LocalScaffoldState.current
val key = remember { Any() }
@@ -395,7 +622,7 @@
scaffoldState.UpdateIdlingDetectorIfNeeded()
Box(modifier = modifier.fillMaxSize()) {
- content()
+ content(contentPadding)
scrollInfoProvider?.let {
AnimatedIndicator(
isVisible = {
@@ -421,6 +648,10 @@
* edge button size.
* @return A [PaddingValues] object with the calculated padding.
*/
+ @Deprecated(
+ "Use the combination of a new contentPadding parameter on the ScreenScaffold to " +
+ "get back the padding values inside of the content lambda."
+ )
public fun contentPaddingWithEdgeButton(
edgeButtonSize: EdgeButtonSize,
start: Dp = 0.dp,
@@ -429,34 +660,62 @@
extraBottom: Dp = 0.dp,
): PaddingValues =
PaddingValues(start, top, end, extraBottom + edgeButtonSize.maximumHeightPlusPadding())
+
+ /** The default space between [EdgeButton] and list content in [ScreenScaffold]. */
+ public val EdgeButtonSpacing: Dp = 16.dp
+
+ /** The minimum space between [EdgeButton] and list content in [ScreenScaffold]. */
+ public val EdgeButtonMinSpacing: Dp = EdgeButtonVerticalPadding
+
+ /** Default contentPadding added to the [ScreenScaffold]. */
+ public val contentPadding: PaddingValues
+ @Composable
+ get() =
+ PaddingValues(
+ horizontal = PaddingDefaults.horizontalContentPadding(),
+ vertical = PaddingDefaults.verticalContentPadding()
+ )
}
// Sets the height that will be used down the line, using a state as parameter, to avoid
// recompositions when the height changes.
-internal fun Modifier.dynamicHeight(heightState: () -> Float) =
- this.then(DynamicHeightElement(heightState))
+internal fun Modifier.dynamicHeight(
+ onIntrinsicHeightMeasured: (Float) -> Unit,
+ heightState: () -> Float
+) = this.then(DynamicHeightElement(onIntrinsicHeightMeasured, heightState))
// Following classes 'inspired' by 'WrapContentElement' / 'WrapContentNode'
-private class DynamicHeightElement(val heightState: () -> Float) :
- ModifierNodeElement<DynamicHeightNode>() {
- override fun create(): DynamicHeightNode = DynamicHeightNode(heightState)
+private class DynamicHeightElement(
+ val onIntrinsicHeightMeasured: (Float) -> Unit,
+ val heightState: () -> Float
+) : ModifierNodeElement<DynamicHeightNode>() {
+ override fun create(): DynamicHeightNode =
+ DynamicHeightNode(onIntrinsicHeightMeasured, heightState)
override fun update(node: DynamicHeightNode) {
node.heightState = heightState
+ node.onIntrinsicHeightMeasured = onIntrinsicHeightMeasured
}
override fun InspectorInfo.inspectableProperties() {
- name = "MyHeightElement"
+ name = "DynamicHeightElement"
}
override fun equals(other: Any?) =
- other is DynamicHeightElement && heightState === other.heightState
+ other is DynamicHeightElement &&
+ heightState === other.heightState &&
+ onIntrinsicHeightMeasured === other.onIntrinsicHeightMeasured
- override fun hashCode() = heightState.hashCode()
+ override fun hashCode() = 31 * heightState.hashCode() + onIntrinsicHeightMeasured.hashCode()
}
-private class DynamicHeightNode(var heightState: () -> Float) :
- LayoutModifierNode, Modifier.Node() {
+private class DynamicHeightNode(
+ var onIntrinsicHeightMeasured: (Float) -> Unit,
+ var heightState: () -> Float
+) : LayoutModifierNode, Modifier.Node() {
+
+ var lastMeasureHeight: Int? = null
+
override fun MeasureScope.measure(
measurable: Measurable,
constraints: Constraints
@@ -464,7 +723,10 @@
// Similar to .fillMaxWidth().height(heightState.value) but we observe the state in the
// measurement pass, not on Composition.
val height = heightState().roundToInt()
-
+ if (lastMeasureHeight == null || height > 0 && lastMeasureHeight != height) {
+ onIntrinsicHeightMeasured(measurable.maxIntrinsicHeight(constraints.maxWidth).toFloat())
+ lastMeasureHeight = height
+ }
val wrappedConstraints =
Constraints(constraints.maxWidth, constraints.maxWidth, height, height)
val placeable = measurable.measure(wrappedConstraints)
@@ -481,3 +743,8 @@
}
}
}
+
+private class ReplacePaddingValues(paddingValues: PaddingValues, val bottomPadding: Dp) :
+ PaddingValues by paddingValues {
+ override fun calculateBottomPadding(): Dp = bottomPadding
+}
diff --git a/wear/compose/compose-material3/src/main/java/androidx/wear/compose/material3/lazy/ScrollTransform.kt b/wear/compose/compose-material3/src/main/java/androidx/wear/compose/material3/lazy/ScrollTransform.kt
index f2bcb1a..61ecf39 100644
--- a/wear/compose/compose-material3/src/main/java/androidx/wear/compose/material3/lazy/ScrollTransform.kt
+++ b/wear/compose/compose-material3/src/main/java/androidx/wear/compose/material3/lazy/ScrollTransform.kt
@@ -93,7 +93,7 @@
* [TransformingLazyColumnItemScope]. It adjusts the height, position, applies scaling and morphing
* effects as the item scrolls.
*
- * @sample androidx.wear.compose.material3.samples.TransformingLazyColumnScalingMorphingEffectSample
+ * @sample androidx.wear.compose.material3.samples.TransformingLazyColumnScrollingSample
* @param scope The [TransformingLazyColumnItemScope] provides access to the item's index and key.
* @param shape [Shape] of the background.
* @param painter [Painter] to use for the background.
@@ -137,7 +137,7 @@
* [Shape] and background [Color] (or [Painter]) so the modifier can do the background drawing and
* apply specific effects to background and content, as in the Material spec.
*
- * @sample androidx.wear.compose.material3.samples.TransformingLazyColumnScalingMorphingEffectSample
+ * @sample androidx.wear.compose.material3.samples.TransformingLazyColumnScrollingSample
* @param scope The [TransformingLazyColumnItemScope] provides access to the item's index and key.
*/
@Composable
diff --git a/wear/compose/integration-tests/demos/src/main/java/androidx/wear/compose/integration/demos/ScalingLazyColumnDemo.kt b/wear/compose/integration-tests/demos/src/main/java/androidx/wear/compose/integration/demos/ScalingLazyColumnDemo.kt
index 16c8bdc..6d20742 100644
--- a/wear/compose/integration-tests/demos/src/main/java/androidx/wear/compose/integration/demos/ScalingLazyColumnDemo.kt
+++ b/wear/compose/integration-tests/demos/src/main/java/androidx/wear/compose/integration/demos/ScalingLazyColumnDemo.kt
@@ -24,10 +24,10 @@
import androidx.compose.ui.Modifier
import androidx.compose.ui.geometry.Offset
import androidx.compose.ui.graphics.Color
-import androidx.compose.ui.platform.LocalContext
+import androidx.compose.ui.platform.LocalConfiguration
import androidx.compose.ui.platform.LocalDensity
import androidx.compose.ui.text.style.TextAlign
-import androidx.compose.ui.unit.Dp
+import androidx.compose.ui.unit.dp
import androidx.wear.compose.foundation.lazy.ScalingLazyColumn
import androidx.wear.compose.foundation.lazy.rememberScalingLazyListState
import androidx.wear.compose.material.AppCard
@@ -58,11 +58,8 @@
@Composable
fun ScalingLazyColumnDetail() {
val state = rememberScalingLazyListState()
- val applicationContext = LocalContext.current
val screenHeightPx =
- with(LocalDensity.current) {
- Dp(applicationContext.resources.configuration.screenHeightDp.toFloat()).roundToPx()
- }
+ with(LocalDensity.current) { LocalConfiguration.current.screenHeightDp.dp.roundToPx() }
val halfScreenHeightPx = screenHeightPx / 2f
ScalingLazyColumn(modifier = Modifier.fillMaxWidth(), state = state) {
item {
diff --git a/wear/protolayout/protolayout-proto/src/main/proto/color.proto b/wear/protolayout/protolayout-proto/src/main/proto/color.proto
index f743302..d5efd4c 100644
--- a/wear/protolayout/protolayout-proto/src/main/proto/color.proto
+++ b/wear/protolayout/protolayout-proto/src/main/proto/color.proto
@@ -80,10 +80,46 @@
DegreesProp end_angle = 3;
}
+// A linear gradient with the provided colors based on defined start and end
+// coordinates.
+//
+// The colors are dispersed at the offsets defined in each color stop.
+message LinearGradient {
+ // The color stops defining how the colors are distributed from the start to
+ // the end coordinates.
+ //
+ // A color stop is a pair of a color and its offset in the gradient.
+ // The offset is the relative position of the color, beginning with 0 at the
+ // start coordinate and ending with 1.0 at the end coordinate.
+ //
+ // There must be at least 2 colors and at most 10 colors.
+ //
+ // If offset values are not set, the colors are evenly distributed in the
+ // gradient.
+ repeated ColorStop color_stops = 1;
+
+ // The starting x position of the linear gradient. Defaults to the left side
+ // of the element.
+ OffsetDimension start_x = 2;
+
+ // The starting y position of the linear gradient. Defaults to the top side of
+ // the element.
+ OffsetDimension start_y = 3;
+
+ // The ending y position of the linear gradient. Defaults to the right side of
+ // the element.
+ OffsetDimension end_x = 4;
+
+ // The ending y position of the linear gradient. Defaults to the top side of
+ // the element.
+ OffsetDimension end_y = 5;
+}
+
// A Brush describes how something is drawn on screen.
// It determines the color(s) that are drawn in the drawing area.
message Brush {
oneof inner {
SweepGradient sweep_gradient = 1;
+ LinearGradient linear_gradient = 2;
}
}
diff --git a/wear/protolayout/protolayout-proto/src/main/proto/dimension.proto b/wear/protolayout/protolayout-proto/src/main/proto/dimension.proto
index 312d58c..43dc615 100644
--- a/wear/protolayout/protolayout-proto/src/main/proto/dimension.proto
+++ b/wear/protolayout/protolayout-proto/src/main/proto/dimension.proto
@@ -207,3 +207,15 @@
BoundingBoxRatio location_ratio = 2;
}
}
+
+// A dimension that represents an offset relative to an elements position.
+message OffsetDimension {
+ oneof inner {
+ // Location in dp, with the default being the point at the top left of the
+ // element.
+ DpProp offset_dp = 1;
+ // Location proportional to the bounding box, with the bounding box's
+ // top/left as 0 and bottom/right as 1.
+ BoundingBoxRatio location_ratio = 2;
+ }
+}
diff --git a/wear/protolayout/protolayout-proto/src/main/proto/layout.proto b/wear/protolayout/protolayout-proto/src/main/proto/layout.proto
index a81a412..1affc10 100644
--- a/wear/protolayout/protolayout-proto/src/main/proto/layout.proto
+++ b/wear/protolayout/protolayout-proto/src/main/proto/layout.proto
@@ -689,6 +689,8 @@
// A brush used to draw this line. If set, the brush will be used instead of
// the color provided in {@code setColor()}.
+ //
+ // Only SweepGradient is supported.
Brush brush = 7;
// Modifiers for this element.
diff --git a/wear/protolayout/protolayout-proto/src/main/proto/modifiers.proto b/wear/protolayout/protolayout-proto/src/main/proto/modifiers.proto
index e3c53e9..c991e82 100644
--- a/wear/protolayout/protolayout-proto/src/main/proto/modifiers.proto
+++ b/wear/protolayout/protolayout-proto/src/main/proto/modifiers.proto
@@ -179,12 +179,21 @@
// While this field is statically accessible from 1.0, it's only bindable
// since version 1.2 and renderers supporting version 1.2 will use the dynamic
// value (if set).
+ //
+ // If a brush is set, this color will only be used if brush is not supported
+ // by the renderer (versions below 1.5).
ColorProp color = 1;
// The corner properties of this element. This only affects the drawing of
// this element if it has a background color or border. If not defined,
// defaults to having a square corner.
Corner corner = 2;
+
+ // A brush used to draw the background. If set and supported, the brush will be
+ // used instead of the color provided in {@code setColor()}.
+ //
+ // Only LinearGradient is supported.
+ Brush brush = 3;
}
// Metadata about an element. For use by libraries building higher-level
diff --git a/wear/protolayout/protolayout/api/current.txt b/wear/protolayout/protolayout/api/current.txt
index b58a040..c8453dc 100644
--- a/wear/protolayout/protolayout/api/current.txt
+++ b/wear/protolayout/protolayout/api/current.txt
@@ -131,6 +131,24 @@
method public androidx.wear.protolayout.ColorBuilders.ColorStop build();
}
+ @androidx.wear.protolayout.expression.RequiresSchemaVersion(major=1, minor=500) public static final class ColorBuilders.LinearGradient implements androidx.wear.protolayout.ColorBuilders.Brush {
+ method public java.util.List<androidx.wear.protolayout.ColorBuilders.ColorStop!> getColorStops();
+ method public androidx.wear.protolayout.DimensionBuilders.OffsetDimension? getEndX();
+ method public androidx.wear.protolayout.DimensionBuilders.OffsetDimension? getEndY();
+ method public androidx.wear.protolayout.DimensionBuilders.OffsetDimension? getStartX();
+ method public androidx.wear.protolayout.DimensionBuilders.OffsetDimension? getStartY();
+ }
+
+ public static final class ColorBuilders.LinearGradient.Builder {
+ ctor @androidx.wear.protolayout.expression.RequiresSchemaVersion(major=1, minor=500) @java.lang.SafeVarargs public ColorBuilders.LinearGradient.Builder(androidx.wear.protolayout.ColorBuilders.ColorProp!...);
+ ctor @androidx.wear.protolayout.expression.RequiresSchemaVersion(major=1, minor=500) @java.lang.SafeVarargs public ColorBuilders.LinearGradient.Builder(androidx.wear.protolayout.ColorBuilders.ColorStop!...);
+ method public androidx.wear.protolayout.ColorBuilders.LinearGradient build();
+ method @androidx.wear.protolayout.expression.RequiresSchemaVersion(major=1, minor=500) public androidx.wear.protolayout.ColorBuilders.LinearGradient.Builder setEndX(androidx.wear.protolayout.DimensionBuilders.OffsetDimension);
+ method @androidx.wear.protolayout.expression.RequiresSchemaVersion(major=1, minor=500) public androidx.wear.protolayout.ColorBuilders.LinearGradient.Builder setEndY(androidx.wear.protolayout.DimensionBuilders.OffsetDimension);
+ method @androidx.wear.protolayout.expression.RequiresSchemaVersion(major=1, minor=500) public androidx.wear.protolayout.ColorBuilders.LinearGradient.Builder setStartX(androidx.wear.protolayout.DimensionBuilders.OffsetDimension);
+ method @androidx.wear.protolayout.expression.RequiresSchemaVersion(major=1, minor=500) public androidx.wear.protolayout.ColorBuilders.LinearGradient.Builder setStartY(androidx.wear.protolayout.DimensionBuilders.OffsetDimension);
+ }
+
@androidx.wear.protolayout.expression.RequiresSchemaVersion(major=1, minor=300) public static final class ColorBuilders.SweepGradient implements androidx.wear.protolayout.ColorBuilders.Brush {
method public java.util.List<androidx.wear.protolayout.ColorBuilders.ColorStop!> getColorStops();
method public androidx.wear.protolayout.DimensionBuilders.DegreesProp getEndAngle();
@@ -212,7 +230,7 @@
method @androidx.wear.protolayout.expression.RequiresSchemaVersion(major=1, minor=200) public androidx.wear.protolayout.DimensionBuilders.AngularLayoutConstraint.Builder setAngularAlignment(int);
}
- @androidx.wear.protolayout.expression.RequiresSchemaVersion(major=1, minor=400) public static final class DimensionBuilders.BoundingBoxRatio implements androidx.wear.protolayout.DimensionBuilders.PivotDimension {
+ @androidx.wear.protolayout.expression.RequiresSchemaVersion(major=1, minor=400) public static final class DimensionBuilders.BoundingBoxRatio implements androidx.wear.protolayout.DimensionBuilders.OffsetDimension androidx.wear.protolayout.DimensionBuilders.PivotDimension {
method public androidx.wear.protolayout.TypeBuilders.FloatProp getRatio();
}
@@ -237,7 +255,7 @@
method @androidx.wear.protolayout.expression.RequiresSchemaVersion(major=1, minor=0) public androidx.wear.protolayout.DimensionBuilders.DegreesProp.Builder setValue(float);
}
- @androidx.wear.protolayout.expression.RequiresSchemaVersion(major=1, minor=0) public static final class DimensionBuilders.DpProp implements androidx.wear.protolayout.DimensionBuilders.AngularDimension androidx.wear.protolayout.DimensionBuilders.ContainerDimension androidx.wear.protolayout.DimensionBuilders.ExtensionDimension androidx.wear.protolayout.DimensionBuilders.ImageDimension androidx.wear.protolayout.DimensionBuilders.PivotDimension androidx.wear.protolayout.DimensionBuilders.SpacerDimension {
+ @androidx.wear.protolayout.expression.RequiresSchemaVersion(major=1, minor=0) public static final class DimensionBuilders.DpProp implements androidx.wear.protolayout.DimensionBuilders.AngularDimension androidx.wear.protolayout.DimensionBuilders.ContainerDimension androidx.wear.protolayout.DimensionBuilders.ExtensionDimension androidx.wear.protolayout.DimensionBuilders.ImageDimension androidx.wear.protolayout.DimensionBuilders.OffsetDimension androidx.wear.protolayout.DimensionBuilders.PivotDimension androidx.wear.protolayout.DimensionBuilders.SpacerDimension {
method public androidx.wear.protolayout.expression.DynamicBuilders.DynamicFloat? getDynamicValue();
method @Dimension(unit=androidx.annotation.Dimension.DP) public float getValue();
}
@@ -287,6 +305,9 @@
@androidx.wear.protolayout.expression.RequiresSchemaVersion(major=1, minor=0) public static interface DimensionBuilders.ImageDimension {
}
+ @androidx.wear.protolayout.expression.RequiresSchemaVersion(major=1, minor=500) public static interface DimensionBuilders.OffsetDimension {
+ }
+
@androidx.wear.protolayout.expression.RequiresSchemaVersion(major=1, minor=400) public static interface DimensionBuilders.PivotDimension {
}
@@ -963,6 +984,7 @@
}
@androidx.wear.protolayout.expression.RequiresSchemaVersion(major=1, minor=0) public static final class ModifiersBuilders.Background {
+ method public androidx.wear.protolayout.ColorBuilders.Brush? getBrush();
method public androidx.wear.protolayout.ColorBuilders.ColorProp? getColor();
method public androidx.wear.protolayout.ModifiersBuilders.Corner? getCorner();
}
@@ -970,6 +992,7 @@
public static final class ModifiersBuilders.Background.Builder {
ctor public ModifiersBuilders.Background.Builder();
method public androidx.wear.protolayout.ModifiersBuilders.Background build();
+ method @androidx.wear.protolayout.expression.RequiresSchemaVersion(major=1, minor=500) public androidx.wear.protolayout.ModifiersBuilders.Background.Builder setBrush(androidx.wear.protolayout.ColorBuilders.Brush);
method @androidx.wear.protolayout.expression.RequiresSchemaVersion(major=1, minor=0) public androidx.wear.protolayout.ModifiersBuilders.Background.Builder setColor(androidx.wear.protolayout.ColorBuilders.ColorProp);
method @androidx.wear.protolayout.expression.RequiresSchemaVersion(major=1, minor=0) public androidx.wear.protolayout.ModifiersBuilders.Background.Builder setCorner(androidx.wear.protolayout.ModifiersBuilders.Corner);
}
diff --git a/wear/protolayout/protolayout/api/restricted_current.txt b/wear/protolayout/protolayout/api/restricted_current.txt
index b58a040..c8453dc 100644
--- a/wear/protolayout/protolayout/api/restricted_current.txt
+++ b/wear/protolayout/protolayout/api/restricted_current.txt
@@ -131,6 +131,24 @@
method public androidx.wear.protolayout.ColorBuilders.ColorStop build();
}
+ @androidx.wear.protolayout.expression.RequiresSchemaVersion(major=1, minor=500) public static final class ColorBuilders.LinearGradient implements androidx.wear.protolayout.ColorBuilders.Brush {
+ method public java.util.List<androidx.wear.protolayout.ColorBuilders.ColorStop!> getColorStops();
+ method public androidx.wear.protolayout.DimensionBuilders.OffsetDimension? getEndX();
+ method public androidx.wear.protolayout.DimensionBuilders.OffsetDimension? getEndY();
+ method public androidx.wear.protolayout.DimensionBuilders.OffsetDimension? getStartX();
+ method public androidx.wear.protolayout.DimensionBuilders.OffsetDimension? getStartY();
+ }
+
+ public static final class ColorBuilders.LinearGradient.Builder {
+ ctor @androidx.wear.protolayout.expression.RequiresSchemaVersion(major=1, minor=500) @java.lang.SafeVarargs public ColorBuilders.LinearGradient.Builder(androidx.wear.protolayout.ColorBuilders.ColorProp!...);
+ ctor @androidx.wear.protolayout.expression.RequiresSchemaVersion(major=1, minor=500) @java.lang.SafeVarargs public ColorBuilders.LinearGradient.Builder(androidx.wear.protolayout.ColorBuilders.ColorStop!...);
+ method public androidx.wear.protolayout.ColorBuilders.LinearGradient build();
+ method @androidx.wear.protolayout.expression.RequiresSchemaVersion(major=1, minor=500) public androidx.wear.protolayout.ColorBuilders.LinearGradient.Builder setEndX(androidx.wear.protolayout.DimensionBuilders.OffsetDimension);
+ method @androidx.wear.protolayout.expression.RequiresSchemaVersion(major=1, minor=500) public androidx.wear.protolayout.ColorBuilders.LinearGradient.Builder setEndY(androidx.wear.protolayout.DimensionBuilders.OffsetDimension);
+ method @androidx.wear.protolayout.expression.RequiresSchemaVersion(major=1, minor=500) public androidx.wear.protolayout.ColorBuilders.LinearGradient.Builder setStartX(androidx.wear.protolayout.DimensionBuilders.OffsetDimension);
+ method @androidx.wear.protolayout.expression.RequiresSchemaVersion(major=1, minor=500) public androidx.wear.protolayout.ColorBuilders.LinearGradient.Builder setStartY(androidx.wear.protolayout.DimensionBuilders.OffsetDimension);
+ }
+
@androidx.wear.protolayout.expression.RequiresSchemaVersion(major=1, minor=300) public static final class ColorBuilders.SweepGradient implements androidx.wear.protolayout.ColorBuilders.Brush {
method public java.util.List<androidx.wear.protolayout.ColorBuilders.ColorStop!> getColorStops();
method public androidx.wear.protolayout.DimensionBuilders.DegreesProp getEndAngle();
@@ -212,7 +230,7 @@
method @androidx.wear.protolayout.expression.RequiresSchemaVersion(major=1, minor=200) public androidx.wear.protolayout.DimensionBuilders.AngularLayoutConstraint.Builder setAngularAlignment(int);
}
- @androidx.wear.protolayout.expression.RequiresSchemaVersion(major=1, minor=400) public static final class DimensionBuilders.BoundingBoxRatio implements androidx.wear.protolayout.DimensionBuilders.PivotDimension {
+ @androidx.wear.protolayout.expression.RequiresSchemaVersion(major=1, minor=400) public static final class DimensionBuilders.BoundingBoxRatio implements androidx.wear.protolayout.DimensionBuilders.OffsetDimension androidx.wear.protolayout.DimensionBuilders.PivotDimension {
method public androidx.wear.protolayout.TypeBuilders.FloatProp getRatio();
}
@@ -237,7 +255,7 @@
method @androidx.wear.protolayout.expression.RequiresSchemaVersion(major=1, minor=0) public androidx.wear.protolayout.DimensionBuilders.DegreesProp.Builder setValue(float);
}
- @androidx.wear.protolayout.expression.RequiresSchemaVersion(major=1, minor=0) public static final class DimensionBuilders.DpProp implements androidx.wear.protolayout.DimensionBuilders.AngularDimension androidx.wear.protolayout.DimensionBuilders.ContainerDimension androidx.wear.protolayout.DimensionBuilders.ExtensionDimension androidx.wear.protolayout.DimensionBuilders.ImageDimension androidx.wear.protolayout.DimensionBuilders.PivotDimension androidx.wear.protolayout.DimensionBuilders.SpacerDimension {
+ @androidx.wear.protolayout.expression.RequiresSchemaVersion(major=1, minor=0) public static final class DimensionBuilders.DpProp implements androidx.wear.protolayout.DimensionBuilders.AngularDimension androidx.wear.protolayout.DimensionBuilders.ContainerDimension androidx.wear.protolayout.DimensionBuilders.ExtensionDimension androidx.wear.protolayout.DimensionBuilders.ImageDimension androidx.wear.protolayout.DimensionBuilders.OffsetDimension androidx.wear.protolayout.DimensionBuilders.PivotDimension androidx.wear.protolayout.DimensionBuilders.SpacerDimension {
method public androidx.wear.protolayout.expression.DynamicBuilders.DynamicFloat? getDynamicValue();
method @Dimension(unit=androidx.annotation.Dimension.DP) public float getValue();
}
@@ -287,6 +305,9 @@
@androidx.wear.protolayout.expression.RequiresSchemaVersion(major=1, minor=0) public static interface DimensionBuilders.ImageDimension {
}
+ @androidx.wear.protolayout.expression.RequiresSchemaVersion(major=1, minor=500) public static interface DimensionBuilders.OffsetDimension {
+ }
+
@androidx.wear.protolayout.expression.RequiresSchemaVersion(major=1, minor=400) public static interface DimensionBuilders.PivotDimension {
}
@@ -963,6 +984,7 @@
}
@androidx.wear.protolayout.expression.RequiresSchemaVersion(major=1, minor=0) public static final class ModifiersBuilders.Background {
+ method public androidx.wear.protolayout.ColorBuilders.Brush? getBrush();
method public androidx.wear.protolayout.ColorBuilders.ColorProp? getColor();
method public androidx.wear.protolayout.ModifiersBuilders.Corner? getCorner();
}
@@ -970,6 +992,7 @@
public static final class ModifiersBuilders.Background.Builder {
ctor public ModifiersBuilders.Background.Builder();
method public androidx.wear.protolayout.ModifiersBuilders.Background build();
+ method @androidx.wear.protolayout.expression.RequiresSchemaVersion(major=1, minor=500) public androidx.wear.protolayout.ModifiersBuilders.Background.Builder setBrush(androidx.wear.protolayout.ColorBuilders.Brush);
method @androidx.wear.protolayout.expression.RequiresSchemaVersion(major=1, minor=0) public androidx.wear.protolayout.ModifiersBuilders.Background.Builder setColor(androidx.wear.protolayout.ColorBuilders.ColorProp);
method @androidx.wear.protolayout.expression.RequiresSchemaVersion(major=1, minor=0) public androidx.wear.protolayout.ModifiersBuilders.Background.Builder setCorner(androidx.wear.protolayout.ModifiersBuilders.Corner);
}
diff --git a/wear/protolayout/protolayout/src/main/java/androidx/wear/protolayout/ColorBuilders.java b/wear/protolayout/protolayout/src/main/java/androidx/wear/protolayout/ColorBuilders.java
index 077c910..09f44ab 100644
--- a/wear/protolayout/protolayout/src/main/java/androidx/wear/protolayout/ColorBuilders.java
+++ b/wear/protolayout/protolayout/src/main/java/androidx/wear/protolayout/ColorBuilders.java
@@ -24,6 +24,7 @@
import androidx.annotation.RestrictTo;
import androidx.annotation.RestrictTo.Scope;
import androidx.wear.protolayout.DimensionBuilders.DegreesProp;
+import androidx.wear.protolayout.DimensionBuilders.OffsetDimension;
import androidx.wear.protolayout.TypeBuilders.FloatProp;
import androidx.wear.protolayout.expression.DynamicBuilders;
import androidx.wear.protolayout.expression.DynamicBuilders.DynamicColor;
@@ -525,7 +526,6 @@
*
* @param colors The color sequence to be distributed around the gradient center. The
* color sequence is distributed between the gradient's start and end angles.
- *
* @throws IllegalArgumentException if the number of colors is less than 2 or larger
* than 10.
*/
@@ -562,6 +562,275 @@
}
/**
+ * A linear gradient with the provided colors based on defined start and end coordinates.
+ *
+ * <p>The colors are dispersed at the offsets defined in each color stop.
+ */
+ @RequiresSchemaVersion(major = 1, minor = 500)
+ public static final class LinearGradient implements Brush {
+ private final ColorProto.LinearGradient mImpl;
+ private final @Nullable Fingerprint mFingerprint;
+
+ LinearGradient(ColorProto.LinearGradient impl, @Nullable Fingerprint fingerprint) {
+ this.mImpl = impl;
+ this.mFingerprint = fingerprint;
+ }
+
+ /**
+ * Gets the color stops defining how the colors are distributed from the start to the end
+ * coordinates.
+ *
+ * <p>A color stop is a pair of a color and its offset in the gradient. The offset is the
+ * relative position of the color, beginning with 0 at the start coordinate and ending with
+ * 1.0 at the end coordinate.
+ *
+ * <p>There must be at least 2 colors and at most 10 colors.
+ *
+ * <p>If offset values are not set, the colors are evenly distributed in the gradient.
+ */
+ public @NonNull List<ColorStop> getColorStops() {
+ List<ColorStop> list = new ArrayList<>();
+ for (ColorProto.ColorStop item : mImpl.getColorStopsList()) {
+ list.add(ColorStop.fromProto(item));
+ }
+ return Collections.unmodifiableList(list);
+ }
+
+ /**
+ * Gets the starting x position of the linear gradient. Defaults to the left side of the
+ * element.
+ */
+ @Nullable
+ public OffsetDimension getStartX() {
+ if (mImpl.hasStartX()) {
+ return DimensionBuilders.offsetDimensionFromProto(mImpl.getStartX());
+ } else {
+ return null;
+ }
+ }
+
+ /**
+ * Gets the starting y position of the linear gradient. Defaults to the top side of the
+ * element.
+ */
+ public @Nullable OffsetDimension getStartY() {
+ if (mImpl.hasStartY()) {
+ return DimensionBuilders.offsetDimensionFromProto(mImpl.getStartY());
+ } else {
+ return null;
+ }
+ }
+
+ /**
+ * Gets the ending y position of the linear gradient. Defaults to the right side of the
+ * element.
+ */
+ public @Nullable OffsetDimension getEndX() {
+ if (mImpl.hasEndX()) {
+ return DimensionBuilders.offsetDimensionFromProto(mImpl.getEndX());
+ } else {
+ return null;
+ }
+ }
+
+ /**
+ * Gets the ending y position of the linear gradient. Defaults to the top side of the
+ * element.
+ */
+ public @Nullable OffsetDimension getEndY() {
+ if (mImpl.hasEndY()) {
+ return DimensionBuilders.offsetDimensionFromProto(mImpl.getEndY());
+ } else {
+ return null;
+ }
+ }
+
+ @Override
+ @RestrictTo(Scope.LIBRARY_GROUP)
+ public @Nullable Fingerprint getFingerprint() {
+ return mFingerprint;
+ }
+
+ /** Creates a new wrapper instance from the proto. */
+ @RestrictTo(Scope.LIBRARY_GROUP)
+ public static @NonNull LinearGradient fromProto(
+ ColorProto.@NonNull LinearGradient proto, @Nullable Fingerprint fingerprint) {
+ return new LinearGradient(proto, fingerprint);
+ }
+
+ static @NonNull LinearGradient fromProto(ColorProto.@NonNull LinearGradient proto) {
+ return fromProto(proto, null);
+ }
+
+ /** Returns the internal proto instance. */
+ ColorProto.@NonNull LinearGradient toProto() {
+ return mImpl;
+ }
+
+ @Override
+ @RestrictTo(Scope.LIBRARY_GROUP)
+ public ColorProto.@NonNull Brush toBrushProto() {
+ return ColorProto.Brush.newBuilder().setLinearGradient(mImpl).build();
+ }
+
+ @Override
+ public @NonNull String toString() {
+ return "LinearGradient{"
+ + "colorStops="
+ + getColorStops()
+ + ", startX="
+ + getStartX()
+ + ", startY="
+ + getStartY()
+ + ", endX="
+ + getEndX()
+ + ", endY="
+ + getEndY()
+ + "}";
+ }
+
+ /** Builder for {@link LinearGradient}. */
+ @SuppressWarnings("HiddenSuperclass")
+ public static final class Builder implements Brush.Builder {
+ private final ColorProto.LinearGradient.Builder mImpl =
+ ColorProto.LinearGradient.newBuilder();
+ private final Fingerprint mFingerprint = new Fingerprint(-1075994710);
+
+ /**
+ * Adds one item to the color stops defining how the colors are distributed from the
+ * start to the end coordinates.
+ *
+ * <p>A color stop is a pair of a color and its offset in the gradient. The offset is
+ * the relative position of the color, beginning with 0 at the start coordinate and
+ * ending with 1.0 at the end coordinate.
+ *
+ * <p>There must be at least 2 colors and at most 10 colors.
+ *
+ * <p>If offset values are not set, the colors are evenly distributed in the gradient.
+ */
+ @RequiresSchemaVersion(major = 1, minor = 500)
+ private @NonNull Builder addColorStop(@NonNull ColorStop colorStop) {
+ mImpl.addColorStops(colorStop.toProto());
+ mFingerprint.recordPropertyUpdate(
+ 1, checkNotNull(colorStop.getFingerprint()).aggregateValueAsInt());
+ return this;
+ }
+
+ /**
+ * Sets the starting x position of the linear gradient. Defaults to the left side of the
+ * element.
+ */
+ @RequiresSchemaVersion(major = 1, minor = 500)
+ public @NonNull Builder setStartX(@NonNull OffsetDimension startX) {
+ mImpl.setStartX(startX.toOffsetDimensionProto());
+ mFingerprint.recordPropertyUpdate(
+ 2, checkNotNull(startX.getFingerprint()).aggregateValueAsInt());
+ return this;
+ }
+
+ /**
+ * Sets the starting y position of the linear gradient. Defaults to the top side of the
+ * element.
+ */
+ @RequiresSchemaVersion(major = 1, minor = 500)
+ public @NonNull Builder setStartY(@NonNull OffsetDimension startY) {
+ mImpl.setStartY(startY.toOffsetDimensionProto());
+ mFingerprint.recordPropertyUpdate(
+ 3, checkNotNull(startY.getFingerprint()).aggregateValueAsInt());
+ return this;
+ }
+
+ /**
+ * Sets the ending y position of the linear gradient. Defaults to the right side of the
+ * element.
+ */
+ @RequiresSchemaVersion(major = 1, minor = 500)
+ public @NonNull Builder setEndX(@NonNull OffsetDimension endX) {
+ mImpl.setEndX(endX.toOffsetDimensionProto());
+ mFingerprint.recordPropertyUpdate(
+ 4, checkNotNull(endX.getFingerprint()).aggregateValueAsInt());
+ return this;
+ }
+
+ /**
+ * Sets the ending y position of the linear gradient. Defaults to the top side of the
+ * element.
+ */
+ @RequiresSchemaVersion(major = 1, minor = 500)
+ public @NonNull Builder setEndY(@NonNull OffsetDimension endY) {
+ mImpl.setEndY(endY.toOffsetDimensionProto());
+ mFingerprint.recordPropertyUpdate(
+ 5, checkNotNull(endY.getFingerprint()).aggregateValueAsInt());
+ return this;
+ }
+
+ /**
+ * Creates an instance of {@link Builder}.
+ *
+ * @param colorStops The color stops defining how the colors are distributed from the
+ * start to the end coordinates.
+ * <p>A color stop is a pair of a color and its offset in the gradient. The offset
+ * is the relative position of the color, beginning with 0 from the start coordinate
+ * and ending with 1.0 at the end coordinate.
+ * @throws IllegalArgumentException if the number of colors is less than 2 or larger
+ * than 10.
+ */
+ @RequiresSchemaVersion(major = 1, minor = 500)
+ @SafeVarargs
+ public Builder(ColorStop @NonNull ... colorStops) {
+ if (colorStops.length < 2 || colorStops.length > 10) {
+ throw new IllegalArgumentException(
+ "Size of colorStops must not be less than 2 or greater than 10. Got "
+ + colorStops.length);
+ }
+ for (ColorStop colorStop : colorStops) {
+ addColorStop(colorStop);
+ }
+ }
+
+ /**
+ * Creates an instance of {@link Builder}.
+ *
+ * <p>The colors are evenly distributed in the gradient.
+ *
+ * @param colors The color sequence to be distributed between the gradient's start and
+ * end coordinates.
+ * @throws IllegalArgumentException if the number of colors is less than 2 or larger
+ * than 10.
+ */
+ @RequiresSchemaVersion(major = 1, minor = 500)
+ @SafeVarargs
+ public Builder(ColorProp @NonNull ... colors) {
+ if (colors.length < 2 || colors.length > 10) {
+ throw new IllegalArgumentException(
+ "Size of colors must not be less than 2 or greater than 10. Got "
+ + colors.length);
+ }
+ for (ColorProp colorProp : colors) {
+ ColorStop stop = new ColorStop.Builder().setColor(colorProp).build();
+ addColorStop(stop);
+ }
+ }
+
+ /**
+ * Builds an instance from accumulated values.
+ *
+ * @throws IllegalStateException if size of colorStops is less than 2 or greater than
+ * 10.
+ */
+ @Override
+ public @NonNull LinearGradient build() {
+ int colorStopsCount = mImpl.getColorStopsCount();
+ if (colorStopsCount < 2 || colorStopsCount > 10) {
+ throw new IllegalStateException(
+ "Size of colorStops must not be less than 2 or greater than 10");
+ }
+ return new LinearGradient(mImpl.build(), mFingerprint);
+ }
+ }
+ }
+
+ /**
* Interface defining a {@link Brush} describes how something is drawn on screen. It determines
* the color(s) that are drawn in the drawing area.
*/
@@ -591,6 +860,9 @@
if (proto.hasSweepGradient()) {
return SweepGradient.fromProto(proto.getSweepGradient(), fingerprint);
}
+ if (proto.hasLinearGradient()) {
+ return LinearGradient.fromProto(proto.getLinearGradient(), fingerprint);
+ }
throw new IllegalStateException("Proto was not a recognised instance of Brush");
}
diff --git a/wear/protolayout/protolayout/src/main/java/androidx/wear/protolayout/DimensionBuilders.java b/wear/protolayout/protolayout/src/main/java/androidx/wear/protolayout/DimensionBuilders.java
index 597e950..5f5a2d6 100644
--- a/wear/protolayout/protolayout/src/main/java/androidx/wear/protolayout/DimensionBuilders.java
+++ b/wear/protolayout/protolayout/src/main/java/androidx/wear/protolayout/DimensionBuilders.java
@@ -117,11 +117,12 @@
@OptIn(markerClass = ExperimentalProtoLayoutExtensionApi.class)
public static final class DpProp
implements AngularDimension,
- ContainerDimension,
- ImageDimension,
- SpacerDimension,
- ExtensionDimension,
- PivotDimension {
+ ContainerDimension,
+ ImageDimension,
+ SpacerDimension,
+ ExtensionDimension,
+ PivotDimension,
+ OffsetDimension {
private final DimensionProto.DpProp mImpl;
private final @Nullable Fingerprint mFingerprint;
@@ -215,6 +216,12 @@
}
@Override
+ @RestrictTo(Scope.LIBRARY_GROUP)
+ public DimensionProto.@NonNull OffsetDimension toOffsetDimensionProto() {
+ return DimensionProto.OffsetDimension.newBuilder().setOffsetDp(mImpl).build();
+ }
+
+ @Override
public @NonNull String toString() {
return "DpProp{" + "value=" + getValue() + ", dynamicValue=" + getDynamicValue() + "}";
}
@@ -227,7 +234,8 @@
ImageDimension.Builder,
SpacerDimension.Builder,
ExtensionDimension.Builder,
- PivotDimension.Builder {
+ PivotDimension.Builder,
+ OffsetDimension.Builder {
private final DimensionProto.DpProp.Builder mImpl = DimensionProto.DpProp.newBuilder();
private final Fingerprint mFingerprint = new Fingerprint(756413087);
@@ -600,9 +608,7 @@
}
}
- /**
- * Interface defining the length of an arc element.
- */
+ /** Interface defining the length of an arc element. */
@RequiresSchemaVersion(major = 1, minor = 500)
public interface AngularDimension {
/** Get the protocol buffer representation of this object. */
@@ -642,7 +648,7 @@
/** A type for angular dimensions, measured in degrees. */
@RequiresSchemaVersion(major = 1, minor = 0)
- public static final class DegreesProp implements AngularDimension{
+ public static final class DegreesProp implements AngularDimension {
private final DimensionProto.DegreesProp mImpl;
private final @Nullable Fingerprint mFingerprint;
@@ -715,7 +721,7 @@
/** Builder for {@link DegreesProp} */
@SuppressWarnings("HiddenSuperclass")
- public static final class Builder implements AngularDimension.Builder{
+ public static final class Builder implements AngularDimension.Builder {
private final DimensionProto.DegreesProp.Builder mImpl =
DimensionProto.DegreesProp.newBuilder();
private final Fingerprint mFingerprint = new Fingerprint(-1927567665);
@@ -1373,7 +1379,7 @@
/** Provide a position representation proportional to the bounding box width/height. */
@RequiresSchemaVersion(major = 1, minor = 400)
- public static final class BoundingBoxRatio implements PivotDimension {
+ public static final class BoundingBoxRatio implements PivotDimension, OffsetDimension {
private final DimensionProto.BoundingBoxRatio mImpl;
private final @Nullable Fingerprint mFingerprint;
@@ -1425,38 +1431,46 @@
}
@Override
+ @RestrictTo(Scope.LIBRARY_GROUP)
+ public DimensionProto.@NonNull OffsetDimension toOffsetDimensionProto() {
+ return DimensionProto.OffsetDimension.newBuilder().setLocationRatio(mImpl).build();
+ }
+
+ @Override
public @NonNull String toString() {
return "BoundingBoxRatio{" + "ratio=" + getRatio() + "}";
}
/** Builder for {@link BoundingBoxRatio}. */
@SuppressWarnings("HiddenSuperclass")
- public static final class Builder implements PivotDimension.Builder {
+ public static final class Builder
+ implements PivotDimension.Builder, OffsetDimension.Builder {
private final DimensionProto.BoundingBoxRatio.Builder mImpl =
DimensionProto.BoundingBoxRatio.newBuilder();
private final Fingerprint mFingerprint = new Fingerprint(-1387873430);
/**
* Creates an instance of {@link Builder}.
- * @param ratio the ratio proportional to the bounding box width/height. value 0
- * represents the location at the top / left of the bounding box and value 1
- * represents the location at the bottom / end of the bounding box. Its default
- * value 0.5 represents the middle of the bounding box. Values outside [0, 1]
- * are also valid. Dynamic value is supported.
+ *
+ * @param ratio the ratio relative to the bounding box width / height, with the bounding
+ * box top / left as 0 and bottom / right as 1. Values outside [0, 1] are also
+ * valid. Dynamic value is supported.
*/
@RequiresSchemaVersion(major = 1, minor = 400)
public Builder(@NonNull FloatProp ratio) {
- setRatio(ratio);
+ setRatio(ratio);
}
+ @RequiresSchemaVersion(major = 1, minor = 400)
+ Builder() {}
+
/**
- * Gets the ratio proportional to the bounding box width/height. value 0 represents the
- * location at the top / left of the bounding box and value 1 represents the location at
- * the bottom / end of the bounding box. Its default value 0.5 represents the middle
- * of the bounding box. Values outside [0, 1] are also valid. Dynamic value is
- * supported.
+ * Sets the ratio relative to the bounding box width / height, with the bounding box top
+ * / left as 0 and bottom / right as 1. Values outside [0, 1] are also valid. Dynamic
+ * value is supported.
*/
- private @NonNull Builder setRatio(@NonNull FloatProp ratio) {
+ @RequiresSchemaVersion(major = 1, minor = 400)
+ @NonNull Builder setRatio(@NonNull FloatProp ratio) {
mImpl.setRatio(ratio.toProto());
mFingerprint.recordPropertyUpdate(
1, checkNotNull(ratio.getFingerprint()).aggregateValueAsInt());
@@ -1511,4 +1525,44 @@
DimensionProto.@NonNull PivotDimension proto) {
return pivotDimensionFromProto(proto, null);
}
+
+ /**
+ * Interface defining a dimension that represents an offset relative to the element's position.
+ */
+ @RequiresSchemaVersion(major = 1, minor = 500)
+ public interface OffsetDimension {
+ /** Get the protocol buffer representation of this object. */
+ @RestrictTo(Scope.LIBRARY_GROUP)
+ DimensionProto.@NonNull OffsetDimension toOffsetDimensionProto();
+
+ /** Get the fingerprint for this object or null if unknown. */
+ @RestrictTo(Scope.LIBRARY_GROUP)
+ @Nullable Fingerprint getFingerprint();
+
+ /** Builder to create {@link OffsetDimension} objects. */
+ @RestrictTo(Scope.LIBRARY_GROUP)
+ interface Builder {
+
+ /** Builds an instance with values accumulated in this Builder. */
+ @NonNull OffsetDimension build();
+ }
+ }
+
+ /** Creates a new wrapper instance from the proto. */
+ @RestrictTo(Scope.LIBRARY_GROUP)
+ public static @NonNull OffsetDimension offsetDimensionFromProto(
+ DimensionProto.@NonNull OffsetDimension proto, @Nullable Fingerprint fingerprint) {
+ if (proto.hasOffsetDp()) {
+ return DpProp.fromProto(proto.getOffsetDp(), fingerprint);
+ }
+ if (proto.hasLocationRatio()) {
+ return BoundingBoxRatio.fromProto(proto.getLocationRatio(), fingerprint);
+ }
+ throw new IllegalStateException("Proto was not a recognised instance of OffsetDimension");
+ }
+
+ static @NonNull OffsetDimension offsetDimensionFromProto(
+ DimensionProto.@NonNull OffsetDimension proto) {
+ return offsetDimensionFromProto(proto, null);
+ }
}
diff --git a/wear/protolayout/protolayout/src/main/java/androidx/wear/protolayout/LayoutElementBuilders.java b/wear/protolayout/protolayout/src/main/java/androidx/wear/protolayout/LayoutElementBuilders.java
index afd1fc7..548240c 100644
--- a/wear/protolayout/protolayout/src/main/java/androidx/wear/protolayout/LayoutElementBuilders.java
+++ b/wear/protolayout/protolayout/src/main/java/androidx/wear/protolayout/LayoutElementBuilders.java
@@ -39,6 +39,7 @@
import androidx.annotation.VisibleForTesting;
import androidx.wear.protolayout.ColorBuilders.Brush;
import androidx.wear.protolayout.ColorBuilders.ColorProp;
+import androidx.wear.protolayout.ColorBuilders.SweepGradient;
import androidx.wear.protolayout.DeviceParametersBuilders.DeviceParameters;
import androidx.wear.protolayout.DimensionBuilders.AngularDimension;
import androidx.wear.protolayout.DimensionBuilders.AngularLayoutConstraint;
@@ -690,10 +691,9 @@
return Collections.unmodifiableList(list);
}
-
/**
- * Gets whether the text should be rendered in a italic typeface. If not specified, defaults to
- * "false".
+ * Gets whether the text should be rendered in a italic typeface. If not specified, defaults
+ * to "false".
*/
public @Nullable BoolProp getItalic() {
return isItalic();
@@ -999,8 +999,7 @@
SpProp spPropSize = sp(size);
mImpl.addSize(spPropSize.toProto());
mFingerprint.recordPropertyUpdate(
- 1,
- checkNotNull(spPropSize.getFingerprint()).aggregateValueAsInt());
+ 1, checkNotNull(spPropSize.getFingerprint()).aggregateValueAsInt());
}
return this;
}
@@ -1036,7 +1035,7 @@
*
* @param fontFamily preferred font family name to be used if available
* @param fallbacks the ordered list of fallback font family to attempt to use if the
- * preferred font family is not available.
+ * preferred font family is not available.
*/
@RequiresSchemaVersion(major = 1, minor = 400)
public @NonNull Builder setPreferredFontFamilies(
@@ -1061,13 +1060,14 @@
* {@link FontSetting#width} setting will always be available.
*
* @throws IllegalArgumentException if the number of the given Setting is larger than
- * 10.
+ * 10.
*/
@RequiresSchemaVersion(major = 1, minor = 400)
public @NonNull Builder setSettings(FontSetting @NonNull ... settings) {
if (settings.length > SETTINGS_LIMIT) {
throw new IllegalArgumentException(
- "Number of given FontSetting can't be larger than " + SETTINGS_LIMIT
+ "Number of given FontSetting can't be larger than "
+ + SETTINGS_LIMIT
+ ".");
}
@@ -1126,7 +1126,7 @@
* FontStyle.Builder#setWeight}.
*
* @param value weight, usually in 1..1000, but actual range can be smaller, depending on
- * the font used
+ * the font used
*/
@RequiresSchemaVersion(major = 1, minor = 400)
static @NonNull FontSetting weight(@IntRange(from = 1, to = 1000) int value) {
@@ -1593,9 +1593,9 @@
* 1.2 and renderers supporting version 1.2 will use the dynamic value (if set).
*
* <p>When using a dynamic value, make sure to specify the bounding constraints for the
- * affected layout element through
- * {@code setLayoutConstraintsForDynamicText(StringLayoutConstraint)} otherwise
- * {@code build()} fails.
+ * affected layout element through {@code
+ * setLayoutConstraintsForDynamicText(StringLayoutConstraint)} otherwise {@code build()}
+ * fails.
*/
public @Nullable StringProp getText() {
if (mImpl.hasText()) {
@@ -2940,7 +2940,8 @@
@RequiresSchemaVersion(major = 1, minor = 0)
public @NonNull Builder setText(@NonNull StringProp text) {
if (text.getDynamicValue() != null) {
- throw new IllegalArgumentException("SpanText.Builder.setText doesn't support dynamic values.");
+ throw new IllegalArgumentException(
+ "SpanText.Builder.setText doesn't support dynamic values.");
}
mImpl.setText(text.toProto());
mFingerprint.recordPropertyUpdate(
@@ -4260,7 +4261,7 @@
}
}
- /** Gets defines the direction in which text is drawn.*/
+ /** Gets defines the direction in which text is drawn. */
public @Nullable ArcDirectionProp getArcDirection() {
if (mImpl.hasArcDirection()) {
return ArcDirectionProp.fromProto(mImpl.getArcDirection());
@@ -4415,9 +4416,9 @@
* 1.2 and renderers supporting version 1.2 will use the dynamic value (if set).
*
* <p>When using a dynamic value, make sure to specify the bounding constraints for the
- * affected layout element through
- * {@code setLayoutConstraintsForDynamicLength(AngularLayoutConstraint)} otherwise {@code
- * build()} fails.
+ * affected layout element through {@code
+ * setLayoutConstraintsForDynamicLength(AngularLayoutConstraint)} otherwise {@code build()}
+ * fails.
*/
public @Nullable DegreesProp getLength() {
if (mImpl.hasLength()) {
@@ -4632,9 +4633,15 @@
/**
* Sets a brush used to draw this line. If set, the brush will be used instead of the
* color provided in {@code setColor()}.
+ *
+ * @throws IllegalArgumentException if the brush is not a {@link SweepGradient}.
*/
@RequiresSchemaVersion(major = 1, minor = 300)
public @NonNull Builder setBrush(@NonNull Brush brush) {
+ if (!(brush instanceof SweepGradient)) {
+ throw new IllegalArgumentException(
+ "Only SweepGradient is supported for ArcLine.");
+ }
mImpl.setBrush(brush.toBrushProto());
mFingerprint.recordPropertyUpdate(
7, checkNotNull(brush.getFingerprint()).aggregateValueAsInt());
@@ -4701,7 +4708,7 @@
String onlyOpaqueMsg = "Only opaque colors are supported";
String alphaChangeMsg =
"Any transparent colors will have their alpha component set to 0xFF"
- + " (opaque).";
+ + " (opaque).";
for (ColorProto.ColorStop colorStop :
mImpl.getBrush().getSweepGradient().getColorStopsList()) {
if (Color.alpha(colorStop.getColor().getArgb()) < 0xFF) {
@@ -4835,9 +4842,7 @@
this.mFingerprint = fingerprint;
}
- /**
- * Gets the length of this line in degrees, including gaps.
- */
+ /** Gets the length of this line in degrees, including gaps. */
public @Nullable DegreesProp getLength() {
if (mImpl.hasLength()) {
return DegreesProp.fromProto(mImpl.getLength());
@@ -4978,9 +4983,7 @@
return this;
}
- /**
- * Sets the thickness of this line. If not defined, defaults to 0.
- */
+ /** Sets the thickness of this line. If not defined, defaults to 0. */
@RequiresSchemaVersion(major = 1, minor = 500)
public @NonNull Builder setThickness(@Dimension(unit = DP) float thickness) {
DpProp thicknessProp = dp(thickness);
@@ -4990,9 +4993,7 @@
return this;
}
- /**
- * Sets the color of this line.
- */
+ /** Sets the color of this line. */
@RequiresSchemaVersion(major = 1, minor = 500)
public @NonNull Builder setColor(@NonNull ColorProp color) {
mImpl.setColor(color.toProto());
@@ -5044,6 +5045,7 @@
6, checkNotNull(linePattern.getFingerprint()).aggregateValueAsInt());
return this;
}
+
/**
* Sets the bounding constraints for the layout affected by the dynamic value from
* {@link #setLength(DegreesProp)}.
@@ -5187,7 +5189,7 @@
* Sets the list of each gap's center location in degrees.
*
* <p>The interval between any two locations must not be shorter than thickness plus gap
- * size, otherwise the gap is ignored.
+ * size, otherwise the gap is ignored.
*
* <p>Note that calling this method will invalidate the previous call of {@link
* #setGapInterval}
@@ -5196,7 +5198,7 @@
public @NonNull Builder setGapLocations(float @NonNull ... gapLocationsInDegrees) {
mImpl.clearGapLocations();
- for (float gapLocation: gapLocationsInDegrees) {
+ for (float gapLocation : gapLocationsInDegrees) {
addGapLocation(degrees(gapLocation));
}
@@ -5240,7 +5242,6 @@
}
}
-
/** A simple spacer used to provide padding between adjacent elements in an {@link Arc}. */
@RequiresSchemaVersion(major = 1, minor = 0)
public static final class ArcSpacer implements ArcLayoutElement {
@@ -5279,7 +5280,7 @@
}
}
- /** Gets the length of this spacer.*/
+ /** Gets the length of this spacer. */
public @Nullable AngularDimension getAngularLength() {
if (mImpl.hasAngularLength()) {
return DimensionBuilders.angularDimensionFromProto(mImpl.getAngularLength());
@@ -5393,16 +5394,16 @@
* Sets the length of this spacer. If not defined, defaults to 0 degrees. If set, this
* angular length will be used instead of the value provided in {@code setLength()}.
*
- * <p>Note that this field only supports static values.
+ * <p>Note that this field only supports static values.
*/
@RequiresSchemaVersion(major = 1, minor = 500)
public @NonNull Builder setAngularLength(@NonNull AngularDimension angularLength) {
- DimensionProto. AngularDimension angularDimensionProto =
+ DimensionProto.AngularDimension angularDimensionProto =
angularLength.toAngularDimensionProto();
if ((angularDimensionProto.hasDegrees()
- && angularDimensionProto.getDegrees().getDynamicValue() != null)
+ && angularDimensionProto.getDegrees().getDynamicValue() != null)
|| (angularDimensionProto.hasDp()
- && angularDimensionProto.getDp().getDynamicValue() != null)) {
+ && angularDimensionProto.getDp().getDynamicValue() != null)) {
throw new IllegalArgumentException(
"ArcSpacer.Builder.setAngularLength doesn't support dynamic values.");
}
@@ -5457,14 +5458,13 @@
}
}
-
/**
- * Gets whether this adapter's contents should be rotated, according to its position in the arc
- * or not. As an example, assume that an {@link Image} has been added to the arc, and ends up at
- * the 3 o clock position. If rotate_contents = true, the image will be placed at the 3 o clock
- * position, and will be rotated clockwise through 90 degrees. If rotate_contents = false, the
- * image will be placed at the 3 o clock position, but itself will not be rotated. If not
- * defined, defaults to false.
+ * Gets whether this adapter's contents should be rotated, according to its position in the
+ * arc or not. As an example, assume that an {@link Image} has been added to the arc, and
+ * ends up at the 3 o clock position. If rotate_contents = true, the image will be placed at
+ * the 3 o clock position, and will be rotated clockwise through 90 degrees. If
+ * rotate_contents = false, the image will be placed at the 3 o clock position, but itself
+ * will not be rotated. If not defined, defaults to false.
*/
public @Nullable BoolProp getRotateContents() {
return isRotateContents();
@@ -5582,8 +5582,8 @@
}
/**
- * An extensible {@code ArcDirection} property that can be set to any curved element to
- * control the drawing direction.
+ * An extensible {@code ArcDirection} property that can be set to any curved element to control
+ * the drawing direction.
*/
@RequiresSchemaVersion(major = 1, minor = 300)
public static final class ArcDirectionProp {
@@ -5591,8 +5591,7 @@
private final @Nullable Fingerprint mFingerprint;
ArcDirectionProp(
- LayoutElementProto.ArcDirectionProp impl,
- @Nullable Fingerprint fingerprint) {
+ LayoutElementProto.ArcDirectionProp impl, @Nullable Fingerprint fingerprint) {
this.mImpl = impl;
this.mFingerprint = fingerprint;
}
@@ -6633,8 +6632,7 @@
*/
@Deprecated
public static FontStyle.@NonNull Builder body1(@NonNull DeviceParameters deviceParameters) {
- return new FontStyle.Builder()
- .setSize(sp(isLargeScreen(deviceParameters) ? 18 : 16));
+ return new FontStyle.Builder().setSize(sp(isLargeScreen(deviceParameters) ? 18 : 16));
}
/**
@@ -6645,8 +6643,7 @@
*/
@Deprecated
public static FontStyle.@NonNull Builder body2(@NonNull DeviceParameters deviceParameters) {
- return new FontStyle.Builder()
- .setSize(sp(isLargeScreen(deviceParameters) ? 16 : 14));
+ return new FontStyle.Builder().setSize(sp(isLargeScreen(deviceParameters) ? 16 : 14));
}
/**
@@ -6672,8 +6669,7 @@
@Deprecated
public static FontStyle.@NonNull Builder caption1(
@NonNull DeviceParameters deviceParameters) {
- return new FontStyle.Builder()
- .setSize(sp(isLargeScreen(deviceParameters) ? 16 : 14));
+ return new FontStyle.Builder().setSize(sp(isLargeScreen(deviceParameters) ? 16 : 14));
}
/**
@@ -6685,45 +6681,44 @@
@Deprecated
public static FontStyle.@NonNull Builder caption2(
@NonNull DeviceParameters deviceParameters) {
- return new FontStyle.Builder()
- .setSize(sp(isLargeScreen(deviceParameters) ? 14 : 12));
+ return new FontStyle.Builder().setSize(sp(isLargeScreen(deviceParameters) ? 14 : 12));
}
private FontStyles() {}
}
- /** Checks whether a layout element has a transformation modifier. */
- private static boolean hasTransformation(LayoutElementProto.@NonNull LayoutElement content) {
- switch (content.getInnerCase()) {
- case IMAGE:
- return content.getImage().hasModifiers()
- && content.getImage().getModifiers().hasTransformation();
- case TEXT:
- return content.getText().hasModifiers()
- && content.getText().getModifiers().hasTransformation();
- case SPACER:
- return content.getSpacer().hasModifiers()
- && content.getSpacer().getModifiers().hasTransformation();
- case BOX:
- return content.getBox().hasModifiers()
- && content.getBox().getModifiers().hasTransformation();
- case ROW:
- return content.getRow().hasModifiers()
- && content.getRow().getModifiers().hasTransformation();
- case COLUMN:
- return content.getColumn().hasModifiers()
- && content.getColumn().getModifiers().hasTransformation();
- case SPANNABLE:
- return content.getSpannable().hasModifiers()
- && content.getSpannable().getModifiers().hasTransformation();
- case ARC:
- return content.getArc().hasModifiers()
- && content.getArc().getModifiers().hasTransformation();
- case EXTENSION:
- // fall through
- case INNER_NOT_SET:
+ /** Checks whether a layout element has a transformation modifier. */
+ private static boolean hasTransformation(LayoutElementProto.@NonNull LayoutElement content) {
+ switch (content.getInnerCase()) {
+ case IMAGE:
+ return content.getImage().hasModifiers()
+ && content.getImage().getModifiers().hasTransformation();
+ case TEXT:
+ return content.getText().hasModifiers()
+ && content.getText().getModifiers().hasTransformation();
+ case SPACER:
+ return content.getSpacer().hasModifiers()
+ && content.getSpacer().getModifiers().hasTransformation();
+ case BOX:
+ return content.getBox().hasModifiers()
+ && content.getBox().getModifiers().hasTransformation();
+ case ROW:
+ return content.getRow().hasModifiers()
+ && content.getRow().getModifiers().hasTransformation();
+ case COLUMN:
+ return content.getColumn().hasModifiers()
+ && content.getColumn().getModifiers().hasTransformation();
+ case SPANNABLE:
+ return content.getSpannable().hasModifiers()
+ && content.getSpannable().getModifiers().hasTransformation();
+ case ARC:
+ return content.getArc().hasModifiers()
+ && content.getArc().getModifiers().hasTransformation();
+ case EXTENSION:
+ // fall through
+ case INNER_NOT_SET:
+ return false;
+ }
return false;
}
- return false;
- }
}
diff --git a/wear/protolayout/protolayout/src/main/java/androidx/wear/protolayout/ModifiersBuilders.java b/wear/protolayout/protolayout/src/main/java/androidx/wear/protolayout/ModifiersBuilders.java
index 9496a5c..d193cb2 100644
--- a/wear/protolayout/protolayout/src/main/java/androidx/wear/protolayout/ModifiersBuilders.java
+++ b/wear/protolayout/protolayout/src/main/java/androidx/wear/protolayout/ModifiersBuilders.java
@@ -27,7 +27,9 @@
import androidx.annotation.RestrictTo;
import androidx.annotation.RestrictTo.Scope;
import androidx.wear.protolayout.ActionBuilders.Action;
+import androidx.wear.protolayout.ColorBuilders.Brush;
import androidx.wear.protolayout.ColorBuilders.ColorProp;
+import androidx.wear.protolayout.ColorBuilders.LinearGradient;
import androidx.wear.protolayout.DimensionBuilders.DegreesProp;
import androidx.wear.protolayout.DimensionBuilders.DpProp;
import androidx.wear.protolayout.DimensionBuilders.PivotDimension;
@@ -1034,13 +1036,13 @@
}
/**
- * A radius with values on both horizontal and vertical axes set to zero. It can be used
- * to have right-angle corners.
+ * A radius with values on both horizontal and vertical axes set to zero. It can be used to
+ * have right-angle corners.
*/
@RequiresSchemaVersion(major = 1, minor = 400)
private static final CornerRadius ZERO =
- new CornerRadius.Builder(new DpProp.Builder(0f).build(),
- new DpProp.Builder(0f).build())
+ new CornerRadius.Builder(
+ new DpProp.Builder(0f).build(), new DpProp.Builder(0f).build())
.build();
/** Get the fingerprint for this object, or null if unknown. */
@@ -1091,8 +1093,7 @@
}
@RequiresSchemaVersion(major = 1, minor = 400)
- Builder() {
- }
+ Builder() {}
/**
* Sets the radius value in dp on the horizontal axis.
@@ -1195,10 +1196,8 @@
private @NonNull CornerRadius toCornerRadius(@Nullable DpProp radius) {
return radius == null
? CornerRadius.ZERO
- : new CornerRadius.Builder(
- dp(radius.getValue()),
- dp(radius.getValue())
- ).build();
+ : new CornerRadius.Builder(dp(radius.getValue()), dp(radius.getValue()))
+ .build();
}
/** Get the fingerprint for this object, or null if unknown. */
@@ -1326,8 +1325,8 @@
* or defaults to zeros when radius is also not set.
*/
@RequiresSchemaVersion(major = 1, minor = 400)
- public @NonNull Builder setTopLeftRadius(@NonNull DpProp xRadius,
- @NonNull DpProp yRadius) {
+ public @NonNull Builder setTopLeftRadius(
+ @NonNull DpProp xRadius, @NonNull DpProp yRadius) {
return setTopLeftRadius(new CornerRadius.Builder(xRadius, yRadius).build());
}
@@ -1337,8 +1336,8 @@
* or defaults to zeros when radius is also not set.
*/
@RequiresSchemaVersion(major = 1, minor = 400)
- public @NonNull Builder setTopRightRadius(@NonNull DpProp xRadius,
- @NonNull DpProp yRadius) {
+ public @NonNull Builder setTopRightRadius(
+ @NonNull DpProp xRadius, @NonNull DpProp yRadius) {
return setTopRightRadius(new CornerRadius.Builder(xRadius, yRadius).build());
}
@@ -1348,8 +1347,8 @@
* set; or defaults to zeros when radius is also not set.
*/
@RequiresSchemaVersion(major = 1, minor = 400)
- public @NonNull Builder setBottomRightRadius(@NonNull DpProp xRadius,
- @NonNull DpProp yRadius) {
+ public @NonNull Builder setBottomRightRadius(
+ @NonNull DpProp xRadius, @NonNull DpProp yRadius) {
return setBottomRightRadius(new CornerRadius.Builder(xRadius, yRadius).build());
}
@@ -1359,8 +1358,8 @@
* set; or defaults to zeros when radius is also not set.
*/
@RequiresSchemaVersion(major = 1, minor = 400)
- public @NonNull Builder setBottomLeftRadius(@NonNull DpProp xRadius,
- @NonNull DpProp yRadius) {
+ public @NonNull Builder setBottomLeftRadius(
+ @NonNull DpProp xRadius, @NonNull DpProp yRadius) {
return setBottomLeftRadius(new CornerRadius.Builder(xRadius, yRadius).build());
}
@@ -1388,6 +1387,9 @@
*
* <p>While this field is statically accessible from 1.0, it's only bindable since version
* 1.2 and renderers supporting version 1.2 will use the dynamic value (if set).
+ *
+ * <p>If a brush is set, this color will only be used if brush is not supported by the
+ * renderer (versions below 1.5).
*/
public @Nullable ColorProp getColor() {
if (mImpl.hasColor()) {
@@ -1410,6 +1412,18 @@
}
}
+ /**
+ * Gets a brush used to draw the background. If set, the brush will be used instead of the
+ * color provided in {@code setColor()}.
+ */
+ public @Nullable Brush getBrush() {
+ if (mImpl.hasBrush()) {
+ return ColorBuilders.brushFromProto(mImpl.getBrush());
+ } else {
+ return null;
+ }
+ }
+
/** Get the fingerprint for this object, or null if unknown. */
@RestrictTo(Scope.LIBRARY_GROUP)
public @Nullable Fingerprint getFingerprint() {
@@ -1435,7 +1449,14 @@
@Override
public @NonNull String toString() {
- return "Background{" + "color=" + getColor() + ", corner=" + getCorner() + "}";
+ return "Background{"
+ + "color="
+ + getColor()
+ + ", corner="
+ + getCorner()
+ + ", brush="
+ + getBrush()
+ + "}";
}
/** Builder for {@link Background} */
@@ -1453,6 +1474,9 @@
*
* <p>While this field is statically accessible from 1.0, it's only bindable since
* version 1.2 and renderers supporting version 1.2 will use the dynamic value (if set).
+ *
+ * <p>If a brush is set, this color will only be used if brush is not supported by the
+ * renderer (versions below 1.5).
*/
@RequiresSchemaVersion(major = 1, minor = 0)
public @NonNull Builder setColor(@NonNull ColorProp color) {
@@ -1475,6 +1499,24 @@
return this;
}
+ /**
+ * Sets a brush used to draw the background. If set and supported, the brush will be
+ * used instead of the color provided in {@code setColor()}.
+ *
+ * @throws IllegalArgumentException if the brush is not a {@link LinearGradient}.
+ */
+ @RequiresSchemaVersion(major = 1, minor = 500)
+ public @NonNull Builder setBrush(@NonNull Brush brush) {
+ if (!(brush instanceof LinearGradient)) {
+ throw new IllegalArgumentException(
+ "Only LinearGradient is supported for Background.");
+ }
+ mImpl.setBrush(brush.toBrushProto());
+ mFingerprint.recordPropertyUpdate(
+ 3, checkNotNull(brush.getFingerprint()).aggregateValueAsInt());
+ return this;
+ }
+
/** Builds an instance from accumulated values. */
public @NonNull Background build() {
return new Background(mImpl.build(), mFingerprint);
diff --git a/wear/protolayout/protolayout/src/test/java/androidx/wear/protolayout/ColorBuildersTest.java b/wear/protolayout/protolayout/src/test/java/androidx/wear/protolayout/ColorBuildersTest.java
index 7910b4e..9c67535 100644
--- a/wear/protolayout/protolayout/src/test/java/androidx/wear/protolayout/ColorBuildersTest.java
+++ b/wear/protolayout/protolayout/src/test/java/androidx/wear/protolayout/ColorBuildersTest.java
@@ -16,6 +16,9 @@
package androidx.wear.protolayout;
+import static androidx.wear.protolayout.ColorBuilders.argb;
+import static androidx.wear.protolayout.DimensionBuilders.dp;
+
import static com.google.common.truth.Truth.assertThat;
import static org.junit.Assert.assertThrows;
@@ -23,8 +26,13 @@
import android.graphics.Color;
import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.wear.protolayout.ColorBuilders.LinearGradient;
+import androidx.wear.protolayout.DimensionBuilders.BoundingBoxRatio;
+import androidx.wear.protolayout.DimensionBuilders.DpProp;
+import androidx.wear.protolayout.TypeBuilders.FloatProp;
import androidx.wear.protolayout.expression.AppDataKey;
import androidx.wear.protolayout.expression.DynamicBuilders;
+import androidx.wear.protolayout.expression.DynamicBuilders.DynamicFloat;
import androidx.wear.protolayout.proto.ColorProto;
import org.junit.Test;
@@ -50,8 +58,40 @@
@SuppressWarnings("deprecation") // Intentionally no static value.
@Test
public void colorProp_withoutStaticValue_throws() {
- assertThrows(IllegalStateException.class, new ColorBuilders.ColorProp.Builder()
- .setDynamicValue(
- DynamicBuilders.DynamicColor.from(new AppDataKey<>(STATE_KEY)))::build);
+ assertThrows(
+ IllegalStateException.class,
+ new ColorBuilders.ColorProp.Builder()
+ .setDynamicValue(
+ DynamicBuilders.DynamicColor.from(
+ new AppDataKey<>(STATE_KEY)))
+ ::build);
+ }
+
+ @Test
+ public void linearGradient_supportsDynamicOffsets() {
+ DynamicFloat dynamicFloat = DynamicFloat.constant(1.0f);
+ DpProp startX = dp(0f);
+ DpProp startY = new DpProp.Builder(0f).setDynamicValue(dynamicFloat).build();
+ BoundingBoxRatio endX =
+ new BoundingBoxRatio.Builder()
+ .setRatio(new FloatProp.Builder(1.0f).build())
+ .build();
+ BoundingBoxRatio endY =
+ new BoundingBoxRatio.Builder()
+ .setRatio(new FloatProp.Builder(1.0f).setDynamicValue(dynamicFloat).build())
+ .build();
+ LinearGradient linearGrad =
+ new LinearGradient.Builder(argb(Color.BLUE), argb(Color.RED))
+ .setStartX(startX)
+ .setStartY(startY)
+ .setEndX(endX)
+ .setEndY(endY)
+ .build();
+
+ assertThat(((DpProp) linearGrad.getStartX()).getValue()).isEqualTo(startX.getValue());
+ assertThat(((DpProp) linearGrad.getStartY()).getDynamicValue()).isNotNull();
+ assertThat(((BoundingBoxRatio) linearGrad.getEndX()).getRatio().getValue()).isEqualTo(1.0f);
+ assertThat(((BoundingBoxRatio) linearGrad.getEndY()).getRatio().getDynamicValue())
+ .isNotNull();
}
}
diff --git a/wear/protolayout/protolayout/src/test/java/androidx/wear/protolayout/ModifiersBuildersTest.java b/wear/protolayout/protolayout/src/test/java/androidx/wear/protolayout/ModifiersBuildersTest.java
index 4aa3c19..8bafddd 100644
--- a/wear/protolayout/protolayout/src/test/java/androidx/wear/protolayout/ModifiersBuildersTest.java
+++ b/wear/protolayout/protolayout/src/test/java/androidx/wear/protolayout/ModifiersBuildersTest.java
@@ -26,8 +26,13 @@
import android.graphics.Color;
import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.wear.protolayout.ColorBuilders.ColorProp;
+import androidx.wear.protolayout.ColorBuilders.LinearGradient;
+import androidx.wear.protolayout.ColorBuilders.SweepGradient;
+import androidx.wear.protolayout.ModifiersBuilders.Background;
import androidx.wear.protolayout.expression.AppDataKey;
import androidx.wear.protolayout.expression.DynamicBuilders;
+import androidx.wear.protolayout.proto.ColorProto;
import androidx.wear.protolayout.proto.ModifiersProto;
import org.junit.Test;
@@ -36,8 +41,8 @@
@RunWith(AndroidJUnit4.class)
public class ModifiersBuildersTest {
private static final String STATE_KEY = "state-key";
- private static final ColorBuilders.ColorProp COLOR =
- new ColorBuilders.ColorProp.Builder(Color.RED)
+ private static final ColorProp COLOR =
+ new ColorProp.Builder(Color.RED)
.setDynamicValue(DynamicBuilders.DynamicColor.from(new AppDataKey<>(STATE_KEY)))
.build();
@@ -54,8 +59,7 @@
@Test
public void backgroundSupportsDynamicColor() {
- ModifiersBuilders.Background background1 =
- new ModifiersBuilders.Background.Builder().setColor(COLOR).build();
+ Background background1 = new Background.Builder().setColor(COLOR).build();
ModifiersProto.Background background1Proto = background1.toProto();
assertThat(background1Proto.getColor().getArgb()).isEqualTo(COLOR.getArgb());
@@ -95,7 +99,7 @@
() ->
new ModifiersBuilders.Shadow.Builder()
.setColor(
- new ColorBuilders.ColorProp.Builder(Color.BLACK)
+ new ColorProp.Builder(Color.BLACK)
.setDynamicValue(
DynamicBuilders.DynamicColor.constant(
Color.GRAY))
@@ -169,7 +173,7 @@
@Test
public void buildAsymmetricalCornerModifier() {
- float [] values = new float[]{1f, 2f, 3f, 4f, 5f, 6f, 7f, 8f};
+ float[] values = new float[] {1f, 2f, 3f, 4f, 5f, 6f, 7f, 8f};
ModifiersBuilders.Corner cornerModifier =
new ModifiersBuilders.Corner.Builder()
.setTopLeftRadius(dp(values[0]), dp(values[1]))
@@ -203,11 +207,9 @@
new DimensionBuilders.DpProp.Builder(2.f)
.setDynamicValue(
DynamicBuilders.DynamicFloat.animate(
- 2.f,
- 5.f))
+ 2.f, 5.f))
.build(),
- dp(1f))
- );
+ dp(1f)));
}
@Test
@@ -221,8 +223,7 @@
new DimensionBuilders.DpProp.Builder(2.f)
.setDynamicValue(
DynamicBuilders.DynamicFloat.animate(
- 2.f,
- 5.f))
+ 2.f, 5.f))
.build()));
}
@@ -247,4 +248,25 @@
assertThat(cornerRadius.getX().getValue()).isEqualTo(5f);
assertThat(cornerRadius.getY().getValue()).isEqualTo(5f);
}
+
+ @Test
+ public void backgroundSupportsLinearGradient() {
+ Background backgroundLinear =
+ new Background.Builder()
+ .setBrush(
+ new LinearGradient.Builder(argb(Color.BLUE), argb(Color.RED))
+ .build())
+ .build();
+ ModifiersProto.Background backgroundLinearProto = backgroundLinear.toProto();
+ assertThat(backgroundLinearProto.getBrush().getInnerCase())
+ .isEqualTo(ColorProto.Brush.InnerCase.LINEAR_GRADIENT);
+ }
+
+ @Test
+ public void background_withSweepGradient_throws() {
+ SweepGradient sweep = new SweepGradient.Builder(argb(Color.BLUE), argb(Color.RED)).build();
+ assertThrows(
+ IllegalArgumentException.class,
+ () -> new Background.Builder().setBrush(sweep).build());
+ }
}
diff --git a/window/window-demos/demo/lint-baseline.xml b/window/window-demos/demo/lint-baseline.xml
index 57a5f51..d4d73fc 100644
--- a/window/window-demos/demo/lint-baseline.xml
+++ b/window/window-demos/demo/lint-baseline.xml
@@ -1,5 +1,5 @@
<?xml version="1.0" encoding="UTF-8"?>
-<issues format="6" by="lint 8.8.0-alpha08" type="baseline" client="gradle" dependencies="false" name="AGP (8.8.0-alpha08)" variant="all" version="8.8.0-alpha08">
+<issues format="6" by="lint 8.9.0-alpha06" type="baseline" client="gradle" dependencies="false" name="AGP (8.9.0-alpha06)" variant="all" version="8.9.0-alpha06">
<issue
id="NewApi"
@@ -29,19 +29,19 @@
</issue>
<issue
- id="WrongConstant"
- message="Must be one or more of: LayoutParams.FLAG_ALLOW_LOCK_WHILE_SCREEN_ON, LayoutParams.FLAG_DIM_BEHIND, LayoutParams.FLAG_BLUR_BEHIND, LayoutParams.FLAG_NOT_FOCUSABLE, LayoutParams.FLAG_NOT_TOUCHABLE, LayoutParams.FLAG_NOT_TOUCH_MODAL, LayoutParams.FLAG_TOUCHABLE_WHEN_WAKING, LayoutParams.FLAG_KEEP_SCREEN_ON, LayoutParams.FLAG_LAYOUT_IN_SCREEN, LayoutParams.FLAG_LAYOUT_NO_LIMITS, LayoutParams.FLAG_FULLSCREEN, LayoutParams.FLAG_FORCE_NOT_FULLSCREEN, LayoutParams.FLAG_DITHER, LayoutParams.FLAG_SECURE, LayoutParams.FLAG_SCALED, LayoutParams.FLAG_IGNORE_CHEEK_PRESSES, LayoutParams.FLAG_LAYOUT_INSET_DECOR, LayoutParams.FLAG_ALT_FOCUSABLE_IM, LayoutParams.FLAG_WATCH_OUTSIDE_TOUCH, LayoutParams.FLAG_SHOW_WHEN_LOCKED, LayoutParams.FLAG_SHOW_WALLPAPER, LayoutParams.FLAG_TURN_SCREEN_ON, LayoutParams.FLAG_DISMISS_KEYGUARD, LayoutParams.FLAG_SPLIT_TOUCH, LayoutParams.FLAG_HARDWARE_ACCELERATED, LayoutParams.FLAG_LAYOUT_IN_OVERSCAN, LayoutParams.FLAG_TRANSLUCENT_STATUS, LayoutParams.FLAG_TRANSLUCENT_NAVIGATION, LayoutParams.FLAG_LOCAL_FOCUS_MODE, LayoutParams.FLAG_LAYOUT_ATTACHED_IN_DECOR, LayoutParams.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS"
- errorLine1=" ?.or(android.R.attr.showWhenLocked or android.R.attr.turnScreenOn)"
- errorLine2=" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~">
+ id="NewApi"
+ message="Call requires API level 30 (current min is 23): `android.view.WindowManager.LayoutParams#setFitInsetsTypes`"
+ errorLine1=" attrs.fitInsetsTypes = WindowInsets.Type.statusBars()"
+ errorLine2=" ~">
<location
- file="src/main/java/androidx/window/demo/PresentationActivity.kt"/>
+ file="src/main/java/androidx/window/demo/embedding/SplitImeActivityPlaceholder.kt"/>
</issue>
<issue
id="WrongConstant"
message="Must be one or more of: LayoutParams.FLAG_ALLOW_LOCK_WHILE_SCREEN_ON, LayoutParams.FLAG_DIM_BEHIND, LayoutParams.FLAG_BLUR_BEHIND, LayoutParams.FLAG_NOT_FOCUSABLE, LayoutParams.FLAG_NOT_TOUCHABLE, LayoutParams.FLAG_NOT_TOUCH_MODAL, LayoutParams.FLAG_TOUCHABLE_WHEN_WAKING, LayoutParams.FLAG_KEEP_SCREEN_ON, LayoutParams.FLAG_LAYOUT_IN_SCREEN, LayoutParams.FLAG_LAYOUT_NO_LIMITS, LayoutParams.FLAG_FULLSCREEN, LayoutParams.FLAG_FORCE_NOT_FULLSCREEN, LayoutParams.FLAG_DITHER, LayoutParams.FLAG_SECURE, LayoutParams.FLAG_SCALED, LayoutParams.FLAG_IGNORE_CHEEK_PRESSES, LayoutParams.FLAG_LAYOUT_INSET_DECOR, LayoutParams.FLAG_ALT_FOCUSABLE_IM, LayoutParams.FLAG_WATCH_OUTSIDE_TOUCH, LayoutParams.FLAG_SHOW_WHEN_LOCKED, LayoutParams.FLAG_SHOW_WALLPAPER, LayoutParams.FLAG_TURN_SCREEN_ON, LayoutParams.FLAG_DISMISS_KEYGUARD, LayoutParams.FLAG_SPLIT_TOUCH, LayoutParams.FLAG_HARDWARE_ACCELERATED, LayoutParams.FLAG_LAYOUT_IN_OVERSCAN, LayoutParams.FLAG_TRANSLUCENT_STATUS, LayoutParams.FLAG_TRANSLUCENT_NAVIGATION, LayoutParams.FLAG_LOCAL_FOCUS_MODE, LayoutParams.FLAG_LAYOUT_ATTACHED_IN_DECOR, LayoutParams.FLAG_DRAWS_SYSTEM_BAR_BACKGROUNDS"
errorLine1=" ?.or(android.R.attr.showWhenLocked or android.R.attr.turnScreenOn)"
- errorLine2=" ~~~~~~~~~~~~~~~~~~~~~~~~~~~">
+ errorLine2=" ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~">
<location
file="src/main/java/androidx/window/demo/PresentationActivity.kt"/>
</issue>
diff --git a/work/work-runtime/src/androidTest/java/androidx/work/impl/WorkerWrapperTest.java b/work/work-runtime/src/androidTest/java/androidx/work/impl/WorkerWrapperTest.java
index 286067b..d73cfec 100644
--- a/work/work-runtime/src/androidTest/java/androidx/work/impl/WorkerWrapperTest.java
+++ b/work/work-runtime/src/androidTest/java/androidx/work/impl/WorkerWrapperTest.java
@@ -1385,6 +1385,18 @@
assertThat(mWorkSpecDao.getState(work.getStringId()), is(FAILED));
}
+ @Test
+ @SmallTest
+ public void testWorkRequest_truncatedTraceTag() {
+ char[] aLongTag = new char[256];
+ Arrays.fill(aLongTag, 'W');
+ OneTimeWorkRequest work =
+ new OneTimeWorkRequest.Builder(TestWorker.class)
+ .setTraceTag(new String(aLongTag))
+ .build();
+ assertThat(work.getWorkSpec().getTraceTag().length(), is(127));
+ }
+
private WorkerWrapper.Builder createBuilder(String workSpecId) {
return new WorkerWrapper.Builder(
mContext,
diff --git a/work/work-runtime/src/main/java/androidx/work/WorkRequest.kt b/work/work-runtime/src/main/java/androidx/work/WorkRequest.kt
index 1b85c92..42b33741 100644
--- a/work/work-runtime/src/main/java/androidx/work/WorkRequest.kt
+++ b/work/work-runtime/src/main/java/androidx/work/WorkRequest.kt
@@ -162,13 +162,13 @@
* You should override the [traceTag], when you are using [ListenableWorker] delegation via
* a [WorkerFactory].
*
- * @param traceTag The name of the trace tag
+ * @param traceTag The name of the trace tag, truncate to a `127` character string if
+ * necessary.
* @return The current [Builder]
*/
@Suppress("MissingGetterMatchingBuilder")
@SuppressWarnings("SetterReturnsThis")
fun setTraceTag(traceTag: String): B {
- // No need to truncate the name here, given its handled by androidx.tracing.Trace
workSpec.traceTag = traceTag
return thisObject
}
@@ -280,10 +280,16 @@
}
require(workSpec.initialDelay <= 0) { "Expedited jobs cannot be delayed" }
}
- if (workSpec.traceTag == null) {
+ val traceTag = workSpec.traceTag
+ if (traceTag == null) {
// Derive a trace tag based on the fully qualified class name if
// one has not already been defined.
workSpec.traceTag = deriveTraceTagFromClassName(workSpec.workerClassName)
+ } else if (traceTag.length > MAX_TRACE_SPAN_LENGTH) {
+ // If there is a trace tag but it exceeds the limit, then truncate it.
+ // Since we also pipe this tag to JobInfo we need to not exceed the limit even
+ // though androidx.tracing.Trace already truncate tags.
+ workSpec.traceTag = traceTag.take(MAX_TRACE_SPAN_LENGTH)
}
// Create a new id and WorkSpec so this WorkRequest.Builder can be used multiple times.
setId(UUID.randomUUID())
diff --git a/xr/arcore/arcore/src/test/kotlin/androidx/xr/arcore/AnchorTest.kt b/xr/arcore/arcore/src/test/kotlin/androidx/xr/arcore/AnchorTest.kt
index ab6b085..49453a2 100644
--- a/xr/arcore/arcore/src/test/kotlin/androidx/xr/arcore/AnchorTest.kt
+++ b/xr/arcore/arcore/src/test/kotlin/androidx/xr/arcore/AnchorTest.kt
@@ -121,6 +121,7 @@
.isEqualTo(RuntimeAnchor.PersistenceState.Persisted)
}
+ @Ignore("Flaky test, see b/379198572")
@Test
fun getPersistedAnchorUuids_previouslyPersistedAnchor_returnsPersistedAnchorUuid() = runTest {
val session = createTestSession()
@@ -159,6 +160,7 @@
assertThat(Anchor.load(session, uuid!!)).isInstanceOf(AnchorCreateSuccess::class.java)
}
+ @Ignore("Flaky test, see b/384999184")
@Test
fun loadFromNativePointer_returnsAnchorCreateSuccess() = runTest {
val session = createTestSession()
