Configura la generazione del profilo di riferimento

Il plug-in Gradle di Baseline Profile semplifica la generazione e la gestione Profili di riferimento. Ti aiuta a svolgere le seguenti attività:

• Crea nuovi profili di baseline per la tua app.
• Crea nuovi profili di riferimento per la tua raccolta.
• Personalizzare la generazione del profilo di riferimento.

Questa pagina spiega come utilizzare il plug-in Gradle del profilo di base per personalizzare la generazione dei profili di riferimento.

Requisiti dei plug-in

• AGP 8.0 o superiore
• Dipendenza dal l'ultima versione del plug-in Gradle

Utilizzare un dispositivo gestito Gradle per generare profili di riferimento

Per utilizzare un dispositivo gestito da Gradle (GMD) per: genera il tuo profilo di riferimento, aggiungine uno nella configurazione build.gradle.kts del modulo producer profilo, probabilmente il modulo di test :baselineprofile, come mostrato nell'esempio che segue:

android {
   testOptions.managedDevices.devices {
       create<com.android.build.api.dsl.ManagedVirtualDevice>("pixel6Api31") {
           device = "Pixel 6"
           apiLevel = 31
           systemImageSource = "aosp"
       }
   }
}

android {
   testOptions.managedDevices.devices {
       pixel6Api31(ManagedVirtualDevice) {
           device 'Pixel 6'
           apiLevel = 31
           systemImageSource 'aosp'
       }
   }
}

Utilizzare GMD per generare profili di riferimento aggiungendolo al profilo di base Configurazione del plug-in Gradle come segue, nel build.gradle.kts dell'oggetto Modulo di test :baselineprofile:

baselineProfile {
    managedDevices += "pixel6Api31"
}

baselineProfile {
    managedDevices = ['pixel6Api31']
}

Quando utilizzi un GMD per generare profili di riferimento, imposta useConnectedDevices su false, nel modulo di test :baselineprofile:

baselineProfile {
    ...
    useConnectedDevices = false
}

baselineProfile {
    ...
    useConnectedDevices false
}

Genera profili di baseline per varianti diverse

Puoi generare profili di riferimento per variante, per versione o come singolo file da utilizzare per tutte le varianti. Controlla questo comportamento tramite l'impostazione di unione, come mostrato nell'esempio seguente, nel build.gradle.kts del modulo dell'applicazione o della libreria.

baselineProfile {
    mergeIntoMain = true
}

baselineProfile {
    mergeIntoMain true
}

Per unire i profili generati per tutte le varianti in un unico profilo, imposta Da mergeIntoMain a true. Non è possibile generare una base di riferimento per variante Profili quando questa impostazione è true, quindi è presente una singola attività Gradle chiamata generateBaselineProfile. L'output del profilo viene eseguito in src/main/generated/baselineProfiles.

Per disattivare l'unione e avere un profilo per variante, imposta mergeIntoMain su false. In questo caso, esistono più attività Gradle specifiche delle varianti. Per ad esempio, quando sono disponibili due versioni, senza costi e a pagamento, e una tipo di build della release, le attività sono le seguenti:

* `generateFreeReleaseBaselineProfile`
* `generatePaidReleaseBaselineProfile`
* `generateReleaseBaselineProfile`

Per specificare il comportamento di unione per variante, utilizza il seguente codice:

baselineProfile {
    variants {
        freeRelease {
            mergeIntoMain = true
        }
    }
}

baselineProfile {
    variants {
        freeRelease {
            mergeIntoMain true
        }
    }
}

Nell'esempio precedente, le varianti in cui il flag è impostato su true vengono tutte unite in src/main/generated/baselineProfiles, mentre i profili delle varianti in cui il flag è impostato su false vengono conservati nella cartella src/<variant>/generated/baselineProfiles.

Per impostazione predefinita, mergeIntoMain è impostato su true per le librerie e su false per le app.

Genera automaticamente i profili di riferimento durante l'assemblaggio di una nuova release

Puoi configurare i profili di riferimento in modo che generino automaticamente con ogni release anziché utilizzare manualmente l'attività generateBaselineProfile. Con la generazione automatica, nella build della release è incluso il profilo più aggiornato.

Per abilitare la generazione automatica per le build della release, usa la automaticGenerationDuringBuild flag:

baselineProfile {
    automaticGenerationDuringBuild = true
}

baselineProfile {
    automaticGenerationDuringBuild true
}

L'impostazione del flag automaticGenerationDuringBuild su true attiva la generazione di un nuovo profilo di riferimento per ogni gruppo di release. Ciò significa che eseguire un'attività di compilazione di release di assemble, ad esempio ./gradlew:app:assembleRelease, attiva anche :app:generateReleaseBaselineProfile, avvia i test di strumentazione del profilo di riferimento e compila il profilo di riferimento su cui vengono eseguiti. Sebbene la generazione automatica aiuti gli utenti a ottenere i migliori vantaggi in termini di prestazioni, aumenta anche i tempi di compilazione grazie alla doppia build e alla strumentazione test.

Puoi anche specificare questo comportamento per variante, come mostrato nell'esempio seguente:

baselineProfile {
    variants {
        freeRelease {
            automaticGenerationDuringBuild = true
        }
    }
}

baselineProfile {
    variants {
        freeRelease {
            automaticGenerationDuringBuild true
        }
    }
}

Nell'esempio precedente, l'attività generateFreeReleaseBaselineProfile viene eseguita all'avvio di assembleFreeRelease. Questo aiuta quando l'utente vuole avere, ad ad esempio una build release per la distribuzione che genera sempre il profilo. durante la creazione e una build releaseWithoutProfile per i test interni.

Archivia i profili di riferimento in sorgenti

Puoi archiviare i profili di riferimento nella directory di origine tramite il saveInSrc flag nel build.gradle.kts del modulo dell'applicazione o della libreria:

• true: il profilo di riferimento è memorizzato in src/<variant>/generated/baselineProfiles. In questo modo puoi eseguire il commit del profilo generato più recente con le tue origini.
• false: il profilo di base viene archiviato nei file intermedi nella build . In questo modo, quando esegui il commit del codice, non salvi la versione generato automaticamente.

baselineProfile {
    saveInSrc = true
}

baselineProfile {
    saveInSrc true
}

Puoi anche specificare questo comportamento per variante:

baselineProfile {
    variants {
        freeRelease {
            saveInSrc = true
        }
    }
}

baselineProfile {
    variants {
        freeRelease {
            saveInSrc true
        }
    }
}

Filtra regole del profilo

Il plug-in Gradle del profilo di riferimento consente di filtrare le regole del profilo di riferimento generate. Ciò è particolarmente utile per le librerie, se vuoi escludere regole del profilo per classi e metodi che fanno parte di altre dipendenze del un'app di esempio o la raccolta stessa. I filtri possono includere ed escludere pacchetti e classi. Se specifichi solo le esclusioni, viene applicato solo il valore corrispondente alla base di riferimento Le regole del profilo sono escluse e tutto il resto è incluso.

Le specifiche dei filtri possono essere:

• Il nome del pacchetto termina con doppi caratteri jolly per corrispondere al pacchetto specificato e per tutti i sottopacchetti. Ad esempio, com.example.** corrisponde a com.example.method e com.example.method.bar.
• Nome del pacchetto che termina con un carattere jolly per corrispondere solo al pacchetto specificato. Ad esempio, com.example.* corrisponde a com.example.method, ma non a com.example.method.bar.
• Nomi di classi che corrispondono a una classe specifica, ad esempio com.example.MyClass.

I seguenti esempi mostrano come includere ed escludere pacchetti specifici:

baselineProfile {
    filter {
        include("com.somelibrary.widget.grid.**")
        exclude("com.somelibrary.widget.grid.debug.**")
        include("com.somelibrary.widget.list.**")
        exclude("com.somelibrary.widget.list.debug.**")
        include("com.somelibrary.widget.text.**")
        exclude("com.somelibrary.widget.text.debug.**")
    }
}

baselineProfile {
    filter {
        include 'com.somelibrary.widget.grid.**'
        exclude 'com.somelibrary.widget.grid.debug.**'
        include 'com.somelibrary.widget.list.**'
        exclude 'com.somelibrary.widget.list.debug.**'
        include 'com.somelibrary.widget.text.**'
        exclude 'com.somelibrary.widget.text.debug.**'
    }
}

Personalizza le regole del filtro per le diverse varianti in questo modo:

// Non-specific filters applied to all the variants.
baselineProfile {
    filter { include("com.myapp.**") }
}

// Flavor-specific filters.
baselineProfile {
    variants {
        free {
            filter {
                include("com.myapp.free.**")
            }
        }
        paid {
            filter {
                include("com.myapp.paid.**")
            }
        }
    }
}

// Build-type-specific filters.
baselineProfile {
    variants {
        release {
            filter {
                include("com.myapp.**")
            }
        }
    }
}

// Variant-specific filters.
baselineProfile {
    variants {
        freeRelease {
            filter {
                include("com.myapp.**")
            }
        }
    }
}

// Non-specific filters applied to all the variants.
baselineProfile {
    filter { include 'com.myapp.**' }
}

// Flavor-specific filters.
baselineProfile {
    variants {
        free {
            filter {
                include 'com.myapp.free.**'
            }
        }
        paid {
            filter {
                include 'com.myapp.paid.**'
            }
        }
    }
}

// Build-type specific filters.
baselineProfile {
    variants {
        release {
            filter {
                include 'com.myapp.**'
            }
        }
    }
}

// Variant-specific filters.
baselineProfile {
    variants {
        freeRelease {
            filter {
                include 'com.myapp.**'
            }
        }
    }
}

Puoi anche filtrare le regole utilizzando l'argomento filterPredicate in BaselineProfileRule.collect(), ma ti consigliamo di utilizzare l'API Gradle plug-in per filtrare perché consente di filtrare più facilmente i sottopacchetti e posto in un unico posto per configurare l'intero modulo.

Personalizzare i tipi di build Benchmark e Profilo di riferimento

Il plug-in Gradle del profilo di base crea tipi di build aggiuntivi da generare i profili ed eseguire benchmark. Questi tipi di build sono preceduti dal prefisso benchmark e nonMinified. Ad esempio, per il tipo di build release, la classe crea i tipi di build benchmarkRelease e nonMinifiedRelease. Questi tipi di build vengono configurati automaticamente per il caso d'uso specifico non richiedono solitamente alcuna personalizzazione. Ma ci sono alcuni casi in cui potrebbe comunque essere utile applicare alcune opzioni personalizzate, ad esempio per applicare configurazione di firma diversa.

Puoi personalizzare i tipi di build generati automaticamente utilizzando un sottoinsieme di le proprietà del tipo di build; le proprietà non utilizzabili vengono sostituite. L'esempio seguente mostra come personalizzare i tipi di build aggiuntivi e quali proprietà vengono sostituite:

android {
    buildTypes {
        release {
            ...
        }
        create("benchmarkRelease") {
            // Customize properties for the `benchmarkRelease` build type here.
            // For example, you can change the signing config (by default
            // it's the same as for the `release` build type).
            signingConfig = signingConfigs.getByName("benchmarkRelease")
        }
        create("nonMinifiedRelease") {
            // Customize properties for the `nonMinifiedRelease` build type here.
            signingConfig = signingConfigs.getByName("nonMinifiedRelease")

            // From Baseline Profile Gradle plugin 1.2.4 and higher, you can't
            // customize the following properties, which are always overridden to
            // avoid breaking Baseline Profile generation:
            //
            // isJniDebuggable = false
            // isDebuggable = false
            // isMinifyEnabled = false
            // isShrinkResources = false
            // isProfileable = true
            // enableAndroidTestCoverage = false
            // enableUnitTestCoverage = false
        }
    }
}

android {
    buildTypes {
        release {
            ...
        }
        benchmarkRelease {
            // Customize properties for the `benchmarkRelease` build type here.
            // For example, you can change the signing config (by default it's the
            // same as for the `release` build type.)
            signingConfig = signingConfigs.benchmarkRelease
        }
        nonMinifiedRelease {
            // Customize properties for the `nonMinifiedRelease` build type here.
            signingConfig = signingConfigs.nonMinifiedRelease

            // From Baseline Profile Gradle plugin 1.2.4 and higher, you can't use
            // the following properties, which are always overridden to avoid breaking
            // Baseline Profile generation:
            //
            // isJniDebuggable = false
            // isDebuggable = false
            // isMinifyEnabled = false
            // isShrinkResources = false
            // isProfileable = true
            // enableAndroidTestCoverage = false
            // enableUnitTestCoverage = false       
        }
    }
}

Note aggiuntive

Quando crei profili di riferimento, tieni presente quanto segue:

• I profili di riferimento compilati devono avere dimensioni inferiori a 1,5 MB. Non al formato di testo nei file sorgente, che in genere sono molto prima della compilazione. Verifica la dimensione della base di riferimento binaria Profilo individuandolo nell'artefatto di output in assets/dexopt/baseline.prof per l'APK o BUNDLE-METADATA/com.android.tools.build.profiles/baseline.prof per AAB.

• Regole generiche che compilano un numero eccessivo di applicazioni possono rallentare l'avvio grazie all'aumento dell'accesso al disco. Se stai appena iniziando a utilizzare i profili di riferimento, non preoccuparti. Tuttavia, a seconda dell'app e del dimensione e numero di percorsi, l'aggiunta di molti percorsi può un rendimento non ottimale. Testa le prestazioni della tua app provando diversi profili e verificare che il rendimento non regredisce dopo il aggiunte.

Codelab