Cambiamenti del comportamento: app destinate ad Android 14 o versioni successive

Come le versioni precedenti, Android 14 include modifiche al comportamento che potrebbero influire sulla tua app. Le seguenti modifiche al comportamento si applicano esclusivamente alle app che hanno come target Android 14 (livello API 34) o versioni successive. Se la tua app ha come target Android 14 o versioni successive, devi modificarla per supportare correttamente questi comportamenti, ove applicabile.

Assicurati di esaminare anche l'elenco delle modifiche al comportamento che interessano tutte le app in esecuzione su Android 14, indipendentemente dal targetSdkVersion dell'app.

Funzionalità di base

I tipi di servizi in primo piano sono obbligatori

Se la tua app ha come target Android 14 (livello API 34) o versioni successive, deve specificare almeno un tipo di servizio in primo piano per ogni servizio in primo piano al suo interno. Devi scegliere un tipo di servizio in primo piano che rappresenti il caso d'uso della tua app. Il sistema si aspetta che i servizi in primo piano di un determinato tipo satisfaggino un determinato caso d'uso.

Se un caso d'uso nella tua app non è associato a nessuno di questi tipi, ti consigliamo vivamente di eseguire la migrazione della logica per utilizzare WorkManager o processi di trasferimento di dati avviati dall'utente.

Applicazione dell'autorizzazione BLUETOOTH_CONNECT in BluetoothAdapter

Android 14 enforces the BLUETOOTH_CONNECT permission when calling the BluetoothAdapter getProfileConnectionState() method for apps targeting Android 14 (API level 34) or higher.

This method already required the BLUETOOTH_CONNECT permission, but it was not enforced. Make sure your app declares BLUETOOTH_CONNECT in your app's AndroidManifest.xml file as shown in the following snippet and check that a user has granted the permission before calling getProfileConnectionState.

<uses-permission android:name="android.permission.BLUETOOTH_CONNECT" />

Aggiornamenti di OpenJDK 17

Android 14 continua l'opera di aggiornamento delle librerie di base di Android per allinearsi alle funzionalità delle ultime release OpenJDK LTS, inclusi gli aggiornamenti delle librerie e il supporto del linguaggio Java 17 per gli sviluppatori di app e piattaforme.

Alcune di queste modifiche possono influire sulla compatibilità delle app:

  • Modifiche alle espressioni regolari: i riferimenti ai gruppi non validi ora non sono consentiti per seguire più da vicino la semantica di OpenJDK. Potresti vedere nuovi casi in cui viene generato un IllegalArgumentException dalla classe java.util.regex.Matcher, quindi assicurati di testare la tua app per verificare la presenza di aree che utilizzano espressioni regolari. Per attivare o disattivare questa modifica durante il test, attiva/disattiva il flag DISALLOW_INVALID_GROUP_REFERENCE utilizzando gli strumenti del framework di compatibilità.
  • Gestione degli UUID: il metodo java.util.UUID.fromString() ora esegue controlli più rigorosi durante la convalida dell'argomento di input, pertanto potresti visualizzare un IllegalArgumentException durante la deserializzazione. Per attivare o disattivare questa variazione durante il test, attiva/disattiva il flag ENABLE_STRICT_VALIDATION utilizzando gli strumenti del framework di compatibilità.
  • Problemi di ProGuard: in alcuni casi, l'aggiunta della classe java.lang.ClassValue causa un problema se provi a ridurre, offuscare e ottimizzare l'app utilizzando ProGuard. Il problema ha origine da una libreria Kotlin che modifica il comportamento di runtime in base al fatto che Class.forName("java.lang.ClassValue") restituisca o meno una classe. Se la tua app è stata sviluppata in base a una versione precedente del runtime senza la classe java.lang.ClassValue disponibile, queste ottimizzazioni potrebbero rimuovere il metodo computeValue dalle classi derivate da java.lang.ClassValue.

JobScheduler rafforza il comportamento di callback e di rete

Since its introduction, JobScheduler expects your app to return from onStartJob or onStopJob within a few seconds. Prior to Android 14, if a job runs too long, the job is stopped and fails silently. If your app targets Android 14 (API level 34) or higher and exceeds the granted time on the main thread, the app triggers an ANR with the error message "No response to onStartJob" or "No response to onStopJob".

This ANR may be a result of 2 scenarios: 1. There is work blocking the main thread, preventing the callbacks onStartJob or onStopJob from executing and completing within the expected time limit. 2. The developer is running blocking work within the JobScheduler callback onStartJob or onStopJob, preventing the callback from completing within the expected time limit.

To address #1, you will need to further debug what is blocking the main thread when the ANR occurs, you can do this using ApplicationExitInfo#getTraceInputStream() to get the tombstone trace when the ANR occurs. If you're able to manually reproduce the ANR, you can record a system trace and inspect the trace using either Android Studio or Perfetto to better understand what is running on the main thread when the ANR occurs. Note that this can happen when using JobScheduler API directly or using the androidx library WorkManager.

To address #2, consider migrating to WorkManager, which provides support for wrapping any processing in onStartJob or onStopJob in an asynchronous thread.

JobScheduler also introduces a requirement to declare the ACCESS_NETWORK_STATE permission if using setRequiredNetworkType or setRequiredNetwork constraint. If your app does not declare the ACCESS_NETWORK_STATE permission when scheduling the job and is targeting Android 14 or higher, it will result in a SecurityException.

API di lancio delle tessere

For apps targeting 14 and higher, TileService#startActivityAndCollapse(Intent) is deprecated and now throws an exception when called. If your app launches activities from tiles, use TileService#startActivityAndCollapse(PendingIntent) instead.

Privacy

Accesso parziale a foto e video

Android 14 introduces Selected Photos Access, which allows users to grant apps access to specific images and videos in their library, rather than granting access to all media of a given type.

This change is only enabled if your app targets Android 14 (API level 34) or higher. If you don't use the photo picker yet, we recommend implementing it in your app to provide a consistent experience for selecting images and videos that also enhances user privacy without having to request any storage permissions.

If you maintain your own gallery picker using storage permissions and need to maintain full control over your implementation, adapt your implementation to use the new READ_MEDIA_VISUAL_USER_SELECTED permission. If your app doesn't use the new permission, the system runs your app in a compatibility mode.

Esperienza utente

Notifiche dell'intent a schermo intero sicure

With Android 11 (API level 30), it was possible for any app to use Notification.Builder.setFullScreenIntent to send full-screen intents while the phone is locked. You could auto-grant this on app install by declaring USE_FULL_SCREEN_INTENT permission in the AndroidManifest.

Full-screen intent notifications are designed for extremely high-priority notifications demanding the user's immediate attention, such as an incoming phone call or alarm clock settings configured by the user. For apps targeting Android 14 (API level 34) or higher, apps that are allowed to use this permission are limited to those that provide calling and alarms only. The Google Play Store revokes default USE_FULL_SCREEN_INTENT permissions for any apps that don't fit this profile. The deadline for these policy changes is May 31, 2024.

This permission remains enabled for apps installed on the phone before the user updates to Android 14. Users can turn this permission on and off.

You can use the new API NotificationManager.canUseFullScreenIntent to check if your app has the permission; if not, your app can use the new intent ACTION_MANAGE_APP_USE_FULL_SCREEN_INTENT to launch the settings page where users can grant the permission.

Sicurezza

Limitazioni relative agli intent impliciti e in attesa

Per le app che hanno come target Android 14 (livello API 34) o versioni successive, Android impedisce alle app di inviare intent impliciti ai componenti interni dell'app nei seguenti modi:

  • Gli intent impliciti vengono recapitati solo ai componenti esportati. Le app devono utilizzare un intent esplicito per l'invio a componenti non esportati oppure contrassegnare il componente come esportato.
  • Se un'app crea un intent in attesa mutabile con un intent che non specifica un componente o un pacchetto, il sistema genera un'eccezione.

Queste modifiche impediscono alle app dannose di intercettare gli intent impliciti che sono destinati ai componenti interni di un'app.

Ad esempio, ecco un filtro di intent che potrebbe essere dichiarato nel file manifest della tua app:

<activity
    android:name=".AppActivity"
    android:exported="false">
    <intent-filter>
        <action android:name="com.example.action.APP_ACTION" />
        <category android:name="android.intent.category.DEFAULT" />
    </intent-filter>
</activity>

Se la tua app ha provato ad avviare questa attività utilizzando un'intent implicita, verrà lanciata un'eccezione ActivityNotFoundException:

Kotlin

// Throws an ActivityNotFoundException exception when targeting Android 14.
context.startActivity(Intent("com.example.action.APP_ACTION"))

Java

// Throws an ActivityNotFoundException exception when targeting Android 14.
context.startActivity(new Intent("com.example.action.APP_ACTION"));

Per avviare l'attività non esportata, l'app deve invece usare un intent esplicito:

Kotlin

// This makes the intent explicit.
val explicitIntent =
        Intent("com.example.action.APP_ACTION")
explicitIntent.apply {
    package = context.packageName
}
context.startActivity(explicitIntent)

Java

// This makes the intent explicit.
Intent explicitIntent =
        new Intent("com.example.action.APP_ACTION")
explicitIntent.setPackage(context.getPackageName());
context.startActivity(explicitIntent);

I broadcast receiver registrati in fase di runtime devono specificare il comportamento di esportazione

Apps and services that target Android 14 (API level 34) or higher and use context-registered receivers are required to specify a flag to indicate whether or not the receiver should be exported to all other apps on the device: either RECEIVER_EXPORTED or RECEIVER_NOT_EXPORTED, respectively. This requirement helps protect apps from security vulnerabilities by leveraging the features for these receivers introduced in Android 13.

Exception for receivers that receive only system broadcasts

If your app is registering a receiver only for system broadcasts through Context#registerReceiver methods, such as Context#registerReceiver(), then it shouldn't specify a flag when registering the receiver.

Caricamento più sicuro del codice dinamico

Se la tua app ha come target Android 14 (livello API 34) o versioni successive e utilizza il codice dinamico Con il caricamento (DCL), tutti i file caricati dinamicamente devono essere contrassegnati come di sola lettura. In caso contrario, il sistema genera un'eccezione. Consigliamo alle app di evitare caricamento dinamico del codice quando possibile, poiché ciò aumenta notevolmente il rischio che un'app possa compromessi da iniezione o manomissione del codice.

Se devi caricare il codice in modo dinamico, utilizza l'approccio seguente per impostare la caricato dinamicamente (ad esempio un file DEX, JAR o APK) in sola lettura, non appena all'apertura del file e prima che venga scritto qualsiasi contenuto:

Kotlin

val jar = File("DYNAMICALLY_LOADED_FILE.jar")
val os = FileOutputStream(jar)
os.use {
    // Set the file to read-only first to prevent race conditions
    jar.setReadOnly()
    // Then write the actual file content
}
val cl = PathClassLoader(jar, parentClassLoader)

Java

File jar = new File("DYNAMICALLY_LOADED_FILE.jar");
try (FileOutputStream os = new FileOutputStream(jar)) {
    // Set the file to read-only first to prevent race conditions
    jar.setReadOnly();
    // Then write the actual file content
} catch (IOException e) { ... }
PathClassLoader cl = new PathClassLoader(jar, parentClassLoader);

Gestire file caricati dinamicamente già esistenti

Per evitare che vengano generate eccezioni per i file esistenti caricati dinamicamente, ti consigliamo di eliminare e ricreare i file prima di provare e caricarli di nuovo nell'app. Quando ricrei i file, segui la procedura precedente le indicazioni per contrassegnare i file come di sola lettura in fase di scrittura. In alternativa, puoi rietichettano i file esistenti come di sola lettura, ma in questo caso consigliamo consigliamo di verificare prima l'integrità dei file (ad esempio, controllo della firma del file rispetto a un valore attendibile), per proteggere meglio la tua app da azioni dannose.

Limitazioni aggiuntive all'avvio di attività in background

For apps targeting Android 14 (API level 34) or higher, the system further restricts when apps are allowed to start activities from the background:

These changes expand the existing set of restrictions to protect users by preventing malicious apps from abusing APIs to start disruptive activities from the background.

Zip Path Traversal

For apps targeting Android 14 (API level 34) or higher, Android prevents the Zip Path Traversal Vulnerability in the following way: ZipFile(String) and ZipInputStream.getNextEntry() throws a ZipException if zip file entry names contain ".." or start with "/".

Apps can opt-out from this validation by calling dalvik.system.ZipPathValidator.clearCallback().

Per le app che hanno come target Android 14 (livello API 34) o versioni successive, un SecurityException viene generato da MediaProjection#createVirtualDisplay in uno dei seguenti scenari:

L'app deve chiedere all'utente di dare il consenso prima di ogni sessione di acquisizione. Una singola sessione di acquisizione è una singola chiamata su MediaProjection#createVirtualDisplay e ogni istanza di MediaProjection deve essere utilizzata una sola volta.

Gestire le modifiche alla configurazione

Se la tua app deve richiamare MediaProjection#createVirtualDisplay per gestire le modifiche alla configurazione (ad esempio l'orientamento o le dimensioni dello schermo), puoi seguire questi passaggi per aggiornare VirtualDisplay per l'istanza MediaProjection esistente:

  1. Richiama VirtualDisplay#resize con la nuova larghezza e altezza.
  2. Fornisci un nuovo Surface con le nuove larghezza e altezza a VirtualDisplay#setSurface.

Registra un callback

L'app deve registrare un callback per gestire i casi in cui l'utente non concede il consenso per continuare una sessione di acquisizione. Per farlo, implementa Callback#onStop e fai in modo che la tua app rilasci le risorse correlate (come VirtualDisplay e Surface).

Se la tua app non registra questo callback,MediaProjection#createVirtualDisplay genera un IllegalStateException quando la tua app lo invoca.

Limitazioni non SDK aggiornate

Android 14 includes updated lists of restricted non-SDK interfaces based on collaboration with Android developers and the latest internal testing. Whenever possible, we make sure that public alternatives are available before we restrict non-SDK interfaces.

If your app does not target Android 14, some of these changes might not immediately affect you. However, while you can currently use some non-SDK interfaces (depending on your app's target API level), using any non-SDK method or field always carries a high risk of breaking your app.

If you are unsure if your app uses non-SDK interfaces, you can test your app to find out. If your app relies on non-SDK interfaces, you should begin planning a migration to SDK alternatives. Nevertheless, we understand that some apps have valid use cases for using non-SDK interfaces. If you cannot find an alternative to using a non-SDK interface for a feature in your app, you should request a new public API.

To learn more about the changes in this release of Android, see Updates to non-SDK interface restrictions in Android 14. To learn more about non-SDK interfaces generally, see Restrictions on non-SDK interfaces.