Update all dependencies

[renovate]

This PR contains the following updates:

Package	Type	Update	Change	Age	Adoption	Passing	Confidence
gradle (source)		minor	8.6 -> 8.7
com.github.triplet.play	plugin	patch	3.9.0 -> 3.9.1
io.github.reactivecircus.app-versioning	plugin	patch	1.3.1 -> 1.3.2
com.mikepenz.aboutlibraries.plugin	plugin	major	10.10.0 -> 11.1.1
com.mikepenz:aboutlibraries-compose-m3	dependencies	major	10.10.0 -> 11.1.1
androidx.datastore:datastore-preferences (source)	dependencies	patch	1.1.0-beta01 -> 1.1.0-beta02
com.google.firebase:firebase-bom	dependencies	minor	32.7.2 -> 32.8.0
com.michael-bull.kotlin-result:kotlin-result	dependencies	major	1.1.18 -> 2.0.0
io.ktor:ktor-serialization-kotlinx-json	dependencies	patch	2.3.8 -> 2.3.9
io.ktor:ktor-client-content-negotiation	dependencies	patch	2.3.8 -> 2.3.9
io.ktor:ktor-client-mock	dependencies	patch	2.3.8 -> 2.3.9
io.ktor:ktor-client-okhttp	dependencies	patch	2.3.8 -> 2.3.9
io.ktor:ktor-client-core	dependencies	patch	2.3.8 -> 2.3.9
androidx.media3:media3-exoplayer-workmanager	dependencies	minor	1.2.1 -> 1.3.0
androidx.media3:media3-session	dependencies	minor	1.2.1 -> 1.3.0
androidx.media3:media3-common	dependencies	minor	1.2.1 -> 1.3.0
androidx.media3:media3-exoplayer	dependencies	minor	1.2.1 -> 1.3.0
app.cash.molecule:molecule-runtime	dependencies	minor	1.3.2 -> 1.4.1
androidx.compose.material3:material3 (source)	dependencies	patch	1.2.0 -> 1.2.1
androidx.compose:compose-bom	dependencies	minor	2024.02.01 -> 2024.03.00
app.cash.turbine:turbine	dependencies	minor	1.0.0 -> 1.1.0
com.google.dagger.hilt.android	plugin	minor	2.50 -> 2.51
com.google.dagger:hilt-android	dependencies	minor	2.50 -> 2.51
com.google.dagger:hilt-android-compiler	dependencies	minor	2.50 -> 2.51

---

Release Notes

gradle/gradle (gradle)

v8.7

Compare Source

ReactiveCircus/app-versioning (io.github.reactivecircus.app-versioning)

v1.3.2

Compare Source

Changed

• Compile with AGP 8.3.0.
• Compile with Kotlin 1.9.23.

mikepenz/AboutLibraries (com.mikepenz:aboutlibraries-compose-m3)

v11.1.1

🚀 Features

• Library Serializer
  • PR: #​963
  • Thanks @​DatL4g
• Update major dependencies | Compose 1.6.4 | Compose-MP 1.6.1
  • PR: #​968

🐛 Fixes

• Set onclick listener of SimpleLibraryItem to null if no license is known
  • PR: #​966
  • Thanks @​alexbakker
• Sort a copy of the list of libraries to prevent a crash
  • PR: #​967
  • Thanks @​alexbakker

v11.1.0

🚀 Features

• Upgrade dependencies | Compose 1.6.0 | Compose Compiler | Lifecycle
  • PR: #​950
• Make Library and Licenses data classes stable with KotlinX Collections
  • PR: #​947
• Compose 1.6 | KotlinX Updates
  • PR: #​958
• Update to compose-multiplatform 1.6.0 / compose-android 1.6.2
  • PR: #​961

🐛 Fixes

• Fix wasm sample app no longer loading
  • PR: #​951

💬 Other

• Update README with warning on configPath
  • PR: #​948
• Module specific names
  • PR: #​952
• Lower noise of log
  • PR: #​956
• Update CI gradle action
  • PR: #​957
• Fix CI for releases on macOS-14 runner
  • PR: #​960

michaelbull/kotlin-result (com.michael-bull.kotlin-result:kotlin-result)

v2.0.0

Compare Source

• The Result type is now an inline value class for reduced runtime overhead (981fbe2)
  • Before & After comparisons outlined below
  • Also see the Overhead design doc on the wiki
• Previously deprecated behaviours have been removed (eecd1b7)

Migration Guide

Ok/Err as Types

The migration to an inline value class means that using Ok/Err as types is no longer valid.

Consumers that need to introspect the type of Result should instead use Result.isOk/Result.isErr booleans. This naming scheme matches Rust's is_ok & is_err functions.

Before:

public inline fun <V, E, U> Result<V, E>.mapOrElse(default: (E) -> U, transform: (V) -> U): U {
    return when (this) {
        is Ok -> transform(value)
        is Err -> default(error)
    }
}

After:

public inline fun <V, E, U> Result<V, E>.mapOrElse(default: (E) -> U, transform: (V) -> U): U {
    return when {
        isOk -> transform(value)
        else -> default(error)
    }
}

Type Casting

When changing the return type to another result, e.g. the map function which goes from Result<V, E> to Result<U, E>, consumers are encouraged to use the asOk/asErr extension functions in conjunction with the isOk/isErr guard.

The example below calls asErr which unsafely casts the Result<V, E to Result<Nothing, E>, which is acceptable given the isOk check, which satisfies the Result<U, E> return type.

The asOk/asOk functions should not be used outside of a manual type guard via isOk/isErr - the cast is unsafe.

public inline infix fun <V, E, U> Result<V, E>.map(transform: (V) -> U): Result<U, E> {
    return when {
        isOk -> Ok(transform(value))
        else -> this.asErr() // unsafely typecasts Result<V, E> to Result<Nothing, E>
    }
}

Removal of Deprecations

The following previously deprecated behaviours have been removed in v2.

• binding & SuspendableResultBinding, use coroutineBinding instead
• and without lambda argument, use andThen instead
• ResultBinding, use BindingScope instead
• getOr without lambda argument, use getOrElse instead
• getErrorOr without lambda argument, use getErrorOrElse instead
• getAll, use filterValues instead
• getAllErrors, use filterErrors instead
• or without lambda argument, use orElse instead
• Result.of, use runCatching instead
• expect with non-lazy evaluation of message
• expectError with non-lazy evaluation of message

Inline Value Class - Before & After

The base Result class is now modelled as an inline value class. References to Ok<V>/Err<E> as types should be replaced with Result<V, Nothing> and Result<Nothing, E> respectively.

Calls to Ok and Err still function, but they no longer create a new instance of the Ok/Err objects - instead these are top-level functions that return a type of Result. This change achieves code that produces zero object allocations when on the "happy path", i.e. anything that returns an Ok(value). Previously, every successful operation wrapped its returned value in a new Ok(value) object.

The Err(error) function still allocates a new object each call by internally wrapping the provided error with a new instance of a Failure object. This Failure class is an internal implementation detail and not exposed to consumers. As a call to Err is usually a terminal state, occurring at the end of a chain, the allocation of a new object is unlikely to cause a lot of GC pressure unless a function that produces an Err is called in a tight loop.

Below is a comparison of the bytecode decompiled to Java produced before and after this change. The total number of possible object allocations is reduced from 4 to 1, with 0 occurring on the happy path and 1 occurring on the unhappy path.

Before: 4 object allocations, 3 on happy path & 1 on unhappy path

public final class Before {
    @​NotNull
    public static final Before INSTANCE = new Before();

    private Before() {
    }

    @​NotNull
    public final Result<Integer, ErrorOne> one() {
        return (Result)(new Ok(50));
    }

    public final int two() {
        return 100;
    }

