feat(Instagram): Disable Disable Reels scrolling by default

Co-authored-by: oSumAtrIX <johan.melkonyan1@web.de>

.github/workflows/build_pull_request.yml

@@ -25,7 +25,8 @@ jobs:
 
       - name: Build
         env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          ORG_GRADLE_PROJECT_githubPackagesUsername: ${{ env.GITHUB_ACTOR }}
+          ORG_GRADLE_PROJECT_githubPackagesPassword: ${{ secrets.GITHUB_TOKEN }}
         run: ./gradlew :patches:buildAndroid --no-daemon
 
       - name: Upload artifacts

.github/workflows/pull_strings.yml

@@ -2,7 +2,7 @@ name: Pull strings
 
 on:
   schedule:
-    - cron: "0 */12 * * *"
+    - cron: "0 0 * * 0"
   workflow_dispatch:
 
 jobs:

.github/workflows/release.yml

@@ -31,7 +31,8 @@ jobs:
 
       - name: Build
         env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          ORG_GRADLE_PROJECT_githubPackagesUsername: ${{ env.GITHUB_ACTOR }}
+          ORG_GRADLE_PROJECT_githubPackagesPassword: ${{ secrets.GITHUB_TOKEN }}
         run: ./gradlew :patches:buildAndroid clean
 
       - name: Setup Node.js

CHANGELOG.md

@@ -1,3 +1,11 @@
+# [5.48.0-dev.9](https://github.com/ReVanced/revanced-patches/compare/v5.48.0-dev.8...v5.48.0-dev.9) (2026-01-08)
+
+
+### Features
+
+* Add `Disable Sentry telemetry` patch ([#6416](https://github.com/ReVanced/revanced-patches/issues/6416)) ([4cc3159](https://github.com/ReVanced/revanced-patches/commit/4cc315952db557c565872de9e8484805f2e42305))
+* Disable Play Integrity patch ([#6412](https://github.com/ReVanced/revanced-patches/issues/6412)) ([6312fe8](https://github.com/ReVanced/revanced-patches/commit/6312fe8d60da24465c0c1b0fa4e94ceb79873d9c))
+
 # [5.48.0-dev.8](https://github.com/ReVanced/revanced-patches/compare/v5.48.0-dev.7...v5.48.0-dev.8) (2026-01-04)
 
 

crowdin.yml

@@ -1,8 +1,9 @@
 project_id_env: "CROWDIN_PROJECT_ID"
 api_token_env: "CROWDIN_PERSONAL_TOKEN"
 
-preserve_hierarchy: false
+preserve_hierarchy: true
 files:
     - source: patches/src/main/resources/addresources/values/strings.xml
+      dest: patches.xml
       translation: patches/src/main/resources/addresources/values-%android_code%/strings.xml
       skip_untranslated_strings: true

extensions/all/misc/disable-play-integrity/build.gradle.kts

@@ -0,0 +1,20 @@
+android {
+    namespace = "app.revanced.extension"
+
+    defaultConfig {
+        minSdk = 21
+    }
+
+    compileOptions {
+        sourceCompatibility = JavaVersion.VERSION_11
+        targetCompatibility = JavaVersion.VERSION_11
+    }
+
+    buildFeatures {
+        aidl = true
+    }
+}
+
+dependencies {
+    compileOnly(libs.annotation)
+}

extensions/all/misc/disable-play-integrity/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest/>

extensions/all/misc/disable-play-integrity/src/main/aidl/com/google/android/play/core/integrity/protocol/IExpressIntegrityService.aidl

@@ -0,0 +1,8 @@
+package com.google.android.play.core.integrity.protocol;
+
+import android.os.Bundle;
+import com.google.android.play.core.integrity.protocol.IExpressIntegrityServiceCallback;
+
+interface IExpressIntegrityService {
+    oneway void requestIntegrityToken(in Bundle request, IExpressIntegrityServiceCallback callback) = 2;
+}

extensions/all/misc/disable-play-integrity/src/main/aidl/com/google/android/play/core/integrity/protocol/IExpressIntegrityServiceCallback.aidl

@@ -0,0 +1,5 @@
+package com.google.android.play.core.integrity.protocol;
+
+interface IExpressIntegrityServiceCallback {
+    oneway void onRequestExpressIntegrityTokenResult(in Bundle result) = 2;
+}

extensions/all/misc/disable-play-integrity/src/main/aidl/com/google/android/play/core/integrity/protocol/IIntegrityService.aidl

@@ -0,0 +1,8 @@
+package com.google.android.play.core.integrity.protocol;
+
+import android.os.Bundle;
+import com.google.android.play.core.integrity.protocol.IIntegrityServiceCallback;
+
+interface IIntegrityService {
+    oneway void requestIntegrityToken(in Bundle request, IIntegrityServiceCallback callback) = 1;
+}

extensions/all/misc/disable-play-integrity/src/main/aidl/com/google/android/play/core/integrity/protocol/IIntegrityServiceCallback.aidl

@@ -0,0 +1,7 @@
+package com.google.android.play.core.integrity.protocol;
+
+import android.os.Bundle;
+
+interface IIntegrityServiceCallback {
+    oneway void onResult(in Bundle result) = 1;
+}

extensions/all/misc/disable-play-integrity/src/main/java/android/ext/PackageId.java

@@ -0,0 +1,10 @@
+package android.ext;
+/** @hide */
+// Int values that are assigned to packages in this interface can be retrieved at runtime from
+// ApplicationInfo.ext().getPackageId() or from AndroidPackage.ext().getPackageId() (in system_server).
+//
+// PackageIds are assigned to parsed APKs only after they are verified, either by a certificate check
+// or by a check that the APK is stored on an immutable OS partition.
+public interface PackageId {
+    String PLAY_STORE_NAME = "com.android.vending";
+}

extensions/all/misc/disable-play-integrity/src/main/java/android/os/BinderWrapper.java

@@ -0,0 +1,62 @@
+package android.os;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import java.io.FileDescriptor;
+
+/** @hide */
+public class BinderWrapper implements IBinder {
+    protected final IBinder base;
+
+    public BinderWrapper(IBinder base) {
+        this.base = base;
+    }
+
+    @Override
+    public boolean transact(int code, @NonNull Parcel data, @Nullable Parcel reply, int flags) throws RemoteException {
+        return base.transact(code, data, reply, flags);
+    }
+
+    @Nullable
+    @Override
+    public IInterface queryLocalInterface(@NonNull String descriptor) {
+        return base.queryLocalInterface(descriptor);
+    }
+
+    @Nullable
+    @Override
+    public String getInterfaceDescriptor() throws RemoteException {
+        return base.getInterfaceDescriptor();
+    }
+
+    @Override
+    public boolean pingBinder() {
+        return base.pingBinder();
+    }
+
+    @Override
+    public boolean isBinderAlive() {
+        return base.isBinderAlive();
+    }
+
+    @Override
+    public void dump(@NonNull FileDescriptor fd, @Nullable String[] args) throws RemoteException {
+        base.dump(fd, args);
+    }
+
+    @Override
+    public void dumpAsync(@NonNull FileDescriptor fd, @Nullable String[] args) throws RemoteException {
+        base.dumpAsync(fd, args);
+    }
+
+    @Override
+    public void linkToDeath(@NonNull DeathRecipient recipient, int flags) throws RemoteException {
+        base.linkToDeath(recipient, flags);
+    }
+
+    @Override
+    public boolean unlinkToDeath(@NonNull DeathRecipient recipient, int flags) {
+        return base.unlinkToDeath(recipient, flags);
+    }
+}

extensions/all/misc/disable-play-integrity/src/main/java/app/grapheneos/gmscompat/lib/playintegrity/ClassicPlayIntegrityServiceWrapper.java

@@ -0,0 +1,41 @@
+package app.grapheneos.gmscompat.lib.playintegrity;
+
+import android.os.Binder;
+import android.os.Bundle;
+import android.os.IBinder;
+import android.os.RemoteException;
+import android.util.Log;
+
+import com.android.internal.os.FakeBackgroundHandler;
+import com.google.android.play.core.integrity.protocol.IIntegrityService;
+import com.google.android.play.core.integrity.protocol.IIntegrityServiceCallback;
+
+class ClassicPlayIntegrityServiceWrapper extends PlayIntegrityServiceWrapper {
+
+    ClassicPlayIntegrityServiceWrapper(IBinder base) {
+        super(base);
+        requestIntegrityTokenTxnCode = 2; // IIntegrityService.Stub.TRANSACTION_requestIntegrityToken
+    }
+
+    static class TokenRequestStub extends IIntegrityService.Stub {
+        public void requestIntegrityToken(Bundle request, IIntegrityServiceCallback callback) {
+            Runnable r = () -> {
+                var result = new Bundle();
+                // https://developer.android.com/google/play/integrity/reference/com/google/android/play/core/integrity/model/IntegrityErrorCode.html#API_NOT_AVAILABLE
+                final int API_NOT_AVAILABLE = -1;
+                result.putInt("error", API_NOT_AVAILABLE);
+                try {
+                    callback.onResult(result);
+                } catch (RemoteException e) {
+                    Log.e("IIntegrityService.Stub", "", e);
+                }
+            };
+            FakeBackgroundHandler.getHandler().postDelayed(r, getTokenRequestResultDelay());
+        }
+    };
+
+    @Override
+    protected Binder createTokenRequestStub() {
+        return new TokenRequestStub();
+    }
+}

extensions/all/misc/disable-play-integrity/src/main/java/app/grapheneos/gmscompat/lib/playintegrity/PlayIntegrityServiceWrapper.java

@@ -0,0 +1,48 @@
+package app.grapheneos.gmscompat.lib.playintegrity;
+
+import android.os.Binder;
+import android.os.BinderWrapper;
+import android.os.IBinder;
+import android.os.Parcel;
+import android.os.RemoteException;
+import android.util.Log;
+
+import androidx.annotation.Nullable;
+
+abstract class PlayIntegrityServiceWrapper extends BinderWrapper {
+    final String TAG;
+    protected int requestIntegrityTokenTxnCode;
+
+    public PlayIntegrityServiceWrapper(IBinder base) {
+        super(base);
+        TAG = getClass().getSimpleName();
+    }
+
+    protected abstract Binder createTokenRequestStub();
+
+    @Override
+    public boolean transact(int code, Parcel data, @Nullable Parcel reply, int flags) throws RemoteException {
+        if (code == requestIntegrityTokenTxnCode) {
+            if (maybeStubOutIntegrityTokenRequest(code, data, reply, flags)) {
+                return true;
+            }
+        }
+        return super.transact(code, data, reply, flags);
+    }
+
+    private boolean maybeStubOutIntegrityTokenRequest(int code, Parcel data, @Nullable Parcel reply, int flags) {
+        Log.d(TAG, "integrity token request detected");
+
+        try {
+            createTokenRequestStub().transact(code, data, reply, flags);
+        } catch (RemoteException e) {
+            // this is a local call
+            throw new IllegalStateException(e);
+        }
+        return true;
+    }
+
+    protected static long getTokenRequestResultDelay() {
+        return 500L;
+    }
+}

extensions/all/misc/disable-play-integrity/src/main/java/app/grapheneos/gmscompat/lib/playintegrity/PlayIntegrityUtils.java

@@ -0,0 +1,35 @@
+package app.grapheneos.gmscompat.lib.playintegrity;
+
+import android.content.Intent;
+import android.content.ServiceConnection;
+import android.ext.PackageId;
+import android.os.IBinder;
+import androidx.annotation.Nullable;
+import app.grapheneos.gmscompat.lib.util.ServiceConnectionWrapper;
+import java.util.function.UnaryOperator;
+
+public class PlayIntegrityUtils {
+
+    public static @Nullable ServiceConnection maybeReplaceServiceConnection(Intent service, ServiceConnection orig) {
+        if (PackageId.PLAY_STORE_NAME.equals(service.getPackage())) {
+            UnaryOperator<IBinder> binderOverride = null;
+
+            final String CLASSIC_SERVICE =
+                    "com.google.android.play.core.integrityservice.BIND_INTEGRITY_SERVICE";
+            final String STANDARD_SERVICE =
+                    "com.google.android.play.core.expressintegrityservice.BIND_EXPRESS_INTEGRITY_SERVICE";
+
+            String action = service.getAction();
+            if (STANDARD_SERVICE.equals(action)) {
+                binderOverride = StandardPlayIntegrityServiceWrapper::new;
+            } else if (CLASSIC_SERVICE.equals(action)) {
+                binderOverride = ClassicPlayIntegrityServiceWrapper::new;
+            }
+
+            if (binderOverride != null) {
+                return new ServiceConnectionWrapper(orig, binderOverride);
+            }
+        }
+        return null;
+    }
+}

extensions/all/misc/disable-play-integrity/src/main/java/app/grapheneos/gmscompat/lib/playintegrity/StandardPlayIntegrityServiceWrapper.java

@@ -0,0 +1,42 @@
+package app.grapheneos.gmscompat.lib.playintegrity;
+
+import android.annotation.SuppressLint;
+import android.os.Binder;
+import android.os.Bundle;
+import android.os.IBinder;
+import android.os.RemoteException;
+import android.util.Log;
+import com.android.internal.os.FakeBackgroundHandler;
+import com.google.android.play.core.integrity.protocol.IExpressIntegrityService;
+import com.google.android.play.core.integrity.protocol.IExpressIntegrityServiceCallback;
+
+@SuppressLint("LongLogTag")
+class StandardPlayIntegrityServiceWrapper extends PlayIntegrityServiceWrapper {
+
+    StandardPlayIntegrityServiceWrapper(IBinder base) {
+        super(base);
+        requestIntegrityTokenTxnCode = 3; // IExpressIntegrityService.Stub.TRANSACTION_requestIntegrityToken
+    }
+
+    static class TokenRequestStub extends IExpressIntegrityService.Stub {
+        public void requestIntegrityToken(Bundle request, IExpressIntegrityServiceCallback callback) {
+            Runnable r = () -> {
+                var result = new Bundle();
+                // https://developer.android.com/google/play/integrity/reference/com/google/android/play/core/integrity/model/StandardIntegrityErrorCode.html#API_NOT_AVAILABLE
+                final int API_NOT_AVAILABLE = -1;
+                result.putInt("error", API_NOT_AVAILABLE);
+                try {
+                    callback.onRequestExpressIntegrityTokenResult(result);
+                } catch (RemoteException e) {
+                    Log.e("IExpressIntegrityService.Stub", "", e);
+                }
+            };
+            FakeBackgroundHandler.getHandler().postDelayed(r, getTokenRequestResultDelay());
+        }
+    };
+
+    @Override
+    protected Binder createTokenRequestStub() {
+        return new TokenRequestStub();
+    }
+}

extensions/all/misc/disable-play-integrity/src/main/java/app/grapheneos/gmscompat/lib/util/ServiceConnectionWrapper.java

@@ -0,0 +1,49 @@
+package app.grapheneos.gmscompat.lib.util;
+
+import android.content.ComponentName;
+import android.content.ServiceConnection;
+import android.os.Build;
+import android.os.IBinder;
+
+import java.util.function.UnaryOperator;
+
+public class ServiceConnectionWrapper implements ServiceConnection {
+    private final ServiceConnection base;
+    private final UnaryOperator<IBinder> binderOverride;
+
+    public ServiceConnectionWrapper(ServiceConnection base, UnaryOperator<IBinder> binderOverride) {
+        this.base = base;
+        this.binderOverride = binderOverride;
+    }
+
+    @Override
+    public void onServiceConnected(ComponentName name, IBinder service) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
+            IBinder override = binderOverride.apply(service);
+            if (override != null) {
+                service = override;
+            }
+        }
+
+        base.onServiceConnected(name, service);
+    }
+
+    @Override
+    public void onServiceDisconnected(ComponentName name) {
+        base.onServiceDisconnected(name);
+    }
+
+    @Override
+    public void onBindingDied(ComponentName name) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            base.onBindingDied(name);
+        }
+    }
+
+    @Override
+    public void onNullBinding(ComponentName name) {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+            base.onNullBinding(name);
+        }
+    }
+}

extensions/all/misc/disable-play-integrity/src/main/java/app/revanced/extension/playintegrity/DisablePlayIntegrityPatch.java

@@ -0,0 +1,17 @@
+package app.revanced.extension.playintegrity;
+
+import android.content.Context;
+import android.content.Intent;
+import android.content.ServiceConnection;
+import app.grapheneos.gmscompat.lib.playintegrity.PlayIntegrityUtils;
+
+public class DisablePlayIntegrityPatch {
+    public static boolean bindService(Context context, Intent service, ServiceConnection conn, int flags) {
+        ServiceConnection override = PlayIntegrityUtils.maybeReplaceServiceConnection(service, conn);
+        if (override != null) {
+            conn = override;
+        }
+
+        return context.bindService(service, conn, flags);
+    }
+}

extensions/all/misc/disable-play-integrity/src/main/java/com/android/internal/os/FakeBackgroundHandler.java

@@ -0,0 +1,11 @@
+package com.android.internal.os;
+
+import android.os.Handler;
+import android.os.Looper;
+
+public class FakeBackgroundHandler {
+
+    public static Handler getHandler() {
+        return new Handler(Looper.getMainLooper());
+    }
+}

extensions/shared/library/src/main/java/app/revanced/extension/shared/Utils.java

@@ -311,6 +311,10 @@ public class Utils {
         return resourceId;
     }
 
+    public static String getResourceString(int id) throws Resources.NotFoundException {
+        return getContext().getResources().getString(id);
+    }
+
     public static int getResourceInteger(String resourceIdentifierName) throws Resources.NotFoundException {
         return getContext().getResources().getInteger(getResourceIdentifierOrThrow(resourceIdentifierName, "integer"));
     }

extensions/strava/build.gradle.kts

@@ -0,0 +1,5 @@
+dependencies {
+    compileOnly(project(":extensions:shared:library"))
+    compileOnly(project(":extensions:strava:stub"))
+    compileOnly(libs.okhttp)
+}

extensions/strava/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest/>

extensions/strava/src/main/java/app/revanced/extension/strava/AddMediaDownloadPatch.java

@@ -0,0 +1,216 @@
+package app.revanced.extension.strava;
+
+import android.annotation.SuppressLint;
+import android.content.ContentResolver;
+import android.content.ContentValues;
+import android.content.Context;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Environment;
+import android.provider.MediaStore;
+import android.webkit.MimeTypeMap;
+
+import com.strava.core.data.MediaType;
+import com.strava.photos.data.Media;
+
+import okhttp3.*;
+
+import java.io.BufferedReader;
+import java.io.InputStream;
+import java.io.IOException;
+import java.io.OutputStream;
+import java.util.List;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.Future;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import app.revanced.extension.shared.Utils;
+
+@SuppressLint("NewApi")
+public final class AddMediaDownloadPatch {
+    public static final int ACTION_DOWNLOAD = -1;
+    public static final int ACTION_OPEN_LINK = -2;
+    public static final int ACTION_COPY_LINK = -3;
+
+    private static final OkHttpClient client = new OkHttpClient();
+
+    public static boolean handleAction(int actionId, Media media) {
+        String url = getUrl(media);
+        switch (actionId) {
+            case ACTION_DOWNLOAD:
+                String name = media.getId();
+                if (media.getType() == MediaType.VIDEO) {
+                    downloadVideo(url, name);
+                } else {
+                    downloadPhoto(url, name);
+                }
+                return true;
+            case ACTION_OPEN_LINK:
+                Utils.openLink(url);
+                return true;
+            case ACTION_COPY_LINK:
+                copyLink(url);
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    public static void copyLink(CharSequence url) {
+        Utils.setClipboard(url);
+        showInfoToast("link_copied_to_clipboard", "🔗");
+    }
+
+    public static void downloadPhoto(String url, String name) {
+        showInfoToast("loading", "⏳");
+        Utils.runOnBackgroundThread(() -> {
+            try (Response response = fetch(url)) {
+                ResponseBody body = response.body();
+                String mimeType = body.contentType().toString();
+                String extension = MimeTypeMap.getSingleton().getExtensionFromMimeType(mimeType);
+                ContentResolver resolver = Utils.getContext().getContentResolver();
+                ContentValues values = new ContentValues();
+                values.put(MediaStore.Images.Media.DISPLAY_NAME, name + '.' + extension);
+                values.put(MediaStore.Images.Media.IS_PENDING, 1);
+                values.put(MediaStore.Images.Media.MIME_TYPE, mimeType);
+                values.put(MediaStore.Images.Media.RELATIVE_PATH, Environment.DIRECTORY_PICTURES + "/Strava");
+                Uri collection = Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q
+                        ? MediaStore.Images.Media.getContentUri(MediaStore.VOLUME_EXTERNAL)
+                        : MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
+                Uri row = resolver.insert(collection, values);
+                try (OutputStream outputStream = resolver.openOutputStream(row)) {
+                    transferTo(body.byteStream(), outputStream);
+                } finally {
+                    values.clear();
+                    values.put(MediaStore.Images.Media.IS_PENDING, 0);
+                    resolver.update(row, values, null);
+                }
+                showInfoToast("yis_2024_local_save_image_success", "✔️");
+            } catch (IOException e) {
+                showErrorToast("download_failure", "❌", e);
+            }
+        });
+    }
+
+    /**
+     * Downloads a video in the M3U8 / HLS (HTTP Live Streaming) format.
+     */
+    public static void downloadVideo(String url, String name) {
+        // The first request yields multiple URLs with different stream options.
+        // In case of Strava, the first one is always of highest quality.
+        // Each stream can consist of multiple chunks.
+        // The second request yields the URLs of all of these chunks.
+        // Fetch all of them concurrently and pipe their streams into the file in order.
+        showInfoToast("loading", "⏳");
+        Utils.runOnBackgroundThread(() -> {
+            try {
+                String highestQualityStreamUrl;
+                try (Response response = fetch(url)) {
+                    highestQualityStreamUrl = replaceFileName(url, lines(response).findFirst().get());
+                }
+                List<Future<Response>> futures;
+                try (Response response = fetch(highestQualityStreamUrl)) {
+                    futures = lines(response)
+                            .map(line -> replaceFileName(highestQualityStreamUrl, line))
+                            .map(chunkUrl -> Utils.submitOnBackgroundThread(() -> fetch(chunkUrl)))
+                            .collect(Collectors.toList());
+                }
+                ContentResolver resolver = Utils.getContext().getContentResolver();
+                ContentValues values = new ContentValues();
+                values.put(MediaStore.Video.Media.DISPLAY_NAME, name + '.' + "mp4");
+                values.put(MediaStore.Video.Media.IS_PENDING, 1);
+                values.put(MediaStore.Video.Media.MIME_TYPE, MimeTypeMap.getSingleton().getMimeTypeFromExtension("mp4"));
+                values.put(MediaStore.Video.Media.RELATIVE_PATH, Environment.DIRECTORY_MOVIES + "/Strava");
+                Uri collection = Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q
+                        ? MediaStore.Video.Media.getContentUri(MediaStore.VOLUME_EXTERNAL)
+                        : MediaStore.Video.Media.EXTERNAL_CONTENT_URI;
+                Uri row = resolver.insert(collection, values);
+                try (OutputStream outputStream = resolver.openOutputStream(row)) {
+                    Throwable error = null;
+                    for (Future<Response> future : futures) {
+                        if (error != null) {
+                            if (future.cancel(true)) {
+                                continue;
+                            }
+                        }
+                        try (Response response = future.get()) {
+                            if (error == null) {
+                                transferTo(response.body().byteStream(), outputStream);
+                            }
+                        } catch (InterruptedException | IOException e) {
+                            error = e;
+                        } catch (ExecutionException e) {
+                            error = e.getCause();
+                        }
+                    }
+                    if (error != null) {
+                        throw new IOException(error);
+                    }
+                } finally {
+                    values.clear();
+                    values.put(MediaStore.Video.Media.IS_PENDING, 0);
+                    resolver.update(row, values, null);
+                }
+                showInfoToast("yis_2024_local_save_video_success", "✔️");
+            } catch (IOException e) {
+                showErrorToast("download_failure", "❌", e);
+            }
+        });
+    }
+
+    private static String getUrl(Media media) {
+        return media.getType() == MediaType.VIDEO
+                ? ((Media.Video) media).getVideoUrl()
+                : media.getLargestUrl();
+    }
+
+    private static String getString(String name, String fallback) {
+        int id = Utils.getResourceIdentifier(name, "string");
+        return id != 0
+                ? Utils.getResourceString(id)
+                : fallback;
+    }
+
+    private static void showInfoToast(String resourceName, String fallback) {
+        String text = getString(resourceName, fallback);
+        Utils.showToastShort(text);
+    }
+
+    private static void showErrorToast(String resourceName, String fallback, IOException exception) {
+        String text = getString(resourceName, fallback);
+        Utils.showToastLong(text + ' ' + exception.getLocalizedMessage());
+    }
+
+    private static Response fetch(String url) throws IOException {
+        Request request = new Request.Builder().url(url).build();
+        Response response = client.newCall(request).execute();
+        if (!response.isSuccessful()) {
+            throw new IOException("Got HTTP status code " + response.code());
+        }
+        return response;
+    }
+
+    /**
+     * {@code inputStream.transferTo(outputStream)} is "too new".
+     */
+    private static void transferTo(InputStream in, OutputStream out) throws IOException {
+        byte[] buffer = new byte[1024 * 8];
+        int length;
+        while ((length = in.read(buffer)) != -1) {
+            out.write(buffer, 0, length);
+        }
+    }
+
+    /**
+     * Gets all file names.
+     */
+    private static Stream<String> lines(Response response) {
+        BufferedReader reader = new BufferedReader(response.body().charStream());
+        return reader.lines().filter(line -> !line.startsWith("#"));
+    }
+
+    private static String replaceFileName(String uri, String newName) {
+        return uri.substring(0, uri.lastIndexOf('/') + 1) + newName;
+    }
+}

extensions/strava/stub/build.gradle.kts

@@ -0,0 +1,12 @@
+plugins {
+    alias(libs.plugins.android.library)
+}
+
+android {
+    namespace = "app.revanced.extension"
+    compileSdk = 34
+
+    defaultConfig {
+        minSdk = 21
+    }
+}

extensions/strava/stub/src/main/AndroidManifest.xml

@@ -0,0 +1 @@
+<manifest/>

extensions/strava/stub/src/main/java/com/strava/core/data/MediaContent.java

@@ -0,0 +1,15 @@
+package com.strava.core.data;
+
+import java.io.Serializable;
+
+public interface MediaContent extends Serializable {
+    String getCaption();
+
+    String getId();
+
+    String getReferenceId();
+
+    MediaType getType();
+
+    void setCaption(String caption);
+}

extensions/strava/stub/src/main/java/com/strava/core/data/MediaDimension.java

@@ -0,0 +1,44 @@
+package com.strava.core.data;
+
+import java.io.Serializable;
+
+public final class MediaDimension implements Comparable<MediaDimension>, Serializable {
+    private final int height;
+    private final int width;
+
+    public MediaDimension(int width, int height) {
+        this.width = width;
+        this.height = height;
+    }
+
+    public int getHeight() {
+        return height;
+    }
+
+    public float getHeightScale() {
+        if (width <= 0 || height <= 0) {
+            return 1f;
+        }
+        return height / width;
+    }
+
+    public int getWidth() {
+        return width;
+    }
+
+    public float getWidthScale() {
+        if (width <= 0 || height <= 0) {
+            return 1f;
+        }
+        return width / height;
+    }
+
+    public boolean isLandscape() {
+        return width > 0 && width >= height;
+    }
+
+    @Override
+    public int compareTo(MediaDimension other) {
+        return 0;
+    }
+}

extensions/strava/stub/src/main/java/com/strava/core/data/MediaType.java

@@ -0,0 +1,16 @@
+package com.strava.core.data;
+
+public enum MediaType {
+    PHOTO(1),
+    VIDEO(2);
+
+    private final int remoteValue;
+
+    private MediaType(int remoteValue) {
+        this.remoteValue = remoteValue;
+    }
+
+    public int getRemoteValue() {
+        return remoteValue;
+    }
+}

extensions/strava/stub/src/main/java/com/strava/core/data/RemoteMediaContent.java

@@ -0,0 +1,17 @@
+package com.strava.core.data;
+
+import java.util.SortedMap;
+
+public interface RemoteMediaContent extends MediaContent {
+    MediaDimension getLargestSize();
+
+    String getLargestUrl();
+
+    SortedMap<Integer, MediaDimension> getSizes();
+
+    String getSmallestUrl();
+
+    RemoteMediaStatus getStatus();
+
+    SortedMap<Integer, String> getUrls();
+}

extensions/strava/stub/src/main/java/com/strava/core/data/RemoteMediaStatus.java

@@ -0,0 +1,11 @@
+package com.strava.core.data;
+
+public enum RemoteMediaStatus {
+    NEW,
+    PENDING,
+    PROCESSED,
+    REPORTED,
+    REINSTATED,
+    DELETED,
+    FAILED
+}

extensions/strava/stub/src/main/java/com/strava/photos/data/Media.java

@@ -0,0 +1,286 @@
+package com.strava.photos.data;
+
+import com.strava.core.data.MediaDimension;
+import com.strava.core.data.MediaType;
+import com.strava.core.data.RemoteMediaContent;
+import com.strava.core.data.RemoteMediaStatus;
+import java.util.SortedMap;
+
+public abstract class Media implements RemoteMediaContent {
+    public static final class Photo extends Media {
+        private final Long activityId;
+        private final String activityName;
+        private final long athleteId;
+        private String caption;
+        private final String createdAt;
+        private final String createdAtLocal;
+        private final String cursor;
+        private final String id;
+        private final SortedMap<Integer, MediaDimension> sizes;
+        private final RemoteMediaStatus status;
+        private final String tag;
+        private final MediaType type;
+        private final SortedMap<Integer, String> urls;
+
+        @Override
+        public Long getActivityId() {
+            return activityId;
+        }
+
+        @Override
+        public String getActivityName() {
+            return activityName;
+        }
+
+        @Override
+        public long getAthleteId() {
+            return athleteId;
+        }
+
+        @Override
+        public String getCaption() {
+            return caption;
+        }
+
+        @Override
+        public String getCreatedAt() {
+            return createdAt;
+        }
+
+        @Override
+        public String getCreatedAtLocal() {
+            return createdAtLocal;
+        }
+
+        @Override
+        public String getCursor() {
+            return cursor;
+        }
+
+        @Override
+        public String getId() {
+            return id;
+        }
+
+        @Override
+        public SortedMap<Integer, MediaDimension> getSizes() {
+            return sizes;
+        }
+
+        @Override
+        public RemoteMediaStatus getStatus() {
+            return status;
+        }
+
+        @Override
+        public String getTag() {
+            return tag;
+        }
+
+        @Override
+        public MediaType getType() {
+            return type;
+        }
+
+        @Override
+        public SortedMap<Integer, String> getUrls() {
+            return urls;
+        }
+
+        @Override
+        public void setCaption(String caption) {
+            this.caption = caption;
+        }
+
+        public Photo(String id,
+                     String caption,
+                     SortedMap<Integer, String> urls,
+                     SortedMap<Integer, MediaDimension> sizes,
+                     long athleteId,
+                     String createdAt,
+                     String createdAtLocal,
+                     Long activityId,
+                     String activityName,
+                     RemoteMediaStatus status,
+                     String tag,
+                     String cursor) {
+            this.id = id;
+            this.caption = caption;
+            this.urls = urls;
+            this.sizes = sizes;
+            this.athleteId = athleteId;
+            this.createdAt = createdAt;
+            this.createdAtLocal = createdAtLocal;
+            this.activityId = activityId;
+            this.activityName = activityName;
+            this.status = status;
+            this.tag = tag;
+            this.cursor = cursor;
+            this.type = MediaType.PHOTO;
+        }
+    }
+
+    public static final class Video extends Media {
+        private final Long activityId;
+        private final String activityName;
+        private final long athleteId;
+        private String caption;
+        private final String createdAt;
+        private final String createdAtLocal;
+        private final String cursor;
+        private final Float durationSeconds;
+        private final String id;
+        private final SortedMap<Integer, MediaDimension> sizes;
+        private final RemoteMediaStatus status;
+        private final String tag;
+        private final MediaType type;
+        private final SortedMap<Integer, String> urls;
+        private final String videoUrl;
+
+        @Override
+        public Long getActivityId() {
+            return activityId;
+        }
+
+        @Override
+        public String getActivityName() {
+            return activityName;
+        }
+
+        @Override
+        public long getAthleteId() {
+            return athleteId;
+        }
+
+        @Override
+        public String getCaption() {
+            return caption;
+        }
+
+        @Override
+        public String getCreatedAt() {
+            return createdAt;
+        }
+
+        @Override
+        public String getCreatedAtLocal() {
+            return createdAtLocal;
+        }
+
+        @Override
+        public String getCursor() {
+            return cursor;
+        }
+
+        public final Float getDurationSeconds() {
+            return durationSeconds;
+        }
+
+        @Override
+        public String getId() {
+            return id;
+        }
+
+        @Override
+        public SortedMap<Integer, MediaDimension> getSizes() {
+            return sizes;
+        }
+
+        @Override
+        public RemoteMediaStatus getStatus() {
+            return status;
+        }
+
+        @Override
+        public String getTag() {
+            return tag;
+        }
+
+        @Override
+        public MediaType getType() {
+            return type;
+        }
+
+        @Override
+        public SortedMap<Integer, String> getUrls() {
+            return urls;
+        }
+
+        public final String getVideoUrl() {
+            return videoUrl;
+        }
+
+        @Override
+        public void setCaption(String caption) {
+            this.caption = caption;
+        }
+
+        public Video(String id,
+                     String caption,
+                     SortedMap<Integer, String> urls,
+                     SortedMap<Integer, MediaDimension> sizes,
+                     long athleteId,
+                     String createdAt,
+                     String createdAtLocal,
+                     Long activityId,
+                     String activityName,
+                     RemoteMediaStatus status,
+                     String videoUrl,
+                     Float durationSeconds,
+                     String tag,
+                     String cursor) {
+            this.id = id;
+            this.caption = caption;
+            this.urls = urls;
+            this.sizes = sizes;
+            this.athleteId = athleteId;
+            this.createdAt = createdAt;
+            this.createdAtLocal = createdAtLocal;
+            this.activityId = activityId;
+            this.activityName = activityName;
+            this.status = status;
+            this.videoUrl = videoUrl;
+            this.durationSeconds = durationSeconds;
+            this.tag = tag;
+            this.cursor = cursor;
+            this.type = MediaType.VIDEO;
+        }
+    }
+
+    public abstract Long getActivityId();
+
+    public abstract String getActivityName();
+
+    public abstract long getAthleteId();
+
+    public abstract String getCreatedAt();
+
+    public abstract String getCreatedAtLocal();
+
+    public abstract String getCursor();
+
+    @Override
+    public MediaDimension getLargestSize() {
+        return null;
+    }
+
+    @Override
+    public String getLargestUrl() {
+        return null;
+    }
+
+    @Override
+    public String getReferenceId() {
+        return null;
+    }
+
+    @Override
+    public String getSmallestUrl() {
+        return null;
+    }
+
+    public abstract String getTag();
+
+    private Media() {
+    }
+}

extensions/youtube/src/main/java/app/revanced/extension/youtube/patches/PauseOnAudioInterruptPatch.java

@@ -0,0 +1,30 @@
+package app.revanced.extension.youtube.patches;
+
+import app.revanced.extension.youtube.settings.Settings;
+
+@SuppressWarnings("unused")
+public class PauseOnAudioInterruptPatch {
+
+    private static final int AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK = -3;
+    private static final int AUDIOFOCUS_LOSS_TRANSIENT = -2;
+
+    /**
+     * Injection point for AudioFocusRequest builder.
+     * Returns true if audio ducking should be disabled (willPauseWhenDucked = true).
+     */
+    public static boolean shouldPauseOnAudioInterrupt() {
+        return Settings.PAUSE_ON_AUDIO_INTERRUPT.get();
+    }
+
+    /**
+     * Injection point for onAudioFocusChange callback.
+     * Converts AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK to AUDIOFOCUS_LOSS_TRANSIENT
+     * when the setting is enabled, causing YouTube to pause instead of ducking.
+     */
+    public static int overrideAudioFocusChange(int focusChange) {
+        if (Settings.PAUSE_ON_AUDIO_INTERRUPT.get() && focusChange == AUDIOFOCUS_LOSS_TRANSIENT_CAN_DUCK) {
+            return AUDIOFOCUS_LOSS_TRANSIENT;
+        }
+        return focusChange;
+    }
+}

extensions/youtube/src/main/java/app/revanced/extension/youtube/settings/Settings.java

@@ -356,6 +356,7 @@ public class Settings extends BaseSettings {
     public static final IntegerSetting ANNOUNCEMENT_LAST_ID = new IntegerSetting("revanced_announcement_last_id", -1, false, false);
     public static final BooleanSetting LOOP_VIDEO = new BooleanSetting("revanced_loop_video", FALSE);
     public static final BooleanSetting LOOP_VIDEO_BUTTON = new BooleanSetting("revanced_loop_video_button", FALSE);
+    public static final BooleanSetting PAUSE_ON_AUDIO_INTERRUPT = new BooleanSetting("revanced_pause_on_audio_interrupt", FALSE, true);
     public static final BooleanSetting BYPASS_URL_REDIRECTS = new BooleanSetting("revanced_bypass_url_redirects", TRUE);
     public static final BooleanSetting DISABLE_HAPTIC_FEEDBACK_CHAPTERS = new BooleanSetting("revanced_disable_haptic_feedback_chapters", FALSE);
     public static final BooleanSetting DISABLE_HAPTIC_FEEDBACK_PRECISE_SEEKING = new BooleanSetting("revanced_disable_haptic_feedback_precise_seeking", FALSE);

gradle.properties

@@ -3,4 +3,4 @@ org.gradle.jvmargs = -Xms512M -Xmx2048M
 org.gradle.parallel = true
 android.useAndroidX = true
 kotlin.code.style = official
-version = 5.48.0-dev.8
+version = 5.48.0-dev.9

patches/api/patches.api

@@ -104,6 +104,10 @@ public final class app/revanced/patches/all/misc/packagename/ChangePackageNamePa
 	public static final fun setPackageNameOption (Lapp/revanced/patcher/patch/Option;)V
 }
 
+public final class app/revanced/patches/all/misc/playintegrity/DisablePlayIntegrityKt {
+	public static final fun getDisablePlayIntegrityPatch ()Lapp/revanced/patcher/patch/BytecodePatch;
+}
+
 public final class app/revanced/patches/all/misc/resources/AddResourcesPatchKt {
 	public static final fun addResource (Ljava/lang/String;Lapp/revanced/util/resource/BaseResource;)Z
 	public static final fun addResources (Lapp/revanced/patcher/patch/Patch;Lkotlin/jvm/functions/Function1;)Z
@@ -940,6 +944,10 @@ public final class app/revanced/patches/shared/misc/pairip/license/DisableLicens
 	public static final fun getDisableLicenseCheckPatch ()Lapp/revanced/patcher/patch/BytecodePatch;
 }
 
+public final class app/revanced/patches/shared/misc/privacy/DisableSentryTelemetryKt {
+	public static final fun getDisableSentryTelemetryPatch ()Lapp/revanced/patcher/patch/ResourcePatch;
+}
+
 public final class app/revanced/patches/shared/misc/settings/SettingsPatchKt {
 	public static final fun overrideThemeColors (Ljava/lang/String;Ljava/lang/String;)V
 	public static final fun settingsPatch (Ljava/util/List;Ljava/util/Set;)Lapp/revanced/patcher/patch/ResourcePatch;
@@ -1192,10 +1200,18 @@ public final class app/revanced/patches/stocard/layout/HideStoryBubblesPatchKt {
 	public static final fun getHideStoryBubblesPatch ()Lapp/revanced/patcher/patch/ResourcePatch;
 }
 
-public final class app/revanced/patches/strava/mediaupload/OverwriteMediaUploadParametersPatchKt {
+public final class app/revanced/patches/strava/media/download/AddMediaDownloadPatchKt {
+	public static final fun getAddMediaDownloadPatch ()Lapp/revanced/patcher/patch/BytecodePatch;
+}
+
+public final class app/revanced/patches/strava/media/upload/OverwriteMediaUploadParametersPatchKt {
 	public static final fun getOverwriteMediaUploadParametersPatch ()Lapp/revanced/patcher/patch/BytecodePatch;
 }
 
+public final class app/revanced/patches/strava/misc/extension/SharedExtensionPatchKt {
+	public static final fun getSharedExtensionPatch ()Lapp/revanced/patcher/patch/BytecodePatch;
+}
+
 public final class app/revanced/patches/strava/password/EnablePasswordLoginPatchKt {
 	public static final fun getEnablePasswordLoginPatch ()Lapp/revanced/patcher/patch/BytecodePatch;
 }
@@ -1688,6 +1704,10 @@ public final class app/revanced/patches/youtube/misc/announcements/Announcements
 	public static final fun getAnnouncementsPatch ()Lapp/revanced/patcher/patch/BytecodePatch;
 }
 
+public final class app/revanced/patches/youtube/misc/audiofocus/PauseOnAudioInterruptPatchKt {
+	public static final fun getPauseOnAudioInterruptPatch ()Lapp/revanced/patcher/patch/BytecodePatch;
+}
+
 public final class app/revanced/patches/youtube/misc/autorepeat/AutoRepeatPatchKt {
 	public static final fun getAutoRepeatPatch ()Lapp/revanced/patcher/patch/BytecodePatch;
 }

patches/build.gradle.kts

@@ -50,12 +50,9 @@ kotlin {
 publishing {
     repositories {
         maven {
-            name = "GitHubPackages"
+            name = "githubPackages"
             url = uri("https://maven.pkg.github.com/revanced/revanced-patches")
-            credentials {
+            credentials(PasswordCredentials::class)
-                username = System.getenv("GITHUB_ACTOR")
-                password = System.getenv("GITHUB_TOKEN")
-            }
         }
     }
 }

patches/src/main/kotlin/app/revanced/patches/all/misc/playintegrity/DisablePlayIntegrity.kt

@@ -0,0 +1,55 @@
+package app.revanced.patches.all.misc.playintegrity
+
+import app.revanced.patcher.extensions.InstructionExtensions.replaceInstruction
+import app.revanced.patcher.patch.bytecodePatch
+import app.revanced.patches.all.misc.transformation.transformInstructionsPatch
+import app.revanced.util.getReference
+import com.android.tools.smali.dexlib2.Opcode
+import com.android.tools.smali.dexlib2.iface.instruction.formats.Instruction35c
+import com.android.tools.smali.dexlib2.iface.reference.MethodReference
+import com.android.tools.smali.dexlib2.immutable.reference.ImmutableMethodReference
+import com.android.tools.smali.dexlib2.util.MethodUtil
+
+private const val EXTENSION_CLASS_DESCRIPTOR = "Lapp/revanced/extension/playintegrity/DisablePlayIntegrityPatch;"
+
+private val CONTEXT_BIND_SERVICE_METHOD_REFERENCE = ImmutableMethodReference(
+    "Landroid/content/Context;",
+    "bindService",
+    listOf("Landroid/content/Intent;", "Landroid/content/ServiceConnection;", "I"),
+    "Z"
+)
+
+
+@Suppress("unused")
+val disablePlayIntegrityPatch = bytecodePatch(
+    name = "Disable Play Integrity",
+    description = "Prevents apps from using Play Integrity by pretending it is not available.",
+    use = false,
+) {
+    extendWith("extensions/all/misc/disable-play-integrity.rve")
+
+    dependsOn(
+        transformInstructionsPatch(
+            filterMap = filterMap@{ classDef, method, instruction, instructionIndex ->
+                val reference = instruction
+                    .getReference<MethodReference>()
+                    ?.takeIf {
+                        MethodUtil.methodSignaturesMatch(CONTEXT_BIND_SERVICE_METHOD_REFERENCE, it)
+                    }
+                    ?: return@filterMap null
+
+                Triple(instruction as Instruction35c, instructionIndex, reference.parameterTypes)
+            },
+            transform = { method, entry ->
+                val (instruction, index, parameterTypes) = entry
+                val parameterString = parameterTypes.joinToString(separator = "")
+                val registerString = "v${instruction.registerC}, v${instruction.registerD}, v${instruction.registerE}, v${instruction.registerF}"
+
+                method.replaceInstruction(
+                    index,
+                    "invoke-static { $registerString }, $EXTENSION_CLASS_DESCRIPTOR->bindService(Landroid/content/Context;$parameterString)Z"
+                )
+            }
+        )
+    )
+}

patches/src/main/kotlin/app/revanced/patches/instagram/misc/share/PermalinkResponseJsonParserFingerprint.kt

@@ -13,7 +13,7 @@ internal val storyUrlResponseJsonParserFingerprint = fingerprint {
 }
 
 internal val profileUrlResponseJsonParserFingerprint = fingerprint {
-    strings("profile_to_share_url", "ProfileUrlResponse")
+    strings("profile_to_share_url")
     custom { method, _ -> method.name == "parseFromJson" }
 }
 

patches/src/main/kotlin/app/revanced/patches/instagram/reels/DisableReelsScrollingPatch.kt

@@ -9,7 +9,7 @@ val disableReelsScrollingPatch = bytecodePatch(
     name = "Disable Reels scrolling",
     description = "Disables the endless scrolling behavior in Instagram Reels, preventing swiping to the next Reel. " +
             "Note: On a clean install, the 'Tip' animation may appear but will stop on its own after a few seconds.",
-    use = true
+    use = false
 ) {
     compatibleWith("com.instagram.android")
 
@@ -31,4 +31,4 @@ val disableReelsScrollingPatch = bytecodePatch(
         // Return false in onInterceptTouchEvent to disable pull-to-refresh.
         clipsSwipeRefreshLayoutOnInterceptTouchEventFingerprint.method.returnEarly(false)
     }
-}
+}

patches/src/main/kotlin/app/revanced/patches/shared/misc/privacy/DisableSentryTelemetry.kt

@@ -0,0 +1,36 @@
+package app.revanced.patches.shared.misc.privacy
+
+import app.revanced.patcher.patch.resourcePatch
+import app.revanced.util.asSequence
+import app.revanced.util.getNode
+import org.w3c.dom.Element
+
+@Suppress("unused")
+val disableSentryTelemetryPatch = resourcePatch(
+    name = "Disable Sentry telemetry",
+    description = "Disables Sentry telemetry. See https://sentry.io/for/android/ for more information.",
+    use = false,
+) {
+    execute {
+        fun Element.replaceOrCreate(tagName: String, attributeName: String, attributeValue: String) {
+            val childElements = getElementsByTagName(tagName).asSequence().filterIsInstance<Element>()
+            val targetChild = childElements.find { childElement ->
+                childElement.getAttribute("android:name") == attributeName
+            }
+            if (targetChild != null) {
+                targetChild.setAttribute("android:value", attributeValue)
+            } else {
+                appendChild(ownerDocument.createElement(tagName).apply {
+                    setAttribute("android:name", attributeName)
+                    setAttribute("android:value", attributeValue)
+                })
+            }
+        }
+
+        document("AndroidManifest.xml").use { document ->
+            val application = document.getNode("application") as Element
+            application.replaceOrCreate("meta-data", "io.sentry.enabled", "false")
+            application.replaceOrCreate("meta-data", "io.sentry.dsn", "")
+        }
+    }
+}

patches/src/main/kotlin/app/revanced/patches/strava/media/download/AddMediaDownloadPatch.kt

@@ -0,0 +1,116 @@
+package app.revanced.patches.strava.media.download
+
+import app.revanced.patcher.extensions.InstructionExtensions.addInstruction
+import app.revanced.patcher.extensions.InstructionExtensions.addInstructions
+import app.revanced.patcher.extensions.InstructionExtensions.addInstructionsWithLabels
+import app.revanced.patcher.extensions.InstructionExtensions.getInstruction
+import app.revanced.patcher.extensions.InstructionExtensions.instructions
+import app.revanced.patcher.patch.bytecodePatch
+import app.revanced.patcher.util.smali.ExternalLabel
+import app.revanced.patches.shared.misc.mapping.get
+import app.revanced.patches.shared.misc.mapping.resourceMappingPatch
+import app.revanced.patches.shared.misc.mapping.resourceMappings
+import app.revanced.patches.strava.misc.extension.sharedExtensionPatch
+import app.revanced.util.getReference
+import app.revanced.util.writeRegister
+import com.android.tools.smali.dexlib2.Opcode
+import com.android.tools.smali.dexlib2.builder.instruction.BuilderInstruction22c
+import com.android.tools.smali.dexlib2.iface.reference.FieldReference
+import com.android.tools.smali.dexlib2.iface.reference.TypeReference
+
+private const val ACTION_CLASS_DESCRIPTOR = "Lcom/strava/bottomsheet/Action;"
+private const val MEDIA_CLASS_DESCRIPTOR = "Lcom/strava/photos/data/Media;"
+private const val MEDIA_DOWNLOAD_CLASS_DESCRIPTOR = "Lapp/revanced/extension/strava/AddMediaDownloadPatch;"
+
+@Suppress("unused")
+val addMediaDownloadPatch = bytecodePatch(
+    name = "Add media download",
+    description = "Extends the full-screen media viewer menu with items to copy or open their URLs or download them directly."
+) {
+    compatibleWith("com.strava")
+
+    dependsOn(
+        resourceMappingPatch,
+        sharedExtensionPatch
+    )
+
+    execute {
+        val fragmentClass = classBy { it.endsWith("/FullscreenMediaFragment;") }!!.mutableClass
+
+        // region Extend menu of `FullscreenMediaFragment` with actions.
+
+        createAndShowFragmentFingerprint.match(fragmentClass).method.apply {
+            val setTrueIndex = instructions.indexOfFirst { instruction ->
+                instruction.opcode == Opcode.IPUT_BOOLEAN
+            }
+            val actionRegistrarRegister = getInstruction<BuilderInstruction22c>(setTrueIndex).registerB
+            val actionRegister = instructions.first { instruction ->
+                instruction.getReference<TypeReference>()?.type == ACTION_CLASS_DESCRIPTOR
+            }.writeRegister!!
+
+            fun addMenuItem(actionId: String, string: String, color: String, drawable: String) = addInstructions(
+                setTrueIndex + 1,
+                """
+                    new-instance v$actionRegister, $ACTION_CLASS_DESCRIPTOR
+                    sget v${actionRegister + 1}, $MEDIA_DOWNLOAD_CLASS_DESCRIPTOR->$actionId:I
+                    const v${actionRegister + 2}, 0x0
+                    const v${actionRegister + 3}, ${resourceMappings["string", string]}
+                    const v${actionRegister + 4}, ${resourceMappings["color", color]}
+                    const v${actionRegister + 5}, ${resourceMappings["drawable", drawable]}
+                    move/from16 v${actionRegister + 6}, v${actionRegister + 4}
+                    invoke-direct/range { v$actionRegister .. v${actionRegister + 7} }, $ACTION_CLASS_DESCRIPTOR-><init>(ILjava/lang/String;IIIILjava/io/Serializable;)V
+                    invoke-virtual { v$actionRegistrarRegister, v$actionRegister }, Lcom/strava/bottomsheet/a;->a(Lcom/strava/bottomsheet/BottomSheetItem;)V
+                """
+            )
+
+            addMenuItem("ACTION_COPY_LINK", "copy_link", "core_o3", "actions_link_normal_xsmall")
+            addMenuItem("ACTION_OPEN_LINK", "fallback_menu_item_open_in_browser", "core_o3", "actions_link_external_normal_xsmall")
+            addMenuItem("ACTION_DOWNLOAD", "download", "core_o3", "actions_download_normal_xsmall")
+
+            // Move media to last parameter of `Action` constructor.
+            val getMediaInstruction = instructions.first { instruction ->
+                instruction.getReference<FieldReference>()?.type == MEDIA_CLASS_DESCRIPTOR
+            }
+            addInstruction(
+                getMediaInstruction.location.index + 1,
+                "move-object/from16 v${actionRegister + 7}, v${getMediaInstruction.writeRegister}"
+            )
+        }
+
+        // endregion
+
+        // region Handle new actions.
+
+        val actionClass = classes.first { clazz ->
+            clazz.type == ACTION_CLASS_DESCRIPTOR
+        }
+        val actionSerializableField = actionClass.instanceFields.first { field ->
+            field.type == "Ljava/io/Serializable;"
+        }
+
+        // Handle "copy link" & "open link" & "download" actions.
+        handleMediaActionFingerprint.match(fragmentClass).method.apply {
+            // Call handler if action ID < 0 (= custom).
+            val moveInstruction = instructions.first { instruction ->
+                instruction.opcode == Opcode.MOVE_RESULT
+            }
+            val indexAfterMoveInstruction = moveInstruction.location.index + 1
+            val actionIdRegister = moveInstruction.writeRegister
+            addInstructionsWithLabels(
+                indexAfterMoveInstruction,
+                """
+                    if-gez v$actionIdRegister, :move
+                    check-cast p2, $ACTION_CLASS_DESCRIPTOR
+                    iget-object v0, p2, $actionSerializableField
+                    check-cast v0, $MEDIA_CLASS_DESCRIPTOR
+                    invoke-static { v$actionIdRegister, v0 }, $MEDIA_DOWNLOAD_CLASS_DESCRIPTOR->handleAction(I$MEDIA_CLASS_DESCRIPTOR)Z
+                    move-result v0
+                    return v0
+                """,
+                ExternalLabel("move", instructions[indexAfterMoveInstruction])
+            )
+        }
+
+        // endregion
+    }
+}

patches/src/main/kotlin/app/revanced/patches/strava/media/download/Fingerprints.kt

@@ -0,0 +1,15 @@
+package app.revanced.patches.strava.media.download
+
+import app.revanced.patcher.fingerprint
+import com.android.tools.smali.dexlib2.AccessFlags
+
+internal val createAndShowFragmentFingerprint = fingerprint {
+    accessFlags(AccessFlags.PUBLIC, AccessFlags.FINAL)
+    returns("V")
+    parameters("L")
+    strings("mediaType")
+}
+
+internal val handleMediaActionFingerprint = fingerprint {
+    parameters("Landroid/view/View;", "Lcom/strava/bottomsheet/BottomSheetItem;")
+}

patches/src/main/kotlin/app/revanced/patches/strava/media/upload/Fingerprints.kt

@@ -1,4 +1,4 @@
-package app.revanced.patches.strava.mediaupload
+package app.revanced.patches.strava.media.upload
 
 import app.revanced.patcher.fingerprint
 

patches/src/main/kotlin/app/revanced/patches/strava/media/upload/OverwriteMediaUploadParametersPatch.kt

@@ -1,4 +1,4 @@
-package app.revanced.patches.strava.mediaupload
+package app.revanced.patches.strava.media.upload
 
 import app.revanced.patcher.patch.bytecodePatch
 import app.revanced.patcher.patch.intOption

patches/src/main/kotlin/app/revanced/patches/strava/misc/extension/Hooks.kt

@@ -0,0 +1,9 @@
+package app.revanced.patches.strava.misc.extension
+
+import app.revanced.patches.shared.misc.extension.extensionHook
+
+internal val applicationOnCreateHook = extensionHook {
+    custom { method, classDef ->
+        method.name == "onCreate" && classDef.endsWith("/StravaApplication;")
+    }
+}

patches/src/main/kotlin/app/revanced/patches/strava/misc/extension/SharedExtensionPatch.kt

@@ -0,0 +1,5 @@
+package app.revanced.patches.strava.misc.extension
+
+import app.revanced.patches.shared.misc.extension.sharedExtensionPatch
+
+val sharedExtensionPatch = sharedExtensionPatch("strava", applicationOnCreateHook)

patches/src/main/kotlin/app/revanced/patches/youtube/misc/audiofocus/Fingerprints.kt

@@ -0,0 +1,14 @@
+package app.revanced.patches.youtube.misc.audiofocus
+
+import app.revanced.patcher.fingerprint
+
+internal val audioFocusChangeListenerFingerprint = fingerprint {
+    strings(
+        "AudioFocus DUCK",
+        "AudioFocus loss; Will lower volume",
+    )
+}
+
+internal val audioFocusRequestBuilderFingerprint = fingerprint {
+    strings("Can't build an AudioFocusRequestCompat instance without a listener")
+}

patches/src/main/kotlin/app/revanced/patches/youtube/misc/audiofocus/PauseOnAudioInterruptPatch.kt

@@ -0,0 +1,66 @@
+package app.revanced.patches.youtube.misc.audiofocus
+
+import app.revanced.patcher.extensions.InstructionExtensions.addInstructions
+import app.revanced.patcher.extensions.InstructionExtensions.addInstructionsWithLabels
+import app.revanced.patcher.extensions.InstructionExtensions.getInstruction
+import app.revanced.patcher.patch.bytecodePatch
+import app.revanced.patcher.util.smali.ExternalLabel
+import app.revanced.patches.all.misc.resources.addResources
+import app.revanced.patches.all.misc.resources.addResourcesPatch
+import app.revanced.patches.shared.misc.settings.preference.SwitchPreference
+import app.revanced.patches.youtube.misc.extension.sharedExtensionPatch
+import app.revanced.patches.youtube.misc.settings.PreferenceScreen
+import app.revanced.patches.youtube.misc.settings.settingsPatch
+
+private const val EXTENSION_CLASS_DESCRIPTOR = "Lapp/revanced/extension/youtube/patches/PauseOnAudioInterruptPatch;"
+
+val pauseOnAudioInterruptPatch = bytecodePatch(
+    name = "Pause on audio interrupt",
+    description = "Adds an option to pause playback instead of lowering volume when other audio plays.",
+) {
+    dependsOn(
+        sharedExtensionPatch,
+        settingsPatch,
+        addResourcesPatch,
+    )
+
+    compatibleWith(
+        "com.google.android.youtube"(
+            "20.14.43",
+        )
+    )
+
+    execute {
+        addResources("youtube", "misc.audiofocus.pauseOnAudioInterruptPatch")
+
+        PreferenceScreen.MISC.addPreferences(
+            SwitchPreference("revanced_pause_on_audio_interrupt"),
+        )
+
+        // Hook the builder method that creates AudioFocusRequest.
+        // At the start, set the willPauseWhenDucked field (b) to true if setting is enabled.
+        val builderMethod = audioFocusRequestBuilderFingerprint.method
+        val builderClass = builderMethod.definingClass
+
+        builderMethod.addInstructionsWithLabels(
+            0,
+            """
+                invoke-static {}, $EXTENSION_CLASS_DESCRIPTOR->shouldPauseOnAudioInterrupt()Z
+                move-result v0
+                if-eqz v0, :skip_override
+                const/4 v0, 0x1
+                iput-boolean v0, p0, $builderClass->b:Z
+            """,
+            ExternalLabel("skip_override", builderMethod.getInstruction(0)),
+        )
+
+        // Also hook the audio focus change listener as a backup.
+        audioFocusChangeListenerFingerprint.method.addInstructions(
+            0,
+            """
+                invoke-static { p1 }, $EXTENSION_CLASS_DESCRIPTOR->overrideAudioFocusChange(I)I
+                move-result p1
+            """
+        )
+    }
+}

patches/src/main/resources/addresources/values/strings.xml

@@ -1558,6 +1558,11 @@ Tap here to learn more about DeArrow"</string>
             <string name="revanced_loop_video_button_toast_on">Loop video is on</string>
             <string name="revanced_loop_video_button_toast_off">Loop video is off</string>
         </patch>
+        <patch id="misc.audiofocus.pauseOnAudioInterruptPatch">
+            <string name="revanced_pause_on_audio_interrupt_title">Pause on audio interrupt</string>
+            <string name="revanced_pause_on_audio_interrupt_summary_on">Playback pauses when other audio plays (e.g. navigation)</string>
+            <string name="revanced_pause_on_audio_interrupt_summary_off">Volume lowers when other audio plays</string>
+        </patch>
         <patch id="misc.dimensions.spoof.spoofDeviceDimensionsPatch">
             <string name="revanced_spoof_device_dimensions_title">Spoof device dimensions</string>
             <string name="revanced_spoof_device_dimensions_summary_on">"Device dimensions spoofed

settings.gradle.kts

@@ -5,12 +5,9 @@ pluginManagement {
         gradlePluginPortal()
         google()
         maven {
-            name = "GitHubPackages"
+            name = "githubPackages"
             url = uri("https://maven.pkg.github.com/revanced/registry")
-            credentials {
+            credentials(PasswordCredentials::class)
-                username = providers.gradleProperty("gpr.user").getOrElse(System.getenv("GITHUB_ACTOR"))
-                password = providers.gradleProperty("gpr.key").getOrElse(System.getenv("GITHUB_TOKEN"))
-            }
         }
     }
 }