Ho letto per molto tempo le prestazioni del codice e l'ottimizzazione dei parametri. Tuttavia, i programmi Android sono uno dei miei obiettivi.
Iniziamo intro i concetti di base o più importanti in cui ci aiutano a raggiungere una soluzione.
Come ha affermato lo sviluppatore Android
il modulo può essere costruito, testato e sottoposto a debug in modo indipendente
Pertanto, i moduli hanno il loro grado e dipendenze e puoi esplorarlo nel progetto Hierarchy Viewer.
È un dato di fatto, l' accento sulla modularizzazione in materia di manutenzione . A differenza delle problematiche legate alle prestazioni, perché la modularizzazione ha questo importante impatto:
- Aumenta la profondità dell'eredità
Ecco un diagramma che l'ho disegnato per chiarirlo. Come puoi vedere mentre usi il modulo discreto, per invocare il Metodo A viene 2N micro secsconfrontato con il N micro secsmodulo senza discreto.
Questa domanda mi viene in mente che i metodi di riferimento contano ciò che riguarda la profondità dell'eredità?
La risposta è: sebbene l'uso della modularizzazione aumenti i metodi di riferimento, ma in realtà non influisce sulle prestazioni dell'app e il principale problema possibile è la profondità dell'eredità in cui nella maggior parte dei casi è ignorabile .
Sottolineo che un aumento dei metodi di riferimento nella modularizzazione è dovuto a ciascun modulo e dipendenze del modulo
In che modo la modularizzazione delle app può aumentare drasticamente il conteggio dei metodi di riferimento così elevato?
Condizioni in cui l'analizzatore APK ha un impatto importante sui metodi di riferimento
Si noti inoltre che la riduzione e la riduzione del codice possono anche modificare considerevolmente il contenuto di un file DEX dopo la compilazione del codice sorgente.
Oltre alla precedente dichiarazione ufficiale, voglio aggiungere un'altra condizione in cui l'analizzatore APK ad impatto sia:
quanto ha vissuto lo sviluppatore nella modularizzazione?
la modularizzazione è come una casa che l' architettura (sviluppatore) definisce dove dovrebbe essere la cucina e dove dovrebbe essere la stanza di riposo e dove dovrebbe essere il WC.
E se l'architettura decidesse di combinare WC e cucina? Sì, questo è un disastro.
Ciò può accadere durante la modularizzazione se lo sviluppatore non ha molta esperienza.
Risposta a domande OP in aggiunta a informazioni aggiuntive
Qui rispondo alle domande poste nei commenti
Perché il Gradle separato dovrebbe essere aggiunto al conteggio del metodo di riferimento? E per una dipendenza separata, se il risultato finale è un singolo APK, non penso che dipendenze duplicate in 'app' e il modulo funzione si aggiungerebbero al conteggio dei metodi di riferimento.
Poiché i moduli possono essere costruiti, testati e sottoposti a debug, DEVONO avere il proprio Grado e dipendenze.
Mentre viene rispettato il progetto multi-modulo, il compilatore genera diversi .dexfile tra cui:
- un
.dexfile per le dipendenze totalmente integrate
- moduli
.dexs
il .dexfile delle dipendenze è un'integrazione di tutti i gradi dei moduli
Diamo un'occhiata a come un livello di modulo influisce sul conteggio finale dei Mothods referenziati ?!
ci sono 2 APK secondi con lo stesso risultato ma differenza nei conteggi dei metodi di riferimento.
Sono entrambe attività vuote che hanno una 1.7kdifferenza nel conteggio dei metodi di riferimento che dipende molto dalla loro funzionalità. Loro differenza chiave è sul Gradle del loro modulo a cui uno è stato configurato
dependencies {
implementation fileTree(dir: 'libs', include: ['*.jar'])
implementation 'androidx.appcompat:appcompat:1.1.0'
implementation 'androidx.constraintlayout:constraintlayout:1.1.3'
}
Un altro configurato per
dependencies {
implementation fileTree(dir: 'libs', include: ['*.jar'])
implementation 'androidx.appcompat:appcompat:1.2.0-alpha01'
implementation 'androidx.constraintlayout:constraintlayout:2.0.0-beta4'
}
Sebbene siano solo attività vuote, ma una minima differenza in Grado ha causato la 1.7kdifferenza nei conteggi dei metodi di riferimento.
E App Gradle lo è
dependencies {
implementation fileTree(dir: 'libs', include: ['*.jar'])
implementation 'androidx.appcompat:appcompat:1.1.0'
implementation 'androidx.constraintlayout:constraintlayout:1.1.3'
implementation project(path: ':module')
}
la principale preoccupazione è perché l'aggiunta del conteggio dei metodi a riferimento individuale è diversa dal conteggio totale dei metodi a cui fa riferimento Apk Analyzer?
Questo è solo il filtro IDE nient'altro. di sicuro, se si seleziona solo un .dexfile Il conteggio dei metodi di riferimento è uguale al SUM di ogni riga Conteggi del metodo di riferimento ma se si selezionano più .dexfile, si vedrà la differenza nel SUM e nel conteggio effettivo a causa dell'uguaglianza nei riferimenti a cui l'analizzatore ha preferito filtrali.
nei tuoi screenshot hai selezionato più .dexfile, quindi l'uguaglianza del filtro Analizzatore.
nel nostro progetto stiamo usando il file dependencies.gradle centralizzato, quindi non c'è possibilità di versione diversa. Quindi, pensi che anche se abbiamo lo stesso / esatto insieme di dipendenze e le loro versioni nei moduli funzione, aumenterà il conteggio dei metodi di riferimento?
Teoricamente NON dovrebbe aumentare il conteggio dei metodi di riferimento. MA , come ho spiegato, l' esperienza degli sviluppatori ha un grande impatto sul risultato finale.
Team Analyzer dovrebbe verificare e risolvere i problemi di prestazioni prima del rilascio come
- regole proguard
- risorse ridotte e minimizzate
- AndroidManifest.xml
- impostazioni del grado
Ora voglio chiarire in che modo l' esperienza degli sviluppatori e la manutenzione del codice influiscono sul risultato finale. ANCHE se il tuo APK utilizza dipendenze centralizzate
nell'esempio sopra, sono aumentato 5.1knel conteggio dei metodi di riferimento ANCHE SE avevo dipendenze centralizzate !!!!!
Com'è possibile ?
La risposta è: ho appena aggiunto un .jarfile inutile e nascosto nella libsdirectory del progetto. altrettanto facile come puoi vedere ho influenzato il risultato finale.
Come puoi vedere, l' esperienza degli sviluppatori influisce sul risultato finale. Di conseguenza, praticamente è possibile che i metodi di riferimento vengano aumentati, anche se teoricamente NON dovrebbero .
E perché non c'è differenza nel conteggio dei metodi di riferimento quando compilo solo il modulo 'app' disabilitando la compilazione parallela? Dovrebbe essere diminuito poiché sarebbero state utilizzate solo le dipendenze del modulo "app", giusto?
la compilazione non ha alcuna relazione con i metodi di riferimento conta.it rispetta ciò che lo sviluppatore desidera rispettare.
Conclusione
Ho coperto tutte le possibilità intorno al problema. In effetti, può essere emerso da diverse situazioni e uno sviluppatore utilizzando questa linea guida può risolvere il problema.
- Spero che abbiate scoperto perché i metodi di riferimento sono stati aumentati e perché in alcuni casi potrebbe essere drasticamente aumentato.
- I moduli hanno i loro gradi di aumento e dipendenze e moduli di aumento della modularizzazione. pertanto, questi riferimenti ai metodi.
- La modulazione influisce in realtà sulle prestazioni delle app ignorabili, ma migliora notevolmente la manutenzione delle app.
- L'esperienza degli sviluppatori nella modularizzazione influisce fortemente anche sul risultato finale.
NOTA IMPORTANTE: quasi tutte le dichiarazioni sono le mie indagini e ricerche. in effetti, potrebbero esserci errori e guasti e verranno aggiornati per aggiungere molte più informazioni in futuro.