    @&#8203;NotNull
    public final Result<Integer, ErrorThree> three(int var1) {
        return (Result)(new Ok(var1 + 25));
    }

    public final void example() {
        Result $this$map$iv = this.one(); // object allocation (1)
        Result var10000;
        if ($this$map$iv instanceof Ok) {
            Integer var10 = INSTANCE.two();
            var10000 = (Result)(new Ok(var10)); // object allocation (2)
        } else {
            if (!($this$map$iv instanceof Err)) {
                throw new NoWhenBranchMatchedException();
            }

            var10000 = $this$map$iv;
        }

        Result $this$mapError$iv = var10000;
        if ($this$mapError$iv instanceof Ok) {
            var10000 = $this$mapError$iv;
        } else {
            if (!($this$mapError$iv instanceof Err)) {
                throw new NoWhenBranchMatchedException();
            }

            ErrorTwo var11 = ErrorTwo.INSTANCE;
            var10000 = (Result)(new Err(var11)); // object allocation (3)
        }

        Result $this$andThen$iv = var10000;
        if ($this$andThen$iv instanceof Ok) {
            int p0 = ((Number)((Ok)$this$andThen$iv).getValue()).intValue();
            var10000 = this.three(p0); // object allocation (4)
        } else {
            if (!($this$andThen$iv instanceof Err)) {
                throw new NoWhenBranchMatchedException();
            }

            var10000 = $this$andThen$iv;
        }

        String result = var10000.toString();
        System.out.println(result);
    }

    public static abstract class Result<V, E> {
        private Result() {
        }
    }

    public static final class Ok<V> extends Result {
        private final V value;

        public Ok(V value) {
            this.value = value;
        }

        public final V getValue() {
            return this.value;
        }

        public boolean equals(@&#8203;Nullable Object other) {
            if (this == other) {
                return true;
            } else if (other != null && this.getClass() == other.getClass()) {
                Ok var10000 = (Ok)other;
                return Intrinsics.areEqual(this.value, ((Ok)other).value);
            } else {
                return false;
            }
        }

        public int hashCode() {
            Object var10000 = this.value;
            return var10000 != null ? var10000.hashCode() : 0;
        }

        @&#8203;NotNull
        public String toString() {
            return "Ok(" + this.value + ')';
        }
    }
    
    public static final class Err<E> extends Result {
        private final E error;

        public Err(E error) {
            this.error = error;
        }

        public final E getError() {
            return this.error;
        }

        public boolean equals(@&#8203;Nullable Object other) {
            if (this == other) {
                return true;
            } else if (other != null && this.getClass() == other.getClass()) {
                Before$Err var10000 = (Err)other;
                return Intrinsics.areEqual(this.error, ((Err)other).error);
            } else {
                return false;
            }
        }

        public int hashCode() {
            Object var10000 = this.error;
            return var10000 != null ? var10000.hashCode() : 0;
        }

        @&#8203;NotNull
        public String toString() {
            return "Err(" + this.error + ')';
        }
    }
}

After: 1 object allocation, 0 on happy path & 1 on unhappy path

public final class After {
    @​NotNull
    public static final After INSTANCE = new After();

    private After() {
    }

    @​NotNull
    public final Object one() {
        return this.Ok(50);
    }

    public final int two() {
        return 100;
    }

    @​NotNull
    public final Object three(int var1) {
        return this.Ok(var1 + 25);
    }

    public final void example() {
        Object $this$map_u2dj2AeeQ8$iv = this.one();
        Object var10000;
        if (Result.isOk_impl($this$map_u2dj2AeeQ8$iv)) {
            var10000 = this.Ok(INSTANCE.two());
        } else {
            var10000 = $this$map_u2dj2AeeQ8$iv;
        }

        Object $this$mapError_u2dj2AeeQ8$iv = var10000;
        if (Result.isErr_impl($this$mapError_u2dj2AeeQ8$iv)) {
            var10000 = this.Err(ErrorTwo.INSTANCE); // object allocation (1)
        } else {
            var10000 = $this$mapError_u2dj2AeeQ8$iv;
        }

        Object $this$andThen_u2dj2AeeQ8$iv = var10000;
        if (Result.isOk_impl($this$andThen_u2dj2AeeQ8$iv)) {
            int p0 = ((Number) Result.getValue_impl($this$andThen_u2dj2AeeQ8$iv)).intValue();
            var10000 = this.three(p0);
        } else {
            var10000 = $this$andThen_u2dj2AeeQ8$iv;
        }

        String result = Result.toString_impl(var10000);
        System.out.println(result);
    }

    @​NotNull
    public final <V> Object Ok(V value) {
        return Result.constructor_impl(value);
    }

    @&#8203;NotNull
    public final <E> Object Err(E error) {
        return Result.constructor_impl(new Failure(error));
    }

    public static final class Result<V, E> {
        @&#8203;Nullable
        private final Object inlineValue;

        public static final V getValue_impl(Object arg0) {
            return arg0;
        }

        public static final E getError_impl(Object arg0) {
            Intrinsics.checkNotNull(arg0, "null cannot be cast to non-null type Failure<E of Result>");
            return ((Failure) arg0).getError();
        }

        public static final boolean isOk_impl(Object arg0) {
            return !(arg0 instanceof Failure);
        }

        public static final boolean isErr_impl(Object arg0) {
            return arg0 instanceof Failure;
        }

        @&#8203;NotNull
        public static String toString_impl(Object arg0) {
            return isOk_impl(arg0) ? "Ok(" + getValue_impl(arg0) + ')' : "Err(" + getError_impl(arg0) + ')';
        }

        @&#8203;NotNull
        public String toString() {
            return toString_impl(this.inlineValue);
        }

        public static int hashCode_impl(Object arg0) {
            return arg0 == null ? 0 : arg0.hashCode();
        }

        public int hashCode() {
            return hashCode_impl(this.inlineValue);
        }

        public static boolean equals_impl(Object arg0, Object other) {
            if (!(other instanceof Result)) {
                return false;
            } else {
                return Intrinsics.areEqual(arg0, ((Result) other).unbox_impl());
            }
        }

        public boolean equals(Object other) {
            return equals_impl(this.inlineValue, other);
        }

        private Result(Object inlineValue) {
            this.inlineValue = inlineValue;
        }

        @&#8203;NotNull
        public static <V, E> Object constructor_impl(@&#8203;Nullable Object inlineValue) {
            return inlineValue;
        }

        public static final Result box_impl(Object v) {
            return new Result(v);
        }

        public final Object unbox_impl() {
            return this.inlineValue;
        }

        public static final boolean equals_impl0(Object p1, Object p2) {
            return Intrinsics.areEqual(p1, p2);
        }
    }

    static final class Failure<E> {
        private final E error;

        public Failure(E error) {
            this.error = error;
        }

        public final E getError() {
            return this.error;
        }

        public boolean equals(@&#8203;Nullable Object other) {
            return other instanceof Failure && Intrinsics.areEqual(this.error, ((Failure)other).error);
        }

        public int hashCode() {
            Object var10000 = this.error;
            return var10000 != null ? var10000.hashCode() : 0;
        }

        @&#8203;NotNull
        public String toString() {
            return "Failure(" + this.error + ')';
        }
    }
}

v1.1.21

Compare Source

This release serves as a bridge towards v2 and the last major release of v1.

Old behaviours have been deprecated in a non-breaking manner to anticipate the breaking changes of v2.

Additions

• Add flatMapEither, flatMapBoth (4e5cdee)
• Add mapCatching (15fc1ff)
  • See: https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/map-catching.html
• Add Iterable.allOk, Iterable.allErr, Iterable.anyOk, Iterable.anyErr, Iterable.countOk, Iterable.countErr (6e62d9f)
• Add Iterable.filterValues, Iterable.filterValuesTo, Iterable.filterErrors, Iterable.filterErrorsTo (f091f50)
• Add transpose (c46a292)
  • See: https://doc.rust-lang.org/std/result/enum.Result.html#method.transpose
• Return List of errors for all variants of zipOrAccumulate by @​YuitoSato (716109a)
  • The four-arg and five-arg variants were returning Collection instead of List.

Deprecations

• Deprecate getAll, getAllErrors in favour of filterValues & filterErrors (aca9ad9)
• Deprecate ResultBinding in favour of BindingScope (dd5c96f)
  • This matches the Kotlin stdlib naming convention used for sequences and coroutines.
• Deprecate suspending variant of binding in favour of coroutineBinding (b19894a)
  • This matches the internally-called function named coroutineScope, and helps consumers distinguish between the blocking variant that is otherwise only differing in package name.
  • This should also help convey to readers that structured concurrency will occur within the block.
• Deprecate Ok/Err as return types (7ce7c16)
  • This is in preparation for the v2 release where these don't exist as types.
• Deprecate getAll/getAllErrors in favour of valuesOf/errorsOf (522c821)

v1.1.20

Compare Source

• Pin GitHub actions by commit hash (8893187)
  • See: https://docs.github.com/en/actions/security-guides/security-hardening-for-github-actions#using-third-party-actions
• Add more build targets for coroutines extensions (a522fbd)
  • kotlinx-coroutines has since started publishing more native build targets since we first became multiplatform. This release ensures we also build native targets for the platforms that were previously missing, namely:
    • androidNativeArm32
    • androidNativeArm64
    • androidNativeX64
    • androidNativeX86
    • linuxArm64
    • wasmJs
  • This ensures that we are now supporting all three tiers of Kotlin/Native target support.

v1.1.19

Compare Source

• Document the order of output lists in Iterable.kt by @​peter-cunderlik-kmed (e81f581)
• Add zipOrAccumulate by @​YuitoSato (27f0a63)
• Update Kotlin to 1.9.20 (05a1e91)
  • "In Kotlin 1.9.20, we've also removed a number of previously deprecated targets, namely:"
    • iosArm32
    • watchosX86
    • wasm32
    • mingwX86
    • linuxMips32
    • linuxMipsel32
  • See: https://kotl.in/native-targets-tiers
• Add andThen{Recover,RecoverIf,RecoverUnless} by @​Jhabkin (d4414b1)
• Facilitate mapping to arbitrary types in and/or functions (05d50b7)
  • See #​95
• Extract shared build logic to convention plugins (88e31cd)
  • See: https://docs.gradle.org/current/userguide/sharing_build_logic_between_subprojects.html#sec:convention_plugins

ktorio/ktor (io.ktor:ktor-serialization-kotlinx-json)

v2.3.9

Compare Source

Published 4 March 2024

Improvements

• Allow to set secure cookie even with http scheme (KTOR-3159)

Bugfixes

• ContentNegotiation: the plugin appends duplicated MIME type to Accept header (KTOR-6684)

androidx/media (androidx.media3:media3-exoplayer-workmanager)

v1.3.0

Compare Source

This release includes the following changes since the
1.2.1 release:

• Common Library:
  • Implement support for android.resource://package/[type/]name raw
    resource URIs where package is different to the package of the current
    application. This has always been documented to work, but wasn't
    correctly implemented until now.
  • Normalize MIME types set by app code or read from media to be fully
    lower-case.
  • Define ads with a full MediaItem instead of a single Uri in
    AdPlaybackState.
  • Increase minSdk to 19 (Android KitKat). This is
    aligned with all other AndroidX libraries,
    and is required for us to upgrade to the latest versions of our AndroidX
    dependencies.
  • Populate both artworkUri and artworkData in
    MediaMetadata.Builder.populate(MediaMetadata) when at least one of
    them is non-null (#​964).
• ExoPlayer:
  • Add PreloadMediaSource and PreloadMediaPeriod that allows apps to
    preload a content media source at a specific start position before
    playback. PreloadMediaSource takes care of preparing the content media
    source to receive the Timeline, preparing and caching the period at
    the given start position, selecting tracks and loading media data for
    the period. Apps control the preload progress by implementing
    PreloadMediaSource.PreloadControl and set the preloaded source to the
    player for playback.
  • Add ExoPlayer.setImageOutput that allows apps to set
    ImageRenderer.ImageOutput.
  • DefaultRenderersFactory now provides an ImageRenderer to the player
    by default with null ImageOutput and ImageDecoder.Factory.DEFAULT.
  • Emit Player.Listener.onPositionDiscontinuity event when silence is
    skipped (#​765).
  • Add experimental support for parsing subtitles during extraction. You
    can enable this using
    MediaSource.Factory.experimentalParseSubtitlesDuringExtraction().
  • Support adaptive media sources with PreloadMediaSource.
  • Implement HttpEngineDataSource, an HttpDataSource using the
    HttpEngine
    API.
  • Prevent subclassing CompositeSequenceableLoader. This component was
    previously made extensible
    but was never subclassed within the library. Customizations can be done
    by wrapping an instance using the
    decorator pattern and
    implementing a custom CompositeSequenceableLoaderFactory.
  • Fix issue where repeating the same time causes metadata from this item
    to be cleared (#​1007).
  • Rename experimentalSetSubtitleParserFactory methods on
    BundledChunkExtractor.Factory and DefaultHlsExtractorFactory to
    setSubtitleParserFactory and disallow passing null. Use the new
    experimentalParseSubtitlesDuringExtraction(boolean) methods to control
    parsing behaviour.
  • Add support for customising the SubtitleParser.Factory used during
    extraction. This can be achieved with
    MediaSource.Factory.setSubtitleParserFactory().
  • Add source prefix to all Format.id fields generated from
    MergingMediaSource. This helps to identify which source produced a
    Format (#​883).
  • Fix the regex used for validating custom Common Media Client Data (CMCD)
    key names by modifying it to only check for hyphen
    (#​1028).
  • Stop double-encoding CMCD query parameters
    (#​1075).
• Transformer:
  • Add support for flattening H.265/HEVC SEF slow motion videos.
  • Increase transmuxing speed, especially for 'remove video' edits.
  • Add API to ensure that the output file starts on a video frame. This can
    make the output of trimming operations more compatible with player
    implementations that don't show the first video frame until its
    presentation timestamp
    (#​829).
  • Add support for optimizing single asset mp4 trim operations.
  • Add support to ensure a video frame has the first timestamp in the
    output file. Fixes output files beginning with black frame on iOS based
    players (#​829).
• Track Selection:
  • Add DefaultTrackSelector.selectImageTrack to enable image track
    selection.
  • Add TrackSelectionParameters.isPrioritizeImageOverVideoEnabled to
    determine whether to select an image track if both an image track and a
    video track are available. The default value is false which means
    selecting a video track is prioritized.
• Extractors:
  • Add additional AV1C parsing to MP4 extractor to retrieve
    ColorInfo.colorSpace, ColorInfo.colorTransfer, and
    ColorInfo.colorRange values
    (#​692).
  • MP3: Use constant bitrate (CBR) seeking for files with an Info header
    (the CBR equivalent of the Xing header). Previously we used the seek
    table from the Info header, but this results in less precise seeking
    than if we ignore it and assume the file is CBR.
  • MPEG2-TS: Add DTS, DTS-LBR and DTS:X Profile2 support
    (#​275).
  • Extract audio types from TS descriptors and map them to role flags,
    allowing users to make better-informed audio track selections
    (#​973).
• Audio:
  • Improve silence skipping algorithm with smooth volume ramp; retained
    minimal silence and more natural silence durations
    (#​7423).
  • Report the skipped silence more deterministically
    (#​1035).
• Video:
  • Change the MediaCodecVideoRenderer constructor that takes a
    VideoFrameProcessor.Factory argument and replace it with a constructor
    that takes a VideoSinkProvider argument. Apps that want to inject a
    custom VideoFrameProcessor.Factory can instantiate a
    CompositingVideoSinkProvider that uses the custom
    VideoFrameProcessor.Factory and pass the video sink provider to
    MediaCodecVideoRenderer.
• Text:
  • Fix serialization of bitmap cues to resolve Tried to marshall a Parcel that contained Binder objects error when using
    DefaultExtractorsFactory.setTextTrackTranscodingEnabled
    (#​836).
  • CEA-708: Ignore rowLock value. The CEA-708-E S-2023 spec states that
    rowLock and columnLock should both be assumed to be true, regardless
    of the values present in the stream (columnLock support is not
    implemented, so it's effectively assumed to always be false).
• Image:
  • Add support for DASH thumbnails. Grid images are cropped and individual
    thumbnails are provided to ImageOutput close to their presentation
    times.
• DRM:
  • Play 'clear lead' unencrypted samples in DRM content immediately by
    default, even if the keys for the later encrypted samples aren't ready
    yet. This may lead to mid-playback stalls if the keys still aren't ready
    when the playback position reaches the encrypted samples (but previously
    playback wouldn't have started at all by this point). This behavior can
    be disabled with
    MediaItem.DrmConfiguration.Builder.setPlayClearContentWithoutKey
    or
    DefaultDrmSessionManager.Builder.setPlayClearSamplesWithoutKeys.
• IMA extension:
  • Fix issue where DASH and HLS ads without the appropriate file extension
    can't be played.
• Session:
  • Disable double-click detection for TV apps
    (#​962).
  • Fix issue where MediaItem.RequestMetadata with just non-null extras is
    not transmitted between media controllers and sessions.
  • Add constructor to MediaLibrarySession.Builder that only takes a
    Context instead of a MediaLibraryService.
• HLS Extension:
  • Reduce HlsMediaPeriod to package-private visibility. This type
    shouldn't be directly depended on from outside the HLS package.
  • Resolve seeks to beginning of a segment more efficiently
    (#​1031).
• Decoder Extensions (FFmpeg, VP9, AV1, MIDI, etc.):
  • MIDI decoder: Ignore SysEx event messages
    (#​710).
• Test Utilities:
  • Don't pause playback in TestPlayerRunHelper.playUntilPosition. The
    test keeps the playback in a playing state, but suspends progress until
    the test is able to add assertions and further actions.
• Demo app:
  • Add a shortform demo module to demo the usage of PreloadMediaSource
    with the short-form content use case.

cashapp/molecule (app.cash.molecule:molecule-runtime)

v1.4.1

Compare Source

New:

• Support for linuxArm64 and wasmJs targets.

v1.4.0

Compare Source

Changed:

• Disable decoy generation for JS target to make compatible with JetBrains Compose 1.6. This is an ABI-breaking change, so all Compose-based libraries targeting JS will also need to have been recompiled.

This version works with Kotlin 1.9.22 by default.

cashapp/turbine (app.cash.turbine:turbine)

v1.1.0

Compare Source

Changed

• Add wasmJs target, remove iosArm32 and watchosX86 targets.
• Throw unconsumed events if scope is externally canceled.

---

Configuration

📅 Schedule: Branch creation - "before 4am on Monday" (UTC), Automerge - At any time (no schedule defined).

🚦 Automerge: Disabled by config. Please merge this manually once you are satisfied.

♻ Rebasing: Whenever PR becomes conflicted, or you tick the rebase/retry checkbox.

👻 Immortal: This PR will be recreated if closed unmerged. Get config help if that's undesired.

---

• If you want to rebase/retry this PR, check this box

---

This PR has been generated by Mend Renovate. View repository job log here.

[renovate]

Edited/Blocked Notification

Renovate will not automatically rebase this PR, because it does not recognize the last commit author and assumes somebody else may have edited the PR.

You can manually request rebase by checking the rebase/retry box above.

⚠ Warning: custom changes will be lost.