Prestazioni Android: aggiunta vista a livello di programmazione rispetto alla visualizzazione delle impostazioni su GONE/VISIBLE

Question

Sto lavorando a un progetto che richiede di gonfiare un semplice tutorial Visualizza quando l'utente apre l'app per la prima volta. Sto cercando di farlo "nel modo giusto" e mi sto chiedendo un problema di prestazioni.

Attualmente, ho nel mio layout una vista imposta su android:visibility="GONE", che io cambio in VISIBLE a seconda di un SharedPreference. Questo mi consente di far capire all'utente come funziona l'app al primo avvio.

Quello che mi chiedo è che cosa implica quando la vista viene resa nel mio frammento. La mia ipotesi è che la vista sarà gonfiata inutilmente, anche se la sua visibilità è impostata su GONE.

Ora, sto pensando a un'alternativa: cosa succede se aggiungo la mia vista solo ai primi lanci, ma a livello di programmazione, nel mio frammento onCreateView. Ciò dovrebbe consentire di non gonfiare la vista nei lanci successivi, ma non gonfiare la vista a livello di programmazione implica prestazioni non buone ai primi lanci?

Answer 1

Quindi, per rispondere alla mia stessa domanda ho utilizzato lo strumento DDMS TraceView per monitorare le chiamate dal mio frammento onAttach fino al suo onResume. Mi consente di vedere quale implementazione è meno efficiente.

Per fare il test, ho avuto un semplice RelativeLayout con un FrameLayout al suo interno (mostrato tutto il tempo). Ho usato un layout personalizzato da aggiungere ogni volta, a livello di programmazione o con una visibilità di GONE sul mio file di layout. Il layout personalizzato era composto da un RelativeLayout con 4 childs (ImageView, TextView, View e Button).

Il mio onCreateView era il seguente, consentendo all'applicazione di ingrandire il layout corretto in base a due costanti static final boolean per modificare i layout.

public View onCreateView(LayoutInflater inflater, ViewGroup container, 
     Bundle savedInstanceState) { 
    LinearLayout root; 
    if(INFLATE_PROGRAMMATICALY) { 
     root = (LinearLayout) inflater.inflate(R.layout.fragment_test_prgmcly, container, false); 
     if(SHOULD_FYI_VIEW_BE_SHOWN) { 
      View tutoView = inflater.inflate(R.layout.inner_view, root, false); 
      root.addView(tutoView); 
     } 
    } else { 
     root = (LinearLayout) inflater.inflate(R.layout.fragment_test_gone,container,false); 
     if(SHOULD_FYI_VIEW_BE_SHOWN) { 
      View tutoView = root.findViewById(R.id.RL_inner_view); 
      tutoView.setVisibility(View.VISIBLE); 
     } 
    } 
    return root; 
} 

Questo ha portato ai seguenti risultati:

Quando il layout opzionale gonfiato

SHOULD_FYI_VIEW_BE_SHOWN=true

La "stima in tempo reale" massimo in Traceview sono di 75 ms quando c'è solo una vista per passare da GONE a VISIBLE, ma di 110 ms quando è necessario creare un'istanza dello inner_view.

Quando il layout opzionale non è gonfiato SHOULD_FYI_VIEW_BE_SHOWN=false

In questo caso, il tempo reale stima massima in Traceview sono di 102ms per il gonfiaggio della vista GONE, contro 39MS quando la vista gonfiata non ha la vista GONE.

Quindi, per il guadagno di prestazioni quando non è necessario gonfiare le visualizzazioni, direi che la soluzione migliore è per ingrandire la visualizzazione a livello di codice se è necessario solo mostrarla per qualche tempo.

Potete trovare il progetto di test su un Gist

Answer 2

Penso che mi sia imbattuto casualmente nella risposta della domanda sul rendimento.

Dal Animation Docs:

Per la visualizzazione che viene sbiadita, impostare la sua visibilità andato. Questo impedisce la vista da occupare spazio layout e omette dal layout calcoli, accelerando elaborazione.

Questo significherebbe prestazioni non venga compromesso fino a quando non si imposta android:visibility a niente altro che GONE.

Answer 3

Penso che si stanno reinventando una ruota. Per questo scenario è già presente lo strumento nei layout xml Android. Si chiama ViewStub. Puoi leggere di più qui: Loading ondemand