Autore Topic: [medio] Advanced SplashScreen – caricare Activity in background  (Letto 13596 volte)

Offline teskio

  • Moderatore globale
  • Utente normale
  • *****
  • Post: 387
  • Respect: +118
    • Github
    • Google+
    • Mostra profilo
    • Skullab
  • Dispositivo Android:
    Cubot GT99 / SurfTab Ventos 10.1
  • Play Store ID:
    Skullab Software
  • Sistema operativo:
    windows 7 / ubuntu 12.04
+16
Livello di difficoltà: medio
Target SDK: qualsiasi
Min SDK: 4
Link al file compresso del progetto eclipse: file in allegato

Vi sarà sicuramente capitato di imbattervi in una cosiddetta SplashScreen, una schermata di qualche applicazione che raffigura un logo, eseguita all’apertura dell’applicazione, spesso usata nei videogames. In giro per la rete è facile trovare qualche tutorial su come realizzare una SplashScreen per Android e il procedimento è relativamente semplice. L’approccio che si propone nel web è quello di creare una Activity di SplashScreen da far partire al lancio dell’app, che dopo qualche secondo si richiude e fa partire l’Activity principale del programma. Questa tecnica però ha un difetto. Il beneficio di avere una SplashScreen è praticamente nullo, se non quello puramente estetico. Infatti Il tempo di esecuzione dell’app aumenta perché deve farsi carico del caricamento dell’Activity di Splash e dell’Activity principale, oltretutto l’utente noterà che dal passaggio da una Activity all’altra lo schermo sarà ancora “nero”, privo di grafica, questo perché l’approccio è sequenziale : chiudo un’Activity e ne apro un'altra !
Quello che vedremo in questo tutorial invece, sarà di usare una tecnica diversa e demandare il caricamento dell’Activity principale ad un Thread. Non lanceremo la SplashScreen Activity per prima, ma esattamente il contrario ! Sarà sempre L’Activity principale ad essere eseguita per prima, e sarà quest’ultima a richiamare la SplashScreen !

In pratica sarà come creare una ProgressDialog, ma con una Activity !

Quindi diamo un occhiata al manifest :

Codice (XML): [Seleziona]
<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
     package="tutorials.teskio.splashscreen"
     android:versionCode="1"
     android:versionName="1.0">
    <application android:icon="@drawable/icon" android:label="@string/app_name">
        <activity android:name=".MainActivity"
                 android:label="@string/app_name"
                 android:configChanges="keyboardHidden|orientation">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
                <activity android:name=".SplashScreen"
                        android:configChanges="keyboardHidden|orientation"
                        android:launchMode="singleInstance">
                </activity>
    </application>
    <uses-sdk android:minSdkVersion="4" />

</manifest>

NOTA :
Citazione
Per non incorrere in spiacevoli inconvenienti, nella rotazione del device, ho dichiarato android:configChanges="keyboardHidden|orientation"
Per tutte e due le Activity, in questo modo le Activity non verrano ricreate in caso di rotazione del device.
Mentre android:launchMode="singleInstance" relativa all’Activity SplashScreen, è stato aggiunto in modo da creare una sola istanza dell’Activity stessa. In questo modo se l’utente dovesse premere il tasto “home” per poi riaprire l’app, lo SplashScreen non verrà ricreato dalla MainActivity, e anzi entrambe continueranno il loro lavoro, ovvero la MainActivity a caricarsi e lo SplashScreen nel settaggio della sua progress bar.

Ok, quello su cui si basa questo approccio è un worker thread e l’utilizzo di Handler per far comunicare le due Activity. Vediamo la classe SplashScreen ,  partendo dal suo layout :

Codice (XML): [Seleziona]
<?xml version="1.0" encoding="utf-8"?>
<LinearLayout
 xmlns:android="http://schemas.android.com/apk/res/android"
 android:layout_width="fill_parent"
 android:layout_height="fill_parent"
 android:orientation="vertical"
 android:gravity="center">
  <ImageView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:src="@drawable/anddevlogo"/>
 
  <ProgressBar android:id="@+id/splash_bar"
        style="@android:style/Widget.ProgressBar.Horizontal"
        android:max="100"
        android:paddingTop="5dp"
        android:layout_width="150dp"
        android:layout_height="wrap_content"/>
       
</LinearLayout>

Molto semplicemente, il layout comprende una ImageView e una ProgressBar con stile “orizzontale” (la classica barra di caricamento)
Mentre ecco il codice dell’Activity SplashScreen :

Codice (Java): [Seleziona]
package tutorials.teskio.splashscreen;

import android.app.Activity;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.view.KeyEvent;
import android.widget.ProgressBar;

public class SplashScreen extends Activity {
       
        private static Handler mHandler ;
        private static Handler mainHandler ;
        private ProgressBar mBar ;
       
        protected static final int CLOSE_SPLASH = 0 ;
        protected static final int SET_PROGRESS = 1 ;
       
        /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.splash_screen);
       
        mBar = (ProgressBar)findViewById(R.id.splash_bar);
       
        mHandler = new Handler(){
                @Override
                public void handleMessage(Message msg){
                        switch(msg.what){
                        case CLOSE_SPLASH:
                        finish();
                        break;
                        case SET_PROGRESS:
                                mBar.setProgress((msg.arg1 / 10));
                        }
                       
                }
        };
    }
   
    @Override
    public void onStart(){
        super.onStart();
        if(mainHandler != null){
                mainHandler.sendEmptyMessage(MainActivity.START_LOAD);
        }
    }
   
    @Override
    public boolean onKeyDown (int keyCode, KeyEvent event){
        if(keyCode == KeyEvent.KEYCODE_BACK){
                mainHandler.sendEmptyMessage(MainActivity.ABORT_LOAD);
        }
        return super.onKeyDown(keyCode, event) ;
    }
    public static void setMainHandler(Handler h){
        mainHandler = h ;
    }
    public static void sendMessage(Message msg){
        mHandler.sendMessage(msg);
    }
    public static void sendMessage(int w){
        mHandler.sendEmptyMessage(w);
    }
}

Nell’onCreate settiamo il layout e la ProgressBar, in più creiamo un Handler che ci servirà per comunicare con l’Activity dal worker thread della MainActivity.
Quando lo SplashScreen è pronto lo comunichiamo alla MainActivity nell’onStart.
A questo punto la MainActivity lancerà il thread di caricamento (che vedremo più avanti), comunicando di volta in volta allo SplashScreen la “percentuale” di caricamento eseguito da visualizzare nella ProgressBar.
Ci sono due metodi di convenienza :

Codice (Java): [Seleziona]
public static void setMainHandler(Handler h){
        mainHandler = h ;
    }
    public static void sendMessage(Message msg){
        mHandler.sendMessage(msg);
    }
    public static void sendMessage(int w){
        mHandler.sendEmptyMessage(w);
    }

I quali servono, uno per  salvare il riferimento dell’Handler della MainActivity (setMainHandler) e l’altro (di cui è stato fatto l’overloading) per comunicare con lo SplashScreen dalla MainActivity.
Ultima nota, l’override del metodo onKeyDown è stato fatto per intercettare la pressione del tasto back e chiudere entrambe le Activity, proprio come se si uscisse dall’app. Se ciò non fosse stato fatto, la pressione del tasto back avrebbe chiuso solo lo SplashScreen e non la MainActivity, che avrebbe continuano a caricarsi, ma senza grafica…
Ecco invece il codice della MainActivity :

Codice (Java): [Seleziona]
package tutorials.teskio.splashscreen;

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.util.Log;
import android.view.ViewGroup.LayoutParams;
import android.widget.LinearLayout;
import android.widget.TextView;

public class MainActivity extends Activity {

        private LayoutParams layoutParams = new LayoutParams(
                        LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT);
        private LayoutParams textParams = new LayoutParams(
                        LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);
        private MainActivity _this;
        private LinearLayout layout;
        private Handler mHandler;
       
        protected static final int FINISH_LOAD = 0 ;
        protected static final int START_LOAD = 1 ;
        protected static final int ABORT_LOAD = 2 ;
       
        /** Called when the activity is first created. */
        @Override
        public void onCreate(Bundle savedInstanceState) {
                super.onCreate(savedInstanceState);
               
                _this = this;
               
                mHandler = new Handler() {
                        @Override
                        public void handleMessage(Message msg) {
                                switch (msg.what) {
                                case FINISH_LOAD:
                                        setContentView(layout);
                                        SplashScreen.sendMessage(SplashScreen.CLOSE_SPLASH);
                                        break;
                                case START_LOAD:
                                        initializing();
                                        break;
                                case ABORT_LOAD:
                                        finish();
                                }

                        }
                };
                startSplash();
        }
       
        private void startSplash() {
                Intent intent = new Intent(this, SplashScreen.class);
                SplashScreen.setMainHandler(mHandler);
                startActivity(intent);
        }

        private void initializing() {
                new Thread() {
                        @Override
                        public void run() {

                                layout = new LinearLayout(_this);
                                layout.setLayoutParams(layoutParams);
                                layout.setOrientation(LinearLayout.VERTICAL);

                                for (int i = 0; i < 1000; i++) {
                                        TextView tv = new TextView(_this);
                                        tv.setLayoutParams(textParams);
                                        tv.setText("Sono la TextView n° " + i);
                                        layout.addView(tv);
                                       
                                        Message msg = new Message();
                                        msg.what = SplashScreen.SET_PROGRESS;
                                        msg.arg1 = i;
                                        SplashScreen.sendMessage(msg);
                                }

                                mHandler.sendEmptyMessage(FINISH_LOAD);

                        }

                }.start();
        }

}

Anche qui abbiamo un Handler nell’onCreate, e due metodi di convenienza, lo startSplash() che fa partire l’Activity di SplashScreen e initializing() che contiene il Thread di caricamento.

NOTA :
Citazione
Per velocizzare il tutto e per permettere di aumentare il carico di lavoro nella creazione della grafica dell’Activity principale, non ho utilizzato file XML per la definizione di Layout, ma ho creato le varie View direttamente da codice, ma nessuno vi vieta di implementare il vostro Layout in formato XML nello stile Android. :-P

Ho volutamente esagerato con la creazione delle TextView (1000 !), proprio per caricare di lavoro il thread e poter visualizzarne l’effetto a schermo. All’interno del Thread possiamo notare l’invio di messaggi ai rispettivi Handler.

Codice (Java): [Seleziona]
Message msg = new Message();
msg.what = SplashScreen.SET_PROGRESS;
msg.arg1 = i; // il numero di TextView caricate
SplashScreen.sendMessage(msg);

Qui non facciamo altro che inviare all’Handler della SplashScreen una informazione relativa alla quantità di TextView inizializzate, mentre con :

Codice (Java): [Seleziona]
mHandler.sendEmptyMessage(FINISH_LOAD);
Informiamo la MainActivity che l’inizializzazione è completata e conseguentemente può fermare lo SplashScreen.

Se tutto è andato a buon fine vedremo l’Activity in foreground (SplashScreen) che indicherà lo stato di caricamento dell’Activity in background (MainActivity) !

That’s all folk !

Al prossimo tutorial, sperando che questo vi possa essere utile…



Offline Nicola_D

  • Utente storico
  • *****
  • Post: 2479
  • SBAGLIATO!
  • Respect: +323
    • Github
    • Google+
    • nicoladorigatti
    • Mostra profilo
  • Dispositivo Android:
    Nexus 6p, Nexus 4, Nexus S, Nexus 7(2012)
  • Sistema operativo:
    Windows 7
Re:[medio] Advanced SplashScreen – caricare Activity in background
« Risposta #1 il: 11 Agosto 2011, 11:32:55 CEST »
0
non credo di averne bisogno nelle mie apps, però è un lavoro fantastico! complimenti davvero!
IMPORTANTE:NON RISPONDO A PROBLEMI VIA MESSAGGIO PRIVATO
LOGCAT: Non sai cos'è? -> Android Debug Bridge | Android Developers
               Dov'è in Eclipse? -> Window -> Open Prospective -> DDMS e guarda in basso!
[Obbligatorio] Logcat, questo sconosciuto! (Gruppo AndDev.it LOGTFO) - Android Developers Italia

Offline teo_

  • Utente junior
  • **
  • Post: 72
  • Respect: +1
    • Github
    • Mostra profilo
  • Dispositivo Android:
    Nexus 4
  • Sistema operativo:
    Windows 7 - Ubuntu 12.10
Re:[medio] Advanced SplashScreen – caricare Activity in background
« Risposta #2 il: 18 Settembre 2011, 21:54:37 CEST »
0
ciao, ottimo tutorial complimenti!
solo una cosa.. in questo modo quando carico l'applicazione però si vede che dall'activity principale "switcha" all'activity della splash screen e poi finito questo "switcha" ancora all'activity principale, quello che mi chiedevo io è.. non si potrebbe per esempio far caricare come activity principale la splash screen, intanto in background caricare l'activity dell'applicazione, e una volta finito il caricamento chiamare quest'ultima?
lo chiedo perchè non ho idea di come implementare quello che ho spiegato, e non sono nemmeno molto sicuro si possa fare..

Offline mordicchio

  • Nuovo arrivato
  • *
  • Post: 4
  • Respect: 0
    • Mostra profilo
  • Dispositivo Android:
    Samsung Galaxy S2
  • Sistema operativo:
    Windows 7
Re:[medio] Advanced SplashScreen – caricare Activity in background
« Risposta #3 il: 27 Dicembre 2011, 01:32:36 CET »
0
Ciao, anzitutto ottimo lavoro. Scusa se riprendo questo topic di vari mesi fa, ma l'ho provato solo adesso. Io ho il seguente problema. Tutto il processo di caricamento va perfettamente, se però mando l'app in background e poi la rimetto in foreground parte lo splashscreen, carica per qualche secondo e poi esce senza caricare nessuna activity. Questo accade in OGNI activity dell'app, basta che almeno una volta sia passato dal caricamento con la splashscreen. Sembra proprio che quest'ultima rimanga attiva e non esca correttamente. Purtroppo non posso fare molti altri test perché sull'emulatore il taskmanager non esiste dunque non posso rimettere in foreground app sospese.

Grazie mille per qualunque aiuto tu mi possa dare!

Offline mordicchio

  • Nuovo arrivato
  • *
  • Post: 4
  • Respect: 0
    • Mostra profilo
  • Dispositivo Android:
    Samsung Galaxy S2
  • Sistema operativo:
    Windows 7
Re:[medio] Advanced SplashScreen – caricare Activity in background
« Risposta #4 il: 27 Dicembre 2011, 11:42:03 CET »
0
Ho trovato da solo l'errore... Nell'Activity SplashScreen, quando ricevi il CLOSE_SPLASH devi anche settare a null il MainHandler altrimenti, essendo statico, permane anche dopo la destroy dell'activity e dunque ad ogni onStart viene erroneamente richiamato.
Dunque:

nella onCreate della SplashActivity:

Codice (Java): [Seleziona]
                 mHandler = new Handler() {
                        @Override
                        public void handleMessage(Message msg) {
                                switch (msg.what) {
                                case CLOSE_SPLASH:
                                        mainHandler = null;
                                        finish();
                                        break;
                                }

                        }
                };

nella onStart():

Codice (Java): [Seleziona]
                if (mainHandler != null)
                        mainHandler.sendEmptyMessage(mainActivity.START_LOAD);
                else {
                        Intent intent = new Intent(SplashScreen.this, mainActivity.class);
                        startActivity(intent);
                }


Volendo si possono fondere entrambi nella onCreate o nella onStart, non cambia nulla tanto quest'activity viene sempre distrutta alla fine dell'operazione

Offline mordicchio

  • Nuovo arrivato
  • *
  • Post: 4
  • Respect: 0
    • Mostra profilo
  • Dispositivo Android:
    Samsung Galaxy S2
  • Sistema operativo:
    Windows 7
Re:[medio] Advanced SplashScreen – caricare Activity in background
« Risposta #5 il: 27 Dicembre 2011, 13:51:21 CET »
0
Ulteriore miglioramento: mi ero dimenticato di distruggere la splash activity quando si ritona in foreground (in questo modo ogni volta che uscite e ritornate la schermata si blocca)

Modifica:

Codice (Java): [Seleziona]
                if (mainHandler != null)
                        mainHandler.sendEmptyMessage(mainActivity.START_LOAD);
                else {
                        Intent intent = new Intent(SplashScreen.this, mainActivity.class);
                        startActivity(intent);
                        finish();
                }

Inoltre se avete più activity e volete che la restart torni sempre all'ultima activity stoppata (e non alla main) bisogna modificare così il campo nel manifest della splash activity

Codice (XML): [Seleziona]
android:launchMode="singleTask"
anzinché "singleInstance", in questo modo il task delle attivazioni è unico e si riattiva correttamente l'activity in cima allo stack trace

Pura curiosità... come mai nessuno se ne era accorto prima?


Offline teskio

  • Moderatore globale
  • Utente normale
  • *****
  • Post: 387
  • Respect: +118
    • Github
    • Google+
    • Mostra profilo
    • Skullab
  • Dispositivo Android:
    Cubot GT99 / SurfTab Ventos 10.1
  • Play Store ID:
    Skullab Software
  • Sistema operativo:
    windows 7 / ubuntu 12.04
Re:[medio] Advanced SplashScreen – caricare Activity in background
« Risposta #6 il: 27 Dicembre 2011, 20:20:30 CET »
0
Grazie per l'interessamento per questo tutorial :-P
Sono contento per i miglioramenti apportati e per i bug scoperti, purtroppo il codice non è mai stato revisionato poichè anch'io non sono solito usare degli splashscreen nelle app. Scrissi questo tutorial come spunto per creare un splashscreen alternativo al modello proprosto in giro per la rete, cioè quello di avviare l'activity di splashscreen come mainActivity e successivamente richiamare le altre, diciamo che scrissi questo codice più per vedere se era possibile usare un'altra strada :-P

Per tornare alle tue domande (che comunque hai già risolto) quando creai questo splashscreen feci in modo che una volta caricata l'activity vera e propria, mandando l'app in background (con il tasto home ad esempio...) lo splashscreen non sarebbe più apparso poichè l'activity era già stata caricata...almeno a memoria mi sembra che il funzionamento fosse questo, riesumerò il codice per dargli un'occhiata ;-)

Comunque ogni correzione è ben voluta ! :D Thanks !

EDIT: sono andato a riguardare il codice, allora...
Citazione
Nell'Activity SplashScreen, quando ricevi il CLOSE_SPLASH devi anche settare a null il MainHandler altrimenti, essendo statico, permane anche dopo la destroy dell'activity

Vero...però il mainHandler viene sempre ricreato e passato allo SplashScreen attraverso il metodo statico public static void setMainHandler(Handler h)
comunque è vero che se si manda il background lo splashscreen poi quando si ritorna all'app lo splashscreen non appare più (schermop nero e attesa carimento mainActivity)...ma se si mette la mainActivity in background una volta caricata lo splashScreen non riparte ma appare subito la mainActivity :-P

Ho trovato giustamente il bug dovuto al tasto back durante lo splashScreen...ma questa è colpa mia (dhò) poichè l'ABORT_LOAD è mal gestita l'ammetto (mea culpa :-()

Comunque come dicevo prima dell'edit ogni suggerimento/miglioramento è sempre ben accetto ! Sono contento che almeno sia servito (anche solo come spunto/base) questo tutorial ! :-P Se ho tempo faccio una revisione del codice e lo riuppo ! Grazie !
« Ultima modifica: 27 Dicembre 2011, 20:49:15 CET da teskio »

Offline mordicchio

  • Nuovo arrivato
  • *
  • Post: 4
  • Respect: 0
    • Mostra profilo
  • Dispositivo Android:
    Samsung Galaxy S2
  • Sistema operativo:
    Windows 7
Re:[medio] Advanced SplashScreen – caricare Activity in background
« Risposta #7 il: 27 Dicembre 2011, 21:23:23 CET »
0
Figurati nessun problema, grazie ancora a te... Aldilà di questi bug relativamente minori, il codice è semplice e ben fatto, devo dire che mi ha aiutato parecchio nella realizzazione della mia app!

Offline Malo

  • Nuovo arrivato
  • *
  • Post: 1
  • Respect: 0
    • Mostra profilo
  • Dispositivo Android:
    Motorola Milestone/Galaxy i7500
  • Sistema operativo:
    Archlinux
Re:[medio] Advanced SplashScreen – caricare Activity in background
« Risposta #8 il: 16 Gennaio 2012, 11:11:51 CET »
0
Non so se può essere utile.. Ma implementato questo tutorial (sono alle prime armi ;) ) mi sono accorto che alla rotazione del display la Main Activity, venendo distrutta e ricreata, propone nuovamente la splash screen (ogni volta che si cambia orientamento)


Seguendo il consiglio di mordicchio
Codice: [Seleziona]
android:launchMode="singleTask"
Ottengo una schermata nera a ogni rotazione prima di visualizzare la main.

Mi è venuto in mente che si può condizionarestartsplash() con un booleano statico nella main actvity
Codice (Java): [Seleziona]
private static boolean loaded=false;e
Codice (Java): [Seleziona]
 if(!loaded){
                mHandler = new Handler() {
                        @Override
                        public void handleMessage(Message msg) {
                                switch (msg.what) {
                                case FINISH_LOAD:
                                               
                                        startHome();
                                        SplashScreen.sendMessage(SplashScreen.CLOSE_SPLASH);
                                        loaded=true;
                                        break;
                                case START_LOAD:
                                        initializing();
                                        break;
                                case ABORT_LOAD:
                                        finish();
                                }
       
                        }


                                       
                };
                startSplash();
        }else{
                startHome();
        }


con startHome()
Codice (Java): [Seleziona]
private void startHome() {
                setContentView(R.layout.main);
                //..quello che volete fare etc..
        }



« Ultima modifica: 16 Gennaio 2012, 14:05:03 CET da Malo »

Offline Mr.Donut

  • Utente junior
  • **
  • Post: 67
  • Respect: +4
    • Mostra profilo
  • Dispositivo Android:
    Nexus One, Lg Optimus Chat
  • Sistema operativo:
    Ubuntu 11.04
Re:[medio] Advanced SplashScreen – caricare Activity in background
« Risposta #9 il: 28 Febbraio 2012, 17:17:29 CET »
+1
Questo lavoro è veramente spettacolare!
Nel tutorial parli della possibilità di usare un Layout in formato XML.
Come si potrebbe fare?

Quello che mi viene in mente è:

-non usare i seguenti parametri
Codice (Java): [Seleziona]
        private LayoutParams layoutParams = new LayoutParams(
                        LayoutParams.FILL_PARENT, LayoutParams.FILL_PARENT);
        private LayoutParams textParams = new LayoutParams(
                        LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);
        private LinearLayout layout;

e richiamare nel run() il setContentView del mio layout in XML.

E' giusto oppure devo fare qualcosa di diverso?

Grazie

EDIT:
Ok, mi sono risposto da solo. :P
« Ultima modifica: 28 Febbraio 2012, 17:41:06 CET da Mr.Donut »

Offline lucab

  • Nuovo arrivato
  • *
  • Post: 49
  • Respect: +10
    • Mostra profilo
    • Lucabportal
  • Dispositivo Android:
    Nexus 5 - Nexus One
  • Play Store ID:
    Luca Biasotto
  • Sistema operativo:
    Mac OS X
Re:[medio] Advanced SplashScreen – caricare Activity in background
« Risposta #10 il: 10 Marzo 2012, 19:03:31 CET »
0
Ciao
Donut interessa anche a me sapere come fare per usare un Layout in fomrato XML,

tu come hai risolto?

non usare i parametri layoutParams , textParams  e layout come dicevi tu è corretto, ma richiamando il setContentView nel run non funziona!

Grazie!
Le occasioni arrivano una volta sola, se non le afferri al volo passeranno altri alla storia.

Offline Mr.Donut

  • Utente junior
  • **
  • Post: 67
  • Respect: +4
    • Mostra profilo
  • Dispositivo Android:
    Nexus One, Lg Optimus Chat
  • Sistema operativo:
    Ubuntu 11.04
Re:[medio] Advanced SplashScreen – caricare Activity in background
« Risposta #11 il: 19 Marzo 2012, 15:35:43 CET »
+1
Ciao
Donut interessa anche a me sapere come fare per usare un Layout in fomrato XML,

tu come hai risolto?

non usare i parametri layoutParams , textParams  e layout come dicevi tu è corretto, ma richiamando il setContentView nel run non funziona!

Grazie!

Hey Ciao lucab! Scusami per l'attesa ma ho avuto parecchi problemi di salute...
Comunque ti spiego subito tutto:
e' molto semplice fare quello che vuoi e ti incollo il pezzetto di codice che ti serve

Codice (Java): [Seleziona]
                                case FINISH_LOAD:
                                        /*** Qui setti il tuo layout in xml ***/
                                        setContentView(R.layout.main);

                                        // Se vuoi aggiungi poi dei button così
                                        ImageButton button1 = (ImageButton) findViewById(R.id.imageButton1);
                                        button1.setOnClickListener(new View.OnClickListener() {
                                                @Override
                                                public void onClick(View v) {
                                                        Log.i("LogCatProva", "Premuto ImgBut1, Lancio tuaActivity()");
                                                        startTuaActivity();
                                                }
                                        });

Quella parte del "CASE" viene eseguita alla fine del nostro splash-screen e quindi puoi settare il tuo xml in quel punto.
Oppure puoi mettere tutto in una funzioncina....

Scusa ancora per il ritardo e spero di averti aiutato!



Offline lucab

  • Nuovo arrivato
  • *
  • Post: 49
  • Respect: +10
    • Mostra profilo
    • Lucabportal
  • Dispositivo Android:
    Nexus 5 - Nexus One
  • Play Store ID:
    Luca Biasotto
  • Sistema operativo:
    Mac OS X
Re:[medio] Advanced SplashScreen – caricare Activity in background
« Risposta #12 il: 23 Marzo 2012, 19:12:58 CET »
0
Grazie mille!!

Comunque tranquillo, nessun problema per il ritardo!!
per cause lavorative e impegni vari la mia povera app è da un è po' che è ferma li, nel weekend spero di avere un po' di tempo e provo a sistemarla come mi hai suggerito!!

Grazie ancora, sei stato chiarissimo!!
:)

EDIT:
Ho risolto seguendo la tua indicazione, grazie ancora ;)
« Ultima modifica: 24 Marzo 2012, 12:40:53 CET da lucab »
Le occasioni arrivano una volta sola, se non le afferri al volo passeranno altri alla storia.

Offline A2PLab

  • Nuovo arrivato
  • *
  • Post: 37
  • [Close The World - txeN ehT nepO]
  • Respect: +1
    • Google+
    • http://it.linkedin.com/in/giuseppemastroeni
    • a2plab
    • a2plab
    • Mostra profilo
    • A2PLab
  • Dispositivo Android:
    HTC Desire, Acer Iconia Tab a500
  • Sistema operativo:
    Ubuntu 11.04
Re:[medio] Advanced SplashScreen – caricare Activity in background
« Risposta #13 il: 03 Maggio 2012, 16:00:55 CEST »
0
Ciao a tutti,

Vorrei aggiungere un grado di complessità a questo tutorial, che comunque è molto utile e ben fatto, complimenti.
Se nella init della mia activity principale io dovessi effettuare delle operazioni con dei fragment e quindi chiamare la executePendigTransaction(), la quale può essere chiamata solo nel main Thread della app?

Idee?

[Close The World - txeN ehT nepO]

Offline ViTiX

  • Nuovo arrivato
  • *
  • Post: 3
  • Respect: 0
    • Mostra profilo
  • Sistema operativo:
    Windows 7 SP1
Re:[medio] Advanced SplashScreen – caricare Activity in background
« Risposta #14 il: 06 Ottobre 2012, 18:44:36 CEST »
0
Come devo fare per far vedere la webview del activity_main?