NewVersionWorker.kt

Yes, here is a comparison of the two codes:

1. Main Differences

a) Import used for PendingIntentCompat

  • First code: import org.schabi.newpipe.util.PendingIntentCompat
  • Second code: import androidx.core.app.PendingIntentCompat

👉 The first code uses a custom implementation of PendingIntentCompat, specific to the NewPipe library.
👉 The second code uses PendingIntentCompat from AndroidX, which is the standard solution provided by Google.

b) getActivity signature

  • First code:

    val pendingIntent = PendingIntentCompat.getActivity(
    applicationContext, 0, intent, 0
)

    It has four parameters:

    • context
    • requestCode
    • intent
    • flags

  • Second code:

    val pendingIntent = PendingIntentCompat.getActivity(
    applicationContext, 0, intent, 0, false
)

    It has five parameters, with a final boolean parameter (false).

👉 The difference comes from the API used:

  • The NewPipe implementation only takes 4 parameters.
  • The AndroidX implementation adds an extra parameter (immutable: Boolean), which improves compatibility with Android 12+.

2. Implications and Compatibility

Why does AndroidX add an immutable parameter?

Since Android 12 (API 31), Google strongly recommends specifying whether a PendingIntent is immutable (immutable = true) or mutable (immutable = false) using the PendingIntent.FLAG_IMMUTABLE flag.
This enhances security and prevents certain exploit issues.

Which code is preferable?

  • If you use NewPipe, you must keep its custom version, but it may not be compatible with Android 12+.
  • If you use AndroidX, you get better support for recent Android versions.

👉 If possible, prioritize the AndroidX version, as it is officially maintained and ensures better future compatibility.

3. Recommended Solution

If you are migrating to AndroidX and your app targets Android 12+, explicitly use PendingIntent.FLAG_IMMUTABLE:

val pendingIntent = PendingIntentCompat.getActivity(
    applicationContext, 0, intent, PendingIntent.FLAG_IMMUTABLE, true
)

This ensures that the PendingIntent is secure and complies with the new Android 12+ rules.

Oui, voici une comparaison des deux codes :

1. Différences principales

a) Import utilisé pour PendingIntentCompat

  • Premier code : import org.schabi.newpipe.util.PendingIntentCompat
  • Deuxième code : import androidx.core.app.PendingIntentCompat

👉 Le premier code utilise une implémentation personnalisée de PendingIntentCompat, spécifique à la bibliothèque NewPipe.
👉 Le deuxième code utilise PendingIntentCompat de AndroidX, qui est la solution standard fournie par Google.

b) Signature de getActivity

  • Premier code :

    val pendingIntent = PendingIntentCompat.getActivity(
    applicationContext, 0, intent, 0
)

    Il y a quatre paramètres :

    • context
    • requestCode
    • intent
    • flags

  • Deuxième code :

    val pendingIntent = PendingIntentCompat.getActivity(
    applicationContext, 0, intent, 0, false
)

    Il y a cinq paramètres, avec un dernier paramètre booléen (false).

👉 La différence vient de l'API utilisée :

  • L'implĂ©mentation de NewPipe ne prend que 4 paramètres.
  • L'implĂ©mentation AndroidX ajoute un paramètre supplĂ©mentaire (immutable: Boolean), ce qui est une amĂ©lioration pour la compatibilitĂ© avec Android 12+.

2. Implications et compatibilité

Pourquoi AndroidX ajoute un paramètre immutable ?

Depuis Android 12 (API 31), Google recommande fortement de préciser si un PendingIntent est immuable (immutable = true) ou modifiable (immutable = false) via le flag PendingIntent.FLAG_IMMUTABLE.
Cela renforce la sécurité et évite certains problèmes d'exploitation.

Quel code est préférable ?

  • Si vous utilisez NewPipe, vous devez garder sa version personnalisĂ©e, mais elle pourrait ne pas ĂŞtre compatible avec Android 12+.
  • Si vous utilisez AndroidX, vous bĂ©nĂ©ficiez d'une meilleure prise en charge des versions rĂ©centes d'Android.

👉 Si possible, privilégiez la version AndroidX, car elle est maintenue officiellement et garantit une meilleure compatibilité future.

3. Solution recommandée

Si vous migrez vers AndroidX et que votre application est destinée à Android 12+, utilisez PendingIntent.FLAG_IMMUTABLE explicitement :

val pendingIntent = PendingIntentCompat.getActivity(
    applicationContext, 0, intent, PendingIntent.FLAG_IMMUTABLE, true
)

Cela garantit que le PendingIntent est sécurisé et conforme aux nouvelles règles d'Android 12+.