From 118005c8604f38c91608a8de0f7b04b5c5f4e095 Mon Sep 17 00:00:00 2001 From: ibaker Date: Fri, 4 Feb 2022 17:55:43 +0000 Subject: [PATCH] Add TYPE_USE to 'frequently used' IntDefs in a backwards-compatible way This ensures Kotlin usages of these IntDef annotations in the 'old' position will continue to compile. 'Frequently used' is a subjective judgement. I have a parallel change that marks all the other public IntDefs in the library as TYPE_USE (those that I've judged to be 'rarely used' by apps). A follow-up change will fix the positions of existing usages to be as if they're only TYPE_USE. #minor-release PiperOrigin-RevId: 426427334 --- .../media3/common/AdPlaybackState.java | 7 +++++++ .../main/java/androidx/media3/common/C.java | 18 ++++++++++++++++++ .../media3/common/util/RepeatModeUtil.java | 10 ++++++++++ .../datasource/cache/CacheDataSource.java | 7 +++++++ .../media3/exoplayer/ExoPlaybackException.java | 10 ++++++++++ .../media3/exoplayer/ExoTimeoutException.java | 10 ++++++++++ .../exoplayer/analytics/AnalyticsListener.java | 9 +++++++++ .../media3/exoplayer/drm/DrmSession.java | 10 ++++++++++ .../androidx/media3/exoplayer/drm/DrmUtil.java | 10 ++++++++++ .../exoplayer/drm/UnsupportedDrmException.java | 13 ++++++++++--- .../media3/exoplayer/offline/Download.java | 13 +++++++++++++ .../exoplayer/scheduler/Requirements.java | 10 ++++++++++ .../trackselection/MappingTrackSelector.java | 9 +++++++++ 13 files changed, 133 insertions(+), 3 deletions(-) diff --git a/libraries/common/src/main/java/androidx/media3/common/AdPlaybackState.java b/libraries/common/src/main/java/androidx/media3/common/AdPlaybackState.java index 22ca06106b..3b900b60e2 100644 --- a/libraries/common/src/main/java/androidx/media3/common/AdPlaybackState.java +++ b/libraries/common/src/main/java/androidx/media3/common/AdPlaybackState.java @@ -18,6 +18,10 @@ package androidx.media3.common; import static androidx.media3.common.util.Assertions.checkArgument; import static androidx.media3.common.util.Assertions.checkState; import static java.lang.Math.max; +import static java.lang.annotation.ElementType.FIELD; +import static java.lang.annotation.ElementType.LOCAL_VARIABLE; +import static java.lang.annotation.ElementType.METHOD; +import static java.lang.annotation.ElementType.PARAMETER; import static java.lang.annotation.ElementType.TYPE_USE; import android.net.Uri; @@ -417,8 +421,11 @@ public final class AdPlaybackState implements Bundleable { * #AD_STATE_AVAILABLE}, {@link #AD_STATE_SKIPPED}, {@link #AD_STATE_PLAYED} or {@link * #AD_STATE_ERROR}. */ + // @Target list includes both 'default' targets and TYPE_USE, to ensure backwards compatibility + // with Kotlin usages from before TYPE_USE was added. @Documented @Retention(RetentionPolicy.SOURCE) + @Target({FIELD, METHOD, PARAMETER, LOCAL_VARIABLE, TYPE_USE}) @IntDef({ AD_STATE_UNAVAILABLE, AD_STATE_AVAILABLE, diff --git a/libraries/common/src/main/java/androidx/media3/common/C.java b/libraries/common/src/main/java/androidx/media3/common/C.java index f22b9b4e85..a91181c595 100644 --- a/libraries/common/src/main/java/androidx/media3/common/C.java +++ b/libraries/common/src/main/java/androidx/media3/common/C.java @@ -303,10 +303,13 @@ public final class C { * #STREAM_TYPE_RING}, {@link #STREAM_TYPE_SYSTEM}, {@link #STREAM_TYPE_VOICE_CALL} or {@link * #STREAM_TYPE_DEFAULT}. */ + // @Target list includes both 'default' targets and TYPE_USE, to ensure backwards compatibility + // with Kotlin usages from before TYPE_USE was added. @SuppressLint("UniqueConstants") // Intentional duplication to set STREAM_TYPE_DEFAULT. @UnstableApi @Documented @Retention(RetentionPolicy.SOURCE) + @Target({FIELD, METHOD, PARAMETER, LOCAL_VARIABLE, TYPE_USE}) @IntDef({ STREAM_TYPE_ALARM, STREAM_TYPE_DTMF, @@ -535,10 +538,13 @@ public final class C { * #VIDEO_SCALING_MODE_SCALE_TO_FIT}, {@link #VIDEO_SCALING_MODE_SCALE_TO_FIT_WITH_CROPPING} or * {@link #VIDEO_SCALING_MODE_DEFAULT}. */ + // @Target list includes both 'default' targets and TYPE_USE, to ensure backwards compatibility + // with Kotlin usages from before TYPE_USE was added. @SuppressLint("UniqueConstants") // Intentional duplication to set VIDEO_SCALING_MODE_DEFAULT. @UnstableApi @Documented @Retention(RetentionPolicy.SOURCE) + @Target({FIELD, METHOD, PARAMETER, LOCAL_VARIABLE, TYPE_USE}) @IntDef({ VIDEO_SCALING_MODE_SCALE_TO_FIT, VIDEO_SCALING_MODE_SCALE_TO_FIT_WITH_CROPPING, @@ -557,9 +563,12 @@ public final class C { @UnstableApi public static final int VIDEO_SCALING_MODE_DEFAULT = VIDEO_SCALING_MODE_SCALE_TO_FIT; /** Strategies for calling {@link Surface#setFrameRate}. */ + // @Target list includes both 'default' targets and TYPE_USE, to ensure backwards compatibility + // with Kotlin usages from before TYPE_USE was added. @UnstableApi @Documented @Retention(RetentionPolicy.SOURCE) + @Target({FIELD, METHOD, PARAMETER, LOCAL_VARIABLE, TYPE_USE}) @IntDef({VIDEO_CHANGE_FRAME_RATE_STRATEGY_OFF, VIDEO_CHANGE_FRAME_RATE_STRATEGY_ONLY_IF_SEAMLESS}) public @interface VideoChangeFrameRateStrategy {} /** @@ -614,9 +623,12 @@ public final class C { * Represents a streaming or other media type. One of {@link #TYPE_DASH}, {@link #TYPE_SS}, {@link * #TYPE_HLS}, {@link #TYPE_RTSP} or {@link #TYPE_OTHER}. */ + // @Target list includes both 'default' targets and TYPE_USE, to ensure backwards compatibility + // with Kotlin usages from before TYPE_USE was added. @UnstableApi @Documented @Retention(RetentionPolicy.SOURCE) + @Target({FIELD, METHOD, PARAMETER, LOCAL_VARIABLE, TYPE_USE}) @IntDef({TYPE_DASH, TYPE_SS, TYPE_HLS, TYPE_RTSP, TYPE_OTHER}) public @interface ContentType {} /** Value returned by {@link Util#inferContentType(String)} for DASH manifests. */ @@ -967,9 +979,12 @@ public final class C { * #NETWORK_TYPE_4G}, {@link #NETWORK_TYPE_5G_SA}, {@link #NETWORK_TYPE_5G_NSA}, {@link * #NETWORK_TYPE_CELLULAR_UNKNOWN}, {@link #NETWORK_TYPE_ETHERNET} or {@link #NETWORK_TYPE_OTHER}. */ + // @Target list includes both 'default' targets and TYPE_USE, to ensure backwards compatibility + // with Kotlin usages from before TYPE_USE was added. @UnstableApi @Documented @Retention(RetentionPolicy.SOURCE) + @Target({FIELD, METHOD, PARAMETER, LOCAL_VARIABLE, TYPE_USE}) @IntDef({ NETWORK_TYPE_UNKNOWN, NETWORK_TYPE_OFFLINE, @@ -1130,9 +1145,12 @@ public final class C { * #FORMAT_EXCEEDS_CAPABILITIES}, {@link #FORMAT_UNSUPPORTED_DRM}, {@link * #FORMAT_UNSUPPORTED_SUBTYPE} or {@link #FORMAT_UNSUPPORTED_TYPE}. */ + // @Target list includes both 'default' targets and TYPE_USE, to ensure backwards compatibility + // with Kotlin usages from before TYPE_USE was added. @UnstableApi @Documented @Retention(RetentionPolicy.SOURCE) + @Target({FIELD, METHOD, PARAMETER, LOCAL_VARIABLE, TYPE_USE}) @IntDef({ FORMAT_HANDLED, FORMAT_EXCEEDS_CAPABILITIES, diff --git a/libraries/common/src/main/java/androidx/media3/common/util/RepeatModeUtil.java b/libraries/common/src/main/java/androidx/media3/common/util/RepeatModeUtil.java index bba07a2707..4214e92dd9 100644 --- a/libraries/common/src/main/java/androidx/media3/common/util/RepeatModeUtil.java +++ b/libraries/common/src/main/java/androidx/media3/common/util/RepeatModeUtil.java @@ -15,11 +15,18 @@ */ package androidx.media3.common.util; +import static java.lang.annotation.ElementType.FIELD; +import static java.lang.annotation.ElementType.LOCAL_VARIABLE; +import static java.lang.annotation.ElementType.METHOD; +import static java.lang.annotation.ElementType.PARAMETER; +import static java.lang.annotation.ElementType.TYPE_USE; + import androidx.annotation.IntDef; import androidx.media3.common.Player; import java.lang.annotation.Documented; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; /** Util class for repeat mode handling. */ @UnstableApi @@ -30,8 +37,11 @@ public final class RepeatModeUtil { * {@link #REPEAT_TOGGLE_MODE_NONE}, {@link #REPEAT_TOGGLE_MODE_ONE} and {@link * #REPEAT_TOGGLE_MODE_ALL}. */ + // @Target list includes both 'default' targets and TYPE_USE, to ensure backwards compatibility + // with Kotlin usages from before TYPE_USE was added. @Documented @Retention(RetentionPolicy.SOURCE) + @Target({FIELD, METHOD, PARAMETER, LOCAL_VARIABLE, TYPE_USE}) @IntDef( flag = true, value = {REPEAT_TOGGLE_MODE_NONE, REPEAT_TOGGLE_MODE_ONE, REPEAT_TOGGLE_MODE_ALL}) diff --git a/libraries/datasource/src/main/java/androidx/media3/datasource/cache/CacheDataSource.java b/libraries/datasource/src/main/java/androidx/media3/datasource/cache/CacheDataSource.java index 8802d8b187..d39cceb0f0 100644 --- a/libraries/datasource/src/main/java/androidx/media3/datasource/cache/CacheDataSource.java +++ b/libraries/datasource/src/main/java/androidx/media3/datasource/cache/CacheDataSource.java @@ -18,6 +18,10 @@ package androidx.media3.datasource.cache; import static androidx.media3.common.util.Assertions.checkNotNull; import static androidx.media3.common.util.Util.castNonNull; import static java.lang.Math.min; +import static java.lang.annotation.ElementType.FIELD; +import static java.lang.annotation.ElementType.LOCAL_VARIABLE; +import static java.lang.annotation.ElementType.METHOD; +import static java.lang.annotation.ElementType.PARAMETER; import static java.lang.annotation.ElementType.TYPE_USE; import android.net.Uri; @@ -364,8 +368,11 @@ public final class CacheDataSource implements DataSource { * Reasons the cache may be ignored. One of {@link #CACHE_IGNORED_REASON_ERROR} or {@link * #CACHE_IGNORED_REASON_UNSET_LENGTH}. */ + // @Target list includes both 'default' targets and TYPE_USE, to ensure backwards compatibility + // with Kotlin usages from before TYPE_USE was added. @Documented @Retention(RetentionPolicy.SOURCE) + @Target({FIELD, METHOD, PARAMETER, LOCAL_VARIABLE, TYPE_USE}) @IntDef({CACHE_IGNORED_REASON_ERROR, CACHE_IGNORED_REASON_UNSET_LENGTH}) public @interface CacheIgnoredReason {} diff --git a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/ExoPlaybackException.java b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/ExoPlaybackException.java index 08aa9aca21..2a2b03ab0f 100644 --- a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/ExoPlaybackException.java +++ b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/ExoPlaybackException.java @@ -15,6 +15,12 @@ */ package androidx.media3.exoplayer; +import static java.lang.annotation.ElementType.FIELD; +import static java.lang.annotation.ElementType.LOCAL_VARIABLE; +import static java.lang.annotation.ElementType.METHOD; +import static java.lang.annotation.ElementType.PARAMETER; +import static java.lang.annotation.ElementType.TYPE_USE; + import android.os.Bundle; import android.os.SystemClock; import android.text.TextUtils; @@ -35,6 +41,7 @@ import java.io.IOException; import java.lang.annotation.Documented; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; /** Thrown when a non locally recoverable playback failure occurs. */ public final class ExoPlaybackException extends PlaybackException { @@ -44,9 +51,12 @@ public final class ExoPlaybackException extends PlaybackException { * {@link #TYPE_UNEXPECTED} or {@link #TYPE_REMOTE}. Note that new types may be added in the * future and error handling should handle unknown type values. */ + // @Target list includes both 'default' targets and TYPE_USE, to ensure backwards compatibility + // with Kotlin usages from before TYPE_USE was added. @UnstableApi @Documented @Retention(RetentionPolicy.SOURCE) + @Target({FIELD, METHOD, PARAMETER, LOCAL_VARIABLE, TYPE_USE}) @IntDef({TYPE_SOURCE, TYPE_RENDERER, TYPE_UNEXPECTED, TYPE_REMOTE}) public @interface Type {} /** diff --git a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/ExoTimeoutException.java b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/ExoTimeoutException.java index 93f9ac8474..cc1ca1404e 100644 --- a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/ExoTimeoutException.java +++ b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/ExoTimeoutException.java @@ -15,12 +15,19 @@ */ package androidx.media3.exoplayer; +import static java.lang.annotation.ElementType.FIELD; +import static java.lang.annotation.ElementType.LOCAL_VARIABLE; +import static java.lang.annotation.ElementType.METHOD; +import static java.lang.annotation.ElementType.PARAMETER; +import static java.lang.annotation.ElementType.TYPE_USE; + import androidx.annotation.IntDef; import androidx.media3.common.Player; import androidx.media3.common.util.UnstableApi; import java.lang.annotation.Documented; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; /** A timeout of an operation on the ExoPlayer playback thread. */ @UnstableApi @@ -32,8 +39,11 @@ public final class ExoTimeoutException extends RuntimeException { * {@link #TIMEOUT_OPERATION_UNDEFINED}. Note that new operations may be added in the future and * error handling should handle unknown operation values. */ + // @Target list includes both 'default' targets and TYPE_USE, to ensure backwards compatibility + // with Kotlin usages from before TYPE_USE was added. @Documented @Retention(RetentionPolicy.SOURCE) + @Target({FIELD, METHOD, PARAMETER, LOCAL_VARIABLE, TYPE_USE}) @IntDef({ TIMEOUT_OPERATION_UNDEFINED, TIMEOUT_OPERATION_RELEASE, diff --git a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/analytics/AnalyticsListener.java b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/analytics/AnalyticsListener.java index 948f3e954a..59d8b333bc 100644 --- a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/analytics/AnalyticsListener.java +++ b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/analytics/AnalyticsListener.java @@ -16,6 +16,11 @@ package androidx.media3.exoplayer.analytics; import static androidx.media3.common.util.Assertions.checkNotNull; +import static java.lang.annotation.ElementType.FIELD; +import static java.lang.annotation.ElementType.LOCAL_VARIABLE; +import static java.lang.annotation.ElementType.METHOD; +import static java.lang.annotation.ElementType.PARAMETER; +import static java.lang.annotation.ElementType.TYPE_USE; import android.media.MediaCodec; import android.media.MediaCodec.CodecException; @@ -60,6 +65,7 @@ import java.io.IOException; import java.lang.annotation.Documented; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; /** * A listener for analytics events. @@ -155,8 +161,11 @@ public interface AnalyticsListener { * *

One of the {@link AnalyticsListener}{@code .EVENT_*} flags. */ + // @Target list includes both 'default' targets and TYPE_USE, to ensure backwards compatibility + // with Kotlin usages from before TYPE_USE was added. @Documented @Retention(RetentionPolicy.SOURCE) + @Target({FIELD, METHOD, PARAMETER, LOCAL_VARIABLE, TYPE_USE}) @IntDef({ EVENT_TIMELINE_CHANGED, EVENT_MEDIA_ITEM_TRANSITION, diff --git a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/drm/DrmSession.java b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/drm/DrmSession.java index 5c1d17c065..73fcb430ee 100644 --- a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/drm/DrmSession.java +++ b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/drm/DrmSession.java @@ -15,6 +15,12 @@ */ package androidx.media3.exoplayer.drm; +import static java.lang.annotation.ElementType.FIELD; +import static java.lang.annotation.ElementType.LOCAL_VARIABLE; +import static java.lang.annotation.ElementType.METHOD; +import static java.lang.annotation.ElementType.PARAMETER; +import static java.lang.annotation.ElementType.TYPE_USE; + import android.media.MediaDrm; import androidx.annotation.IntDef; import androidx.annotation.Nullable; @@ -25,6 +31,7 @@ import java.io.IOException; import java.lang.annotation.Documented; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; import java.util.Map; import java.util.UUID; @@ -70,8 +77,11 @@ public interface DrmSession { * The state of the DRM session. One of {@link #STATE_RELEASED}, {@link #STATE_ERROR}, {@link * #STATE_OPENING}, {@link #STATE_OPENED} or {@link #STATE_OPENED_WITH_KEYS}. */ + // @Target list includes both 'default' targets and TYPE_USE, to ensure backwards compatibility + // with Kotlin usages from before TYPE_USE was added. @Documented @Retention(RetentionPolicy.SOURCE) + @Target({FIELD, METHOD, PARAMETER, LOCAL_VARIABLE, TYPE_USE}) @IntDef({STATE_RELEASED, STATE_ERROR, STATE_OPENING, STATE_OPENED, STATE_OPENED_WITH_KEYS}) @interface State {} /** The session has been released. This is a terminal state. */ diff --git a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/drm/DrmUtil.java b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/drm/DrmUtil.java index dd22bb206d..ec43643855 100644 --- a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/drm/DrmUtil.java +++ b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/drm/DrmUtil.java @@ -15,6 +15,12 @@ */ package androidx.media3.exoplayer.drm; +import static java.lang.annotation.ElementType.FIELD; +import static java.lang.annotation.ElementType.LOCAL_VARIABLE; +import static java.lang.annotation.ElementType.METHOD; +import static java.lang.annotation.ElementType.PARAMETER; +import static java.lang.annotation.ElementType.TYPE_USE; + import android.media.DeniedByServerException; import android.media.MediaDrm; import android.media.MediaDrmResetException; @@ -29,14 +35,18 @@ import androidx.media3.common.util.Util; import java.lang.annotation.Documented; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; /** DRM-related utility methods. */ @UnstableApi public final class DrmUtil { /** Identifies the operation which caused a DRM-related error. */ + // @Target list includes both 'default' targets and TYPE_USE, to ensure backwards compatibility + // with Kotlin usages from before TYPE_USE was added. @Documented @Retention(RetentionPolicy.SOURCE) + @Target({FIELD, METHOD, PARAMETER, LOCAL_VARIABLE, TYPE_USE}) @IntDef( value = { ERROR_SOURCE_EXO_MEDIA_DRM, diff --git a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/drm/UnsupportedDrmException.java b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/drm/UnsupportedDrmException.java index 34d5e80b84..f42dde626b 100644 --- a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/drm/UnsupportedDrmException.java +++ b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/drm/UnsupportedDrmException.java @@ -15,11 +15,16 @@ */ package androidx.media3.exoplayer.drm; +import static java.lang.annotation.ElementType.FIELD; +import static java.lang.annotation.ElementType.LOCAL_VARIABLE; +import static java.lang.annotation.ElementType.METHOD; +import static java.lang.annotation.ElementType.PARAMETER; +import static java.lang.annotation.ElementType.TYPE_USE; + import androidx.annotation.IntDef; import androidx.media3.common.util.UnstableApi; import java.lang.annotation.Documented; -import java.lang.annotation.Retention; -import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; /** Thrown when the requested DRM scheme is not supported. */ @UnstableApi @@ -29,8 +34,10 @@ public final class UnsupportedDrmException extends Exception { * The reason for the exception. One of {@link #REASON_UNSUPPORTED_SCHEME} or {@link * #REASON_INSTANTIATION_ERROR}. */ + // @Target list includes both 'default' targets and TYPE_USE, to ensure backwards compatibility + // with Kotlin usages from before TYPE_USE was added. @Retention(RetentionPolicy.SOURCE) @Documented - @Retention(RetentionPolicy.SOURCE) + @Target({FIELD, METHOD, PARAMETER, LOCAL_VARIABLE, TYPE_USE}) @IntDef({REASON_UNSUPPORTED_SCHEME, REASON_INSTANTIATION_ERROR}) public @interface Reason {} /** The requested DRM scheme is unsupported by the device. */ diff --git a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/offline/Download.java b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/offline/Download.java index 0ba86073d5..9594592d6d 100644 --- a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/offline/Download.java +++ b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/offline/Download.java @@ -15,6 +15,12 @@ */ package androidx.media3.exoplayer.offline; +import static java.lang.annotation.ElementType.FIELD; +import static java.lang.annotation.ElementType.LOCAL_VARIABLE; +import static java.lang.annotation.ElementType.METHOD; +import static java.lang.annotation.ElementType.PARAMETER; +import static java.lang.annotation.ElementType.TYPE_USE; + import androidx.annotation.IntDef; import androidx.media3.common.C; import androidx.media3.common.util.Assertions; @@ -22,6 +28,7 @@ import androidx.media3.common.util.UnstableApi; import java.lang.annotation.Documented; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; /** Represents state of a download. */ @UnstableApi @@ -32,8 +39,11 @@ public final class Download { * #STATE_DOWNLOADING}, {@link #STATE_COMPLETED}, {@link #STATE_FAILED}, {@link #STATE_REMOVING} * or {@link #STATE_RESTARTING}. */ + // @Target list includes both 'default' targets and TYPE_USE, to ensure backwards compatibility + // with Kotlin usages from before TYPE_USE was added. @Documented @Retention(RetentionPolicy.SOURCE) + @Target({FIELD, METHOD, PARAMETER, LOCAL_VARIABLE, TYPE_USE}) @IntDef({ STATE_QUEUED, STATE_STOPPED, @@ -71,8 +81,11 @@ public final class Download { public static final int STATE_RESTARTING = 7; /** Failure reasons. Either {@link #FAILURE_REASON_NONE} or {@link #FAILURE_REASON_UNKNOWN}. */ + // @Target list includes both 'default' targets and TYPE_USE, to ensure backwards compatibility + // with Kotlin usages from before TYPE_USE was added. @Documented @Retention(RetentionPolicy.SOURCE) + @Target({FIELD, METHOD, PARAMETER, LOCAL_VARIABLE, TYPE_USE}) @IntDef({FAILURE_REASON_NONE, FAILURE_REASON_UNKNOWN}) public @interface FailureReason {} /** The download isn't failed. */ diff --git a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/scheduler/Requirements.java b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/scheduler/Requirements.java index 916ae5f824..34d435bb47 100644 --- a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/scheduler/Requirements.java +++ b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/scheduler/Requirements.java @@ -15,6 +15,12 @@ */ package androidx.media3.exoplayer.scheduler; +import static java.lang.annotation.ElementType.FIELD; +import static java.lang.annotation.ElementType.LOCAL_VARIABLE; +import static java.lang.annotation.ElementType.METHOD; +import static java.lang.annotation.ElementType.PARAMETER; +import static java.lang.annotation.ElementType.TYPE_USE; + import android.content.Context; import android.content.Intent; import android.content.IntentFilter; @@ -34,6 +40,7 @@ import androidx.media3.common.util.Util; import java.lang.annotation.Documented; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; /** Defines a set of device state requirements. */ @UnstableApi @@ -43,8 +50,11 @@ public final class Requirements implements Parcelable { * Requirement flags. Possible flag values are {@link #NETWORK}, {@link #NETWORK_UNMETERED}, * {@link #DEVICE_IDLE}, {@link #DEVICE_CHARGING} and {@link #DEVICE_STORAGE_NOT_LOW}. */ + // @Target list includes both 'default' targets and TYPE_USE, to ensure backwards compatibility + // with Kotlin usages from before TYPE_USE was added. @Documented @Retention(RetentionPolicy.SOURCE) + @Target({FIELD, METHOD, PARAMETER, LOCAL_VARIABLE, TYPE_USE}) @IntDef( flag = true, value = {NETWORK, NETWORK_UNMETERED, DEVICE_IDLE, DEVICE_CHARGING, DEVICE_STORAGE_NOT_LOW}) diff --git a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/trackselection/MappingTrackSelector.java b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/trackselection/MappingTrackSelector.java index 9e9051d646..980a5a7749 100644 --- a/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/trackselection/MappingTrackSelector.java +++ b/libraries/exoplayer/src/main/java/androidx/media3/exoplayer/trackselection/MappingTrackSelector.java @@ -17,6 +17,11 @@ package androidx.media3.exoplayer.trackselection; import static java.lang.Math.max; import static java.lang.Math.min; +import static java.lang.annotation.ElementType.FIELD; +import static java.lang.annotation.ElementType.LOCAL_VARIABLE; +import static java.lang.annotation.ElementType.METHOD; +import static java.lang.annotation.ElementType.PARAMETER; +import static java.lang.annotation.ElementType.TYPE_USE; import android.util.Pair; import androidx.annotation.IntDef; @@ -43,6 +48,7 @@ import com.google.common.collect.ImmutableList; import java.lang.annotation.Documented; import java.lang.annotation.Retention; import java.lang.annotation.RetentionPolicy; +import java.lang.annotation.Target; import java.util.Arrays; import org.checkerframework.checker.nullness.compatqual.NullableType; @@ -62,8 +68,11 @@ public abstract class MappingTrackSelector extends TrackSelector { * {@link #RENDERER_SUPPORT_NO_TRACKS}, {@link #RENDERER_SUPPORT_UNSUPPORTED_TRACKS}, {@link * #RENDERER_SUPPORT_EXCEEDS_CAPABILITIES_TRACKS} or {@link #RENDERER_SUPPORT_PLAYABLE_TRACKS}. */ + // @Target list includes both 'default' targets and TYPE_USE, to ensure backwards compatibility + // with Kotlin usages from before TYPE_USE was added. @Documented @Retention(RetentionPolicy.SOURCE) + @Target({FIELD, METHOD, PARAMETER, LOCAL_VARIABLE, TYPE_USE}) @IntDef({ RENDERER_SUPPORT_NO_TRACKS, RENDERER_SUPPORT_UNSUPPORTED_TRACKS,