Android Annotations: Ciclo de vida

Te contamos a continuación cómo se gestiona el ciclo de vida dentro de AndroidAnnotations.

Instalar AndroidAnnotations

Dentro de AndroidAnnotations podemos validar o introducirnos dentro del ciclo de vida de una aplicación. Para ello tenemos diferentes anotaciones, que vamos a ver de forma práctica.

Lo primero que haremos será instalar AndroidAnnotations en nuestra aplicación, para lo que simplemente tenemos que incluir dos líneas en las dependencias y especificar la versión que queremos utilizar, que en este caso será la 4.6.0.

Para hacerlo tenemos que sustituir este bloque de código:


dependencies {
    implementation fileTree(dir: 'libs', include: ['*.jar'])
    implementation 'com.android.support:appcompat-v7:28.0.0'
    implementation 'com.android.support.constraint:constraint-layout:1.1.3'
    testImplementation 'junit:junit:4.12'
   	 androidTestImplementation 'com.android.support.test:runner:1.0.2'
    androidTestImplementation 'com.android.support.test.espresso:espresso-core:3.0.2'
}

Por este otro:


def AAVersion = '4.6.0'

dependencies {
    annotationProcessor "org.androidannotations:androidannotations:$AAVersion"
    implementation "org.androidannotations:androidannotations-api:$AAVersion"

    implementation fileTree(dir: 'libs', include: ['*.jar'])
    implementation 'com.android.support:appcompat-v7:28.0.0'
    implementation 'com.android.support.constraint:constraint-layout:1.1.3'
    testImplementation 'junit:junit:4.12'
    androidTestImplementation 'com.android.support.test:runner:1.0.2'
    androidTestImplementation 'com.android.support.test.espresso:espresso-core:3.0.2'
}

A continuación tendríamos que cambiar el archivo AndroidManifest, para que se lance la MainActivity de AndroidAnnotations dentro de nuestra aplicación. Esto lo haremos cambiando la línea:

<activity android:name=”.MainActivity”>

Por esta otra:


<activity android:name=”.MainActivity_”>

Finalmente podremos vaciar la MainActivity que se construye por defecto, y dejarla con esta anotación:


@EActivity(R.layout.activity_main)
public class MainActivity extends AppCompatActivity {
}

Con esta notación lo que indicamos es que nuestra clase ha sido mejorada con AndroidAnnotations, y ya tendríamos una aplicación funcional.

Distintas partes del ciclo de vida

Vamos a ver las distintas partes del ciclo de vida, para lo que eso vamos a editar el archivo MainActivity.java de esta forma:


@EActivity(R.layout.activity_main)
public class MainActivity extends AppCompatActivity {

    @AfterExtras
    void initAfterExtras() {
        Log.d("","----------------------------------------------------------------------->1 - AfterExtras");
    }

    @AfterInject
    void initAfterInject() {
        Log.d("","----------------------------------------------------------------------->2 - AfterInject");
    }

    @Override
    protected void onCreate(Bundle sIS) {
        super.onCreate(sIS);
        Log.d("","----------------------------------------------------------------------->3 - onCreate");
    }

    @AfterViews
    void initAfterViews() {
        Log.d("","----------------------------------------------------------------------->4 - AfterViews");
    }

    @Override
    protected void onStart() {
        super.onStart();
        Log.d("","----------------------------------------------------------------------->5 - onStart");
    }

    @Override
    protected void onResume() {
        super.onResume();
        Log.d("","----------------------------------------------------------------------->6 - onResume");
    }
}

De esta forma vamos a poder ver cuál es el orden de ejecución y cómo podemos interactuar con el ciclo de vida la aplicación. Para ello lanzamos la aplicación y una vez ejecutada pasamos a ver los logs que se han generado durante el proceso.

De esta forma podemos observar que se ha lanzado primero AfterExtras, después AfterInject, a continuación OnCreate y para finalizar AfterViews.

Si quieres ampliar tus conocimientos en Andorid puedes hacer este curso dónde aprenderás desde cero AndroidAnnotation, el framework que te facilita programar aplicaciones nativas.