[pull] androidx-main from androidx:androidx-main

camera/camera-common/api/current.txt

@@ -1 +1,40 @@
 // Signature format: 4.0
+package androidx.camera.common {
+
+  @kotlin.jvm.JvmInline public final value class DiscreteRotation {
+    method @BytecodeOnly public static androidx.camera.common.DiscreteRotation! box-impl(int);
+    method @InaccessibleFromKotlin public int getDegrees();
+    method @KotlinOnly public inline operator androidx.camera.common.DiscreteRotation minus(androidx.camera.common.DiscreteRotation other);
+    method @KotlinOnly public inline operator androidx.camera.common.DiscreteRotation minus(int degrees);
+    method @BytecodeOnly public static int minus-4Qa-4Hw(int, int);
+    method @BytecodeOnly public static int minus-REjC-m4(int, int);
+    method @KotlinOnly public inline operator androidx.camera.common.DiscreteRotation plus(androidx.camera.common.DiscreteRotation other);
+    method @KotlinOnly public inline operator androidx.camera.common.DiscreteRotation plus(int degrees);
+    method @BytecodeOnly public static int plus-4Qa-4Hw(int, int);
+    method @BytecodeOnly public static int plus-REjC-m4(int, int);
+    method @BytecodeOnly public int unbox-impl();
+    property public int degrees;
+    field public static final androidx.camera.common.DiscreteRotation.Companion Companion;
+  }
+
+  public static final class DiscreteRotation.Companion {
+    method @KotlinOnly public androidx.camera.common.DiscreteRotation from(int degrees);
+    method @BytecodeOnly public int from-REjC-m4(int);
+    method @KotlinOnly public androidx.camera.common.DiscreteRotation fromSurfaceRotation(int surfaceRotation);
+    method @BytecodeOnly public int fromSurfaceRotation-REjC-m4(int);
+    method @KotlinOnly public androidx.camera.common.DiscreteRotation round(float degrees);
+    method @KotlinOnly public androidx.camera.common.DiscreteRotation round(int degrees);
+    method @BytecodeOnly public int round-REjC-m4(float);
+    method @BytecodeOnly public int round-REjC-m4(int);
+  }
+
+  public final class DiscreteRotationMath {
+    method public static int fromSurfaceRotation(int surfaceRotation);
+    method public static void requireDiscreteRotation(int degrees);
+    method public static int round(float degrees);
+    method public static int round(int degrees);
+    field public static final androidx.camera.common.DiscreteRotationMath INSTANCE;
+  }
+
+}
+

camera/camera-common/api/restricted_current.txt

@@ -1 +1,42 @@
 // Signature format: 4.0
+package androidx.camera.common {
+
+  @kotlin.jvm.JvmInline public final value class DiscreteRotation {
+    ctor @KotlinOnly @kotlin.PublishedApi internal DiscreteRotation(int degrees);
+    method @BytecodeOnly public static androidx.camera.common.DiscreteRotation! box-impl(int);
+    method @BytecodeOnly @kotlin.PublishedApi internal static int constructor-impl(int);
+    method @InaccessibleFromKotlin public int getDegrees();
+    method @KotlinOnly public inline operator androidx.camera.common.DiscreteRotation minus(androidx.camera.common.DiscreteRotation other);
+    method @KotlinOnly public inline operator androidx.camera.common.DiscreteRotation minus(int degrees);
+    method @BytecodeOnly public static int minus-4Qa-4Hw(int, int);
+    method @BytecodeOnly public static int minus-REjC-m4(int, int);
+    method @KotlinOnly public inline operator androidx.camera.common.DiscreteRotation plus(androidx.camera.common.DiscreteRotation other);
+    method @KotlinOnly public inline operator androidx.camera.common.DiscreteRotation plus(int degrees);
+    method @BytecodeOnly public static int plus-4Qa-4Hw(int, int);
+    method @BytecodeOnly public static int plus-REjC-m4(int, int);
+    method @BytecodeOnly public int unbox-impl();
+    property public int degrees;
+    field public static final androidx.camera.common.DiscreteRotation.Companion Companion;
+  }
+
+  public static final class DiscreteRotation.Companion {
+    method @KotlinOnly public androidx.camera.common.DiscreteRotation from(int degrees);
+    method @BytecodeOnly public int from-REjC-m4(int);
+    method @KotlinOnly public androidx.camera.common.DiscreteRotation fromSurfaceRotation(int surfaceRotation);
+    method @BytecodeOnly public int fromSurfaceRotation-REjC-m4(int);
+    method @KotlinOnly public androidx.camera.common.DiscreteRotation round(float degrees);
+    method @KotlinOnly public androidx.camera.common.DiscreteRotation round(int degrees);
+    method @BytecodeOnly public int round-REjC-m4(float);
+    method @BytecodeOnly public int round-REjC-m4(int);
+  }
+
+  public final class DiscreteRotationMath {
+    method public static int fromSurfaceRotation(int surfaceRotation);
+    method public static void requireDiscreteRotation(int degrees);
+    method public static int round(float degrees);
+    method public static int round(int degrees);
+    field public static final androidx.camera.common.DiscreteRotationMath INSTANCE;
+  }
+
+}
+

camera/camera-common/src/main/kotlin/androidx/camera/common/DiscreteRotation.kt

@@ -0,0 +1,74 @@
+/*
+ * Copyright 2026 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.common
+
+import android.view.Surface
+
+/**
+ * Kotlin value class that represents fixed 0, 90, 180, 270 degree rotations with utility functions
+ * for adding and subtracting discrete rotations from each other.
+ *
+ * A [DiscreteRotation] represents integer degrees in fixed 90 degree increments.
+ */
+@JvmInline
+@Suppress("NOTHING_TO_INLINE", "ValueClassDefinition")
+public value class DiscreteRotation @PublishedApi internal constructor(public val degrees: Int) {
+    /** Add a [DiscreteRotation] from this, modding the result by 360. */
+    @Suppress("ValueClassUsageWithoutJvmName")
+    public inline operator fun plus(other: DiscreteRotation): DiscreteRotation =
+        DiscreteRotation((this.degrees + other.degrees) % 360)
+
+    /** Add a [DiscreteRotation] from this, modding the result by 360. */
+    @Suppress("ValueClassUsageWithoutJvmName")
+    public inline operator fun plus(degrees: Int): DiscreteRotation = this.plus(from(degrees))
+
+    /** Subtract a [DiscreteRotation] from this, modding the result by 360. */
+    @Suppress("ValueClassUsageWithoutJvmName")
+    public inline operator fun minus(other: DiscreteRotation): DiscreteRotation =
+        DiscreteRotation((this.degrees - other.degrees + 360) % 360)
+
+    /** Subtract a [DiscreteRotation] from this, modding the result by 360. */
+    @Suppress("ValueClassUsageWithoutJvmName")
+    public inline operator fun minus(degrees: Int): DiscreteRotation = this.minus(from(degrees))
+
+    override fun toString(): String = "$degrees°"
+
+    public companion object {
+
+        /** Convert integer [degrees] to a [DiscreteRotation] */
+        @Suppress("ValueClassUsageWithoutJvmName", "MissingJvmstatic")
+        public fun from(degrees: Int): DiscreteRotation {
+            DiscreteRotationMath.requireDiscreteRotation(degrees)
+            return DiscreteRotation(degrees)
+        }
+
+        /** Round integer [degrees] to a [DiscreteRotation]. */
+        @Suppress("ValueClassUsageWithoutJvmName", "MissingJvmstatic")
+        public fun round(degrees: Int): DiscreteRotation =
+            DiscreteRotation(DiscreteRotationMath.round(degrees))
+
+        /** Round floating point [degrees] to a [DiscreteRotation]. */
+        @Suppress("ValueClassUsageWithoutJvmName", "MissingJvmstatic")
+        public fun round(degrees: Float): DiscreteRotation =
+            DiscreteRotation(DiscreteRotationMath.round(degrees))
+
+        /** Get a [DiscreteRotation] from [Surface] rotation values. */
+        @Suppress("ValueClassUsageWithoutJvmName", "MissingJvmstatic")
+        public fun fromSurfaceRotation(surfaceRotation: Int): DiscreteRotation =
+            DiscreteRotation(DiscreteRotationMath.fromSurfaceRotation(surfaceRotation))
+    }
+}

camera/camera-common/src/main/kotlin/androidx/camera/common/DiscreteRotationMath.kt

@@ -0,0 +1,85 @@
+/*
+ * Copyright 2026 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.common
+
+import android.view.Surface
+
+/** Utility functions for working with discrete rotations values [0, 90, 180, 270]. */
+public object DiscreteRotationMath {
+    /**
+     * Throws an [IllegalArgumentException] if the given [degrees] is not one of [0, 90, 180, 270].
+     */
+    @JvmStatic
+    public fun requireDiscreteRotation(degrees: Int) {
+        require(degrees == 0 || degrees == 90 || degrees == 180 || degrees == 270) {
+            "Unexpected rotation: $degrees. Value must be one of 0, 90, 180, 270"
+        }
+    }
+
+    /**
+     * Round [degrees] to the nearest discrete rotation (0, 90, 180, 270). Negative values are
+     * rounded to the nearest positive discrete rotation value.
+     *
+     * Example(s):
+     * - `40 => 0°`
+     * - `50 => 90°`
+     * - `-40 => 0°` (Equivalent to -40 + 360 => round(320) => 0)
+     * - `-50 => 270°` (Equivalent to -50 + 360 => round(310) => 270°)
+     */
+    @JvmStatic
+    public fun round(degrees: Int): Int {
+        // 1. Given an integer (positive or negative) constrain it to -359...359 using % 360
+        // 2. Offset the value to a positive range by adding 360.
+        // 3. When rounding to a multiple of 90 we use integer division to discard the remainder,
+        //    which effectively rounds down for positive integers. Adding 45 causes this to round to
+        //    the nearest discrete value.
+        // 4. Multiply by 90 to convert the value back to degrees.
+        // 5. % 360, giving a one of 0, 90, 180, 270
+        return ((degrees % 360 + (360 + 45)) / 90) * 90 % 360
+    }
+
+    /**
+     * Round [degrees] to the nearest discrete rotation (0, 90, 180, 270). Negative values are
+     * rounded to the nearest positive discrete rotation value.
+     *
+     * Example(s):
+     * - `40.000f => 0°`
+     * - `44.990f => 0°`
+     * - `45.001f => 90°`
+     * - `-40.00f° => 0°` (Equivalent to -40.000f + 360 => round(320) => 0)
+     * - `-50.00f° => 270°` (Equivalent to -50.000f + 360 => round(310) => 270)
+     */
+    @JvmStatic
+    public fun round(degrees: Float): Int {
+        // 1. Constrain to -360 < d < 360 using % 360
+        // 2. Divide d by 90 and round giving an integer value between -4 < d < 4
+        // 3. Multiply by 90, and add 360 to convert to a positive integer degree range.
+        // 4. % 360, giving a one of 0, 90, 180, 270
+        return (Math.round(degrees % 360 / 90) * 90 + 360) % 360
+    }
+
+    /** Get a [DiscreteRotation] from [Surface] rotation values. */
+    @JvmStatic
+    public fun fromSurfaceRotation(surfaceRotation: Int): Int =
+        when (surfaceRotation) {
+            Surface.ROTATION_0 -> 0
+            Surface.ROTATION_90 -> 90
+            Surface.ROTATION_180 -> 180
+            Surface.ROTATION_270 -> 270
+            else -> throw IllegalArgumentException("Unexpected Surface rotation $surfaceRotation!")
+        }
+}