Gestire i file manifest

In questa pagina viene descritto come funziona l'unione dei manifest e come applicare l'unione preferenze per risolvere i conflitti di unione. Per una presentazione dell'app , consulta il Panoramica del file manifest dell'app.

Unire più file manifest

Il file APK o Android App Bundle può contenere solo uno AndroidManifest.xml, ma il tuo progetto Android Studio potrebbe contenere diversi file manifest forniti dal set di origine principale, dalle varianti della build e librerie. Quando crei la tua app, la build di Gradle viene unita tutti i file manifest in un unico file manifest pacchettizzato nella tua app.

Lo strumento di unione dei file manifest combina tutti gli elementi XML di ogni file seguendo euristica di unione e il rispetto delle preferenze di unione che hai definito con attributi XML speciali.

Suggerimento: utilizza il file manifest unito , descritta nella sezione seguente, per visualizzare l'anteprima dei risultati del file manifest unito e individuare eventuali conflitti errori.

Unisci priorità

Lo strumento di unione combina tutti i file manifest in un unico file in sequenza, in base alla priorità di ciascun file manifest. Ad esempio, se disponi tre file manifest, quello con priorità più bassa viene unito manifest con la priorità più alta successiva, che viene poi unito a quello con la priorità più alta come illustrato nella Figura 1.

Figura 1. La procedura per unire tre file manifest da quella più bassa a quella più alta.

Esistono tre tipi base di file manifest che possono essere uniti in ciascuno le altre priorità e le relative priorità di unione sono le seguenti (la priorità più alta per prima):

  1. File manifest per il tuo variante build

    Se disponi di più set di origini per la variante, i relativi le priorità del file manifest sono le seguenti:

    • Crea manifest della variante (ad esempio src/demoDebug/)
    • Manifest del tipo di build (ad esempio src/debug/)
    • File manifest flavor del prodotto (ad esempio src/demo/)

      Se utilizzi dimensioni flavor, le priorità del file manifest corrispondono all'ordine di ciascuna dimensione elencata flavorDimensions (la prima è la priorità più alta).

  2. File manifest principale per il modulo dell'app
  3. File manifest da una raccolta inclusa

    Se hai più librerie, le relative priorità manifest corrispondono l'ordine in cui appaiono in Gradle Blocco dependencies.

Ad esempio, nel file manifest principale viene unito il manifest di una libreria, quindi il file manifest principale viene unito al manifest della variante della build. Ricorda che sono gli stessi priorità di unione per tutti gli insiemi di origini, come descritto in Crea con i set di origini.

Importante:le configurazioni della build Il file build.gradle sostituisce qualsiasi attributo corrispondente in file manifest unito. Ad esempio, minSdk da build.gradle o Il file build.gradle.kts sostituisce l'attributo corrispondente in <uses-sdk> . Per evitare confusione, ometti <uses-sdk> e definisci queste proprietà solo nell'elemento build.gradle file. Per ulteriori dettagli, vedi Configura la tua build.

Unisci le euristiche di conflitto

Lo strumento di unione può abbinare logicamente ogni elemento XML di un file manifest a un dell'elemento corrispondente in un altro manifest. Per maggiori dettagli su come vedi le priorità di unione nella sezione precedente.

Se un elemento del manifest con priorità più bassa non corrisponde ad alcun elemento in il manifest con priorità più alta, questo viene aggiunto al manifest unito. Tuttavia, se c'è un elemento corrispondente, lo strumento di unione tenta di combinare tutti gli attributi di ciascuno nello stesso elemento. Se lo strumento rileva che contengono lo stesso attributo con valori diversi, viene generato un evento si verifica un conflitto.

La tabella 1 illustra i possibili risultati quando lo strumento di fusione tenta di combinare tutti gli attributi nello stesso elemento.

Tabella 1. Comportamento predefinito di unione per l'attributo valori

Attributo ad alta priorità Attributo a bassa priorità Risultato unito dell'attributo
Per niente preziosa Per niente preziosa Nessun valore (utilizza il valore predefinito)
Valore B Valore B
Valore A Per niente preziosa Valore A
Valore A Valore A
Valore B Errore di conflitto: devi aggiungere un valore indicatore di regola di unione.

Tuttavia, in alcune situazioni lo strumento di unione si comporta in modo diverso per evitare conflitti di unione:

  • Gli attributi nell'elemento <manifest> non vengono mai uniti in sinergia; vengono utilizzati solo gli attributi del manifest con la massima priorità.
  • L'attributo android:required in <uses-feature> e Gli elementi <uses-library> utilizzano un'unione OR. In caso di conflitto, "true" viene applicata e la funzionalità o la libreria richiesta da un file manifest è sempre inclusa.
  • Attributi in L'elemento <uses-sdk> utilizza sempre il valore dell'attributo manifest a priorità più elevata, tranne che nei seguenti casi:
    • Quando il manifest con priorità più bassa ha un valore minSdk più alta, si verifica un errore a meno che applica lo overrideLibrary.
    • Quando il manifest con priorità più bassa ha un targetSdkVersion inferiore, lo strumento di unione utilizza il valore dal manifest con priorità più alta e aggiunge anche eventuali autorizzazioni di sistema necessari per garantire che la libreria importata continui a funzionare correttamente (nei casi in cui la versione di Android successiva abbia maggiori limitazioni relative alle autorizzazioni). Per ulteriori informazioni al riguardo, del comportamento, consulta la sezione sul sistema implicito autorizzazioni.
  • L'elemento <intent-filter> non ha mai corrispondenze tra e i file manifest. Ciascuno di essi viene considerato all'elemento principale comune nel file manifest unito.

Per tutti gli altri conflitti tra attributi, ricevi un errore e devi indica allo strumento di unione come risolverlo aggiungendo un attributo speciale in il file manifest a priorità più alta. Consulta la sezione seguente su indicatori delle regole di unione.

Non dipendono dai valori predefiniti degli attributi. Poiché tutti vengono combinati attributi univoci nello stesso elemento, questo potrebbe e inaspettati, se il manifest con priorità più alta dipende effettivamente dalla valore predefinito di un attributo senza dichiararlo. Ad esempio, se il valore il file manifest prioritario non dichiara il android:launchMode viene utilizzato il valore predefinito "standard", ma se l'attributo il manifest con priorità inferiore dichiara questo attributo con un valore diverso, viene applicato al file manifest unito, sostituendo il valore predefinito. Tu deve definire esplicitamente ogni attributo come preferisci. Valori predefiniti per ogni attributo sono documentati riferimento del file manifest.

Unisci indicatori di regole

Un indicatore delle regole di unione è un attributo XML che puoi utilizzare per esprimere le tue preferenze su come risolvere i conflitti di unione o rimuovere gli elementi e gli attributi indesiderati. Puoi applicare un indicatore a un intero elemento o solo a elementi specifici attributi in un elemento.

Quando unisci due file manifest, lo strumento di unione cerca questi indicatori nel un file manifest con priorità più alta.

Tutti gli indicatori appartengono allo spazio dei nomi Android tools, quindi devi prima dichiarare questo spazio dei nomi nell'elemento <manifest>, come mostrato qui:

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.myapp"
    xmlns:tools="http://schemas.android.com/tools">

Indicatori di nodo

Per applicare una regola di unione a un intero elemento XML (a tutti gli attributi in un determinato manifest e a tutti i relativi tag figlio), utilizza quanto segue attributi:

tools:node="merge"
Unisci tutti gli attributi in questo tag e tutti gli elementi nidificati, se presenti non ci sono conflitti usando l'unione euristica dei conflitti. Questo è il comportamento predefinito per gli elementi.

Manifest a bassa priorità:

<activity android:name="com.example.ActivityOne"
    android:windowSoftInputMode="stateUnchanged">
    <intent-filter>
        <action android:name="android.intent.action.SEND" />
        <category android:name="android.intent.category.DEFAULT" />
    </intent-filter>
</activity>

Manifest ad alta priorità:

<activity android:name="com.example.ActivityOne"
    android:screenOrientation="portrait"
    tools:node="merge">
</activity>

Risultato del file manifest unito:

<activity android:name="com.example.ActivityOne"
    android:screenOrientation="portrait"
    android:windowSoftInputMode="stateUnchanged">
    <intent-filter>
        <action android:name="android.intent.action.SEND" />
        <category android:name="android.intent.category.DEFAULT" />
    </intent-filter>
</activity>
tools:node="merge-only-attributes"
Unisci gli attributi solo in questo tag; non unire gli elementi nidificati.

Manifest a bassa priorità:

<activity android:name="com.example.ActivityOne"
    android:windowSoftInputMode="stateUnchanged">
    <intent-filter>
        <action android:name="android.intent.action.SEND" />
        <data android:type="image/*" />
        <category android:name="android.intent.category.DEFAULT" />
    </intent-filter>
</activity>

Manifest ad alta priorità:

<activity android:name="com.example.ActivityOne"
    android:screenOrientation="portrait"
    tools:node="merge-only-attributes">
</activity>

Risultato del file manifest unito:

<activity android:name="com.example.ActivityOne"
    android:screenOrientation="portrait"
    android:windowSoftInputMode="stateUnchanged">
</activity>
tools:node="remove"
Rimuovi questo elemento dal file manifest unito. Utilizzata quando scoprite un elemento nel file manifest unito che non vi serve è stato fornito da un file manifest a priorità inferiore che è fuori dal tuo controllo (ad esempio, una libreria importata).

Manifest a bassa priorità:

<activity-alias android:name="com.example.alias">
  <meta-data android:name="cow"
      android:value="@string/moo"/>
  <meta-data android:name="duck"
      android:value="@string/quack"/>
</activity-alias>

Manifest ad alta priorità:

<activity-alias android:name="com.example.alias">
  <meta-data android:name="cow"
      tools:node="remove"/>
</activity-alias>

Risultato del file manifest unito:

<activity-alias android:name="com.example.alias">
  <meta-data android:name="duck"
      android:value="@string/quack"/>
</activity-alias>
tools:node="removeAll"
Simile a tools:node="remove", ma rimuove tutti elementi corrispondenti a questo tipo di elemento (nello stesso elemento principale).

Manifest a bassa priorità:

<activity-alias android:name="com.example.alias">
  <meta-data android:name="cow"
      android:value="@string/moo"/>
  <meta-data android:name="duck"
      android:value="@string/quack"/>
</activity-alias>

Manifest ad alta priorità:

<activity-alias android:name="com.example.alias">
  <meta-data tools:node="removeAll"/>
</activity-alias>

Risultato del file manifest unito:

<activity-alias android:name="com.example.alias">
</activity-alias>
tools:node="replace"
Sostituisci completamente l'elemento con priorità più bassa. Vale a dire, se è un elemento corrispondente nel manifest di priorità inferiore, ignoralo e utilizza esattamente come appare nel file manifest.

Manifest a bassa priorità:

<activity-alias android:name="com.example.alias">
  <meta-data android:name="cow"
      android:value="@string/moo"/>
  <meta-data android:name="duck"
      android:value="@string/quack"/>
</activity-alias>

Manifest ad alta priorità:

<activity-alias android:name="com.example.alias"
    tools:node="replace">
  <meta-data android:name="fox"
      android:value="@string/dingeringeding"/>
</activity-alias>

Risultato del file manifest unito:

<activity-alias android:name="com.example.alias">
  <meta-data android:name="fox"
      android:value="@string/dingeringeding"/>
</activity-alias>
tools:node="strict"
Genera un errore di build ogni volta che per questo elemento a priorità inferiore il file manifest non corrisponde esattamente all'elemento nel file manifest con priorità più alta (a meno che risolti da altri indicatori delle regole di unione). Questa operazione sostituisce l'euristica del conflitto di unione. Per Ad esempio, se il manifest a priorità inferiore include un attributo aggiuntivo, la build non va a buon fine (mentre il comportamento predefinito aggiunge l'attributo nel file manifest unito).

Manifest a bassa priorità:

<activity android:name="com.example.ActivityOne"
    android:windowSoftInputMode="stateUnchanged">
    <intent-filter>
        <action android:name="android.intent.action.SEND" />
        <category android:name="android.intent.category.DEFAULT" />
    </intent-filter>
</activity>

Manifest ad alta priorità:

<activity android:name="com.example.ActivityOne"
    android:screenOrientation="portrait"
    tools:node="strict">
</activity>

Questo crea un errore di unione dei file manifest. I due elementi manifest non può differire per niente in modalità con restrizioni. Devi applicare altri indicatori delle regole di unione per risolvere queste differenze. (Senza tools:node="strict", questi due file possono essere uniti senza errori, come mostrato nell'esempio tools:node="merge".

Indicatori degli attributi

Per applicare una regola di unione solo ad attributi specifici in una utilizza il seguente tag attributi. Ogni attributo accetta uno o più nomi di attributi (incluso il , separate da virgole.

tools:remove="attr, ..."
Rimuovi gli attributi specificati dal file manifest unito. Utilizzato quando il file manifest a priorità inferiore include questi e vuoi assicurarti che non vengano inseriti nella del file manifest.

Manifest a bassa priorità:

<activity android:name="com.example.ActivityOne"
    android:windowSoftInputMode="stateUnchanged">

Manifest ad alta priorità:

<activity android:name="com.example.ActivityOne"
    android:screenOrientation="portrait"
    tools:remove="android:windowSoftInputMode">

Risultato del file manifest unito:

<activity android:name="com.example.ActivityOne"
    android:screenOrientation="portrait">
tools:replace="attr, ..."
Sostituisci gli attributi specificati nel manifest con priorità più bassa quelli del manifest. In altre parole, mantieni sempre valori del file manifest con priorità più alta.

Manifest a bassa priorità:

<activity android:name="com.example.ActivityOne"
    android:theme="@oldtheme"
    android:exported="false"
    android:windowSoftInputMode="stateUnchanged">

Manifest ad alta priorità:

<activity android:name="com.example.ActivityOne"
    android:theme="@newtheme"
    android:exported="true"
    android:screenOrientation="portrait"
    tools:replace="android:theme,android:exported">

Risultato del file manifest unito:

<activity android:name="com.example.ActivityOne"
    android:theme="@newtheme"
    android:exported="true"
    android:screenOrientation="portrait"
    android:windowSoftInputMode="stateUnchanged">
tools:strict="attr, ..."
Genera un errore di compilazione ogni volta che questi attributi nella Il manifest con priorità più bassa non corrisponde esattamente agli attributi nel file manifest con priorità più alta del file manifest. Questo è il comportamento predefinito per tutti gli attributi, ad eccezione di quelli con comportamenti speciali, come descritto nell'euristica dei conflitti di unione.

Manifest a bassa priorità:

<activity android:name="com.example.ActivityOne"
    android:screenOrientation="landscape">
</activity>

Manifest ad alta priorità:

<activity android:name="com.example.ActivityOne"
    android:screenOrientation="portrait"
    tools:strict="android:screenOrientation">
</activity>

Questo crea un errore di unione dei file manifest. Devi applicare un'altra regola di unione per risolvere il conflitto. Questo è il comportamento predefinito, lo stesso risultato si verifica aggiungendo esplicitamente tools:strict="screenOrientation".

Puoi anche applicare più indicatori a un elemento, come illustrato nell'esempio seguente:

Manifest a bassa priorità:

<activity android:name="com.example.ActivityOne"
    android:theme="@oldtheme"
    android:exported="false"
    android:allowTaskReparenting="true"
    android:windowSoftInputMode="stateUnchanged">

Manifest ad alta priorità:

<activity android:name="com.example.ActivityOne"
    android:theme="@newtheme"
    android:exported="true"
    android:screenOrientation="portrait"
    tools:replace="android:theme,android:exported"
    tools:remove="android:windowSoftInputMode">

Risultato del file manifest unito:

<activity android:name="com.example.ActivityOne"
    android:theme="@newtheme"
    android:exported="true"
    android:allowTaskReparenting="true"
    android:screenOrientation="portrait">

Selettore indicatore

Se vuoi applicare gli indicatori delle regole di unione solo a una risorsa specifica libreria importata, aggiungi l'attributo tools:selector con il nome del pacchetto di libreria.

Ad esempio, con il seguente manifest, remove la regola di unione viene applicata solo quando il file manifest con priorità inferiore proviene da Libreria com.example.lib1:

<permission android:name="permissionOne"
    tools:node="remove"
    tools:selector="com.example.lib1">

Se il manifest con priorità inferiore proviene da qualsiasi altra origine, remove regola di unione viene ignorata.

Nota:se lo utilizzi con uno degli indicatori degli attributi, allora viene applicato a tutti gli attributi specificati nell'indicatore.

Esegui l'override di <uses-sdk> per le librerie importate

Per impostazione predefinita, quando importi una libreria con un valore minSdk superiore al file manifest principale, si verifica un errore e impossibile importare la libreria.

Per fare in modo che lo strumento di unione ignori questo conflitto e importa la raccolta mantenendo minSdk di livello inferiore dell'app aggiungi l'attributo overrideLibrary al tag <uses-sdk>. Il valore dell'attributo può corrispondere a uno o più nomi di pacchetti di libreria (separate da virgole), che indicano le librerie che possono sostituire il campo minSdk del file manifest.

Ad esempio, se il file manifest principale dell'app applica overrideLibrary nel seguente modo:

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
          package="com.example.app"
          xmlns:tools="http://schemas.android.com/tools">
  <uses-sdk tools:overrideLibrary="com.example.lib1, com.example.lib2"/>
...

Quindi è possibile unire i seguenti file manifest senza errori relativi a il tag <uses-sdk> e il file manifest unito mantiene minSdk="2" dal file manifest dell'app.

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
          package="com.example.lib1">
   <uses-sdk android:minSdk="4" />
...

Autorizzazioni di sistema implicite

Alcune API Android che una volta erano accessibili senza costi dalle app sono diventate limitati dalle autorizzazioni di sistema versioni recenti di Android.

Per evitare di danneggiare le app che prevedono l'accesso a questi API, le versioni recenti di Android consentono alle app di continuare ad accedere a queste API senza l'autorizzazione se targetSdkVersion è impostato su un valore inferiore rispetto alla versione in cui è stata aggiunta la limitazione. Questo comportamento concede all'app un'autorizzazione implicita per consentire l'accesso alle API. L'elemento unito che hanno valori diversi per targetSdkVersion potrebbe essere interessato.

Se il file manifest con priorità più bassa ha un valore più basso per targetSdkVersion che le fornisce un'autorizzazione implicita, e il manifest con priorità più alta non ha lo stesso (poiché il suo targetSdkVersion è uguale o superiore a rispetto alla versione in cui è stata aggiunta la limitazione), lo strumento di unione aggiunge esplicitamente l'autorizzazione di sistema al file manifest unito.

Ad esempio, se la tua app imposta targetSdkVersion su 4 o versioni successive e importa una libreria con targetSdkVersion impostato su 3 o su un valore inferiore, lo strumento di unione aggiunge il parametro WRITE_EXTERNAL_STORAGE per il file manifest unito.

La tabella 2 elenca tutte le autorizzazioni possibili che potresti aggiungere al file manifest unito:

Tabella 2. Elenco delle autorizzazioni dello strumento di fusione potrebbe aggiungere al file manifest unito

Dichiarazioni del manifest con priorità più bassa Autorizzazioni aggiunte al manifest unito
targetSdkVersion è 3 o inferiore WRITE_EXTERNAL_STORAGE, READ_PHONE_STATE
targetSdkVersion ha almeno 15 anni e utilizza READ_CONTACTS READ_CALL_LOG
targetSdkVersion ha almeno 15 anni e utilizza WRITE_CONTACTS WRITE_CALL_LOG

Controllare il manifest unito e individuare eventuali conflitti

Anche prima di creare la tua app, puoi vedere un'anteprima degli elementi che hai unito del file manifest. Per visualizzare un'anteprima:

  1. In Android Studio, apri il file AndroidManifest.xml.
  2. Fai clic sulla scheda File manifest unito nella parte inferiore dell'editor.

La visualizzazione Manifest unito mostra i risultati del file manifest unito a sinistra e le informazioni su ciascun file manifest unito a destra, come mostrato in figura 2.

Elementi che sono stati uniti da file manifest con priorità inferiore sono evidenziati in diversi colori a sinistra. La chiave per ogni colore è specificato in Origini manifest.

Figura 2. Visualizzazione del file manifest unito.

I file manifest che facevano parte della build, ma non hanno contribuito a elementi o sono elencati in Altri file manifest.

Per visualizzare informazioni sulla provenienza di un elemento, fai clic sull'elemento nella parte sinistra ; inoltre, i dettagli verranno visualizzati in Unione di log.

Gli eventuali conflitti presenti vengono visualizzati in Errori di unione con un consiglio su come risolvere il conflitto utilizzando indicatori delle regole di unione.

Gli errori vengono stampati anche nella finestra Log eventi. Per visualizzarle, seleziona Visualizza > Finestre degli strumenti > Log eventi.

Per vedere un log completo dell'albero decisionale unito, puoi trovare il file di log nella directory build/outputs/logs/ del modulo, denominata manifest-merger-buildVariant-report.txt.

Unisci criteri

Lo strumento di unione dei file manifest può abbinare logicamente ogni elemento XML di un file manifest file a un elemento corrispondente in un altro file. La fusione corrisponde a ogni elemento utilizzando una chiave di corrispondenza, costituita da un valore di attributo univoco (ad es. android:name) oppure l'univocità naturale del tag stesso (ad esempio, può essere presente un solo <supports-screen>).

Se due manifest hanno lo stesso elemento XML, Lo strumento unisce i due elementi utilizzando uno dei tre criteri di unione:

Unisci
Combina tutti gli attributi non in conflitto nello stesso tag e unisci elementi secondari in base al rispettivo criterio di unione. Eventuali attributi sono in conflitto tra loro, uniscili con gli indicatori delle regole di unione.
Unisci solo bambini
Non combinare o unire gli attributi (tieni solo quelli forniti dal file manifest con la massima priorità) e unisci agli elementi secondari in base al criterio di unione.
Keep
Lascia l'elemento così com'è e aggiungilo all'elemento principale comune nella sezione file unito. Viene usato solo quando è accettabile che ci siano diversi dichiarazioni dello stesso elemento.

La tabella 3 elenca ogni tipo di elemento, il tipo di criterio di unione utilizzato e chiave utilizzata per determinare la corrispondenza di un elemento tra due manifest:

Tabella 3. I criteri di unione degli elementi manifest chiavi di corrispondenza

Elemento Unisci criterio Chiave di corrispondenza
<action> Unisci Attributo android:name
<activity> Unisci Attributo android:name
<application> Unisci Ce n'è solo uno per <manifest>.
<category> Unisci Attributo android:name
<data> Unisci Ce n'è solo uno per <intent-filter>.
<grant-uri-permission> Unisci Ce n'è solo uno per <provider>.
<instrumentation> Unisci Attributo android:name
<intent-filter> Keep Nessuna corrispondenza; sono consentite diverse dichiarazioni all'interno dell'elemento principale.
<manifest> Unisci solo bambini Esiste un solo file per file.
<meta-data> Unisci Attributo android:name
<path-permission> Unisci Ce n'è solo uno per <provider>.
<permission-group> Unisci Attributo android:name
<permission> Unisci Attributo android:name
<permission-tree> Unisci Attributo android:name
<provider> Unisci Attributo android:name
<receiver> Unisci Attributo android:name
<screen> Unisci Attributo android:screenSize
<service> Unisci Attributo android:name
<supports-gl-texture> Unisci Attributo android:name
<supports-screen> Unisci Ce n'è solo uno per <manifest>.
<uses-configuration> Unisci Ce n'è solo uno per <manifest>.
<uses-feature> Unisci Attributo android:name (se non presente, il valore android:glEsVersion)
<uses-library> Unisci Attributo android:name
<uses-permission> Unisci Attributo android:name
<uses-sdk> Unisci Ce n'è solo uno per <manifest>.
Elementi personalizzati Unisci Nessuna corrispondenza; che non sono note allo strumento di fusione e sono sempre incluse nel manifest unito.

Inserisci variabili di build nel manifest

Se devi inserire nel file AndroidManifest.xml variabili che siano definita nel file build.gradle, puoi farlo con proprietà manifestPlaceholders. Questa proprietà prende una mappa di coppie chiave/valore, come mostrato qui:

Alla moda

android {
    defaultConfig {
        manifestPlaceholders = [hostName:"www.example.com"]
    }
    ...
}

Kotlin

android {
    defaultConfig {
        manifestPlaceholders["hostName"] = "www.example.com"
    }
    ...
}

Puoi quindi inserire uno dei segnaposto nel file manifest come valore attributo:

<intent-filter ... >
    <data android:scheme="https" android:host="${hostName}" ... />
    ...
</intent-filter>

Per impostazione predefinita, gli strumenti di creazione forniscono anche ID applicazione nel segnaposto ${applicationId}. Il valore corrisponde sempre al valore finale l'ID applicazione per la build corrente, e le modifiche per varianti di build. Questo è utile quando vuoi utilizzare uno spazio dei nomi univoco per gli identificatori ad esempio un'azione intent, anche tra le varianti della build.

Ad esempio, se il tuo file build.gradle ha il seguente aspetto:

Alla moda

android {
    defaultConfig {
        applicationId "com.example.myapp"
    }
    flavorDimensions "type"
    productFlavors {
        free {
            applicationIdSuffix ".free"
            dimension "type"
        }
        pro {
            applicationIdSuffix ".pro"
            dimension "type"
        }
    }
}

Kotlin

android {
    defaultConfig {
        applicationId = "com.example.myapp"
    }
    flavorDimensions += "type"
    productFlavors {
        create("free") {
            applicationIdSuffix = ".free"
            dimension = "type"
        }
        create("pro") {
            applicationIdSuffix = ".pro"
            dimension = "type"
        }
    }
}

Quindi puoi inserire l'ID applicazione nel file manifest in questo modo:

<intent-filter ... >
    <action android:name="${applicationId}.TRANSMOGRIFY" />
    ...
</intent-filter>

E il risultato manifest quando crei il modello sapore del prodotto è questo:

<intent-filter ... >
   <action android:name="com.example.myapp.free.TRANSMOGRIFY" />
    ...
</intent-filter>

Per ulteriori informazioni, consulta Imposta l'ID applicazione.