Una Actividad es una cosa única y enfocada que el usuario puede hacer, según la documentación oficial de android.

El término proviene claramente del verbo act que básicamente significa realizar una acción o interactuar con algo.

Aunque podemos tener una actividad sin componentes visuales, la mayoría de las actividades se crean para albergar vistas y widgets con los que los usuarios pueden interactuar.

Por lo tanto, las actividades pueden referirse vagamente a toda la pantalla con la que el usuario va a interactuar.

Con esta forma de pensar aquí están algunas de las cosas que podemos hacer a nuestra actividad:

No. Acción Descripción
1. Abrir una nueva actividad. Esto reemplaza la actividad o pantalla actual.
2. Cerrar la actividad actual Para que deje de ser visible para nosotros. El sistema Android no la matará completamente, sólo la pondrá en segundo plano, para que no vuelva a ella.
3. Rotar el dispositivo Digamos que estás viendo un vídeo o jugando a un juego desde esta aplicación y quieres verlo en una disposición diferente. Este proceso hace que se recree la actividad para que se adapte a tus necesidades de disposición.

Hacer cosas como las anteriores hace que el sistema androide levante varios callbacks del ciclo de vida. Estos son básicamente los métodos que se plantean en una manera impulsada por eventos en varias etapas en el ciclo de vida de una "actividad". Por ejemplo, la creación, la pausa, la reanudación, el inicio, el reinicio, la detención, etc.

Mecanismos de presentación de una "actividad

Las Actividades se pueden presentar de varias maneras en android:

No. Mecanismo Descripción
1. Ventana de pantalla completa: La forma más común de presentar una actividad.Con esto cubren toda la pantalla.
2. Ventanas flotantes : Las actividades pueden ser configuradas como ventanas flotantes a través de un tema con el atributo windowIsFloating.
3. Embedding : Las actividades también pueden ser incrustadas dentro de otra actividad utilizando el grupo de actividades.

Sin embargo, tenga en cuenta que la incrustación ya no es atractiva, ya que el ActivityGroup fue obsoleto con la introducción de Fragments en el nivel 13 de la API. Los fragmentos son básicamente sub-actividades con su propio ciclo de vida.

Definición de la clase Activity.

Veamos también una descripción programática de una actividad.

Primero pertenece al paquete android.app:

package android.app;

Activity es una clase como cualquier otra, pero también es única a su manera. También es pública, por lo que es visible y utilizable dentro de otros paquetes fuera del suyo.

public class Activity..{}

El hecho de ser una clase hace que también tenga características orientadas a objetos que otras clases sí tienen como

  1. Capacidad de derivar de otras clases y ser derivado de ellas.
  2. Capacidad de implementar interfaces.
  3. Capacidad de tener sus propios métodos, campos y clases internas.

De hecho la clase Activity deriva de la clase ContextThemeWrapper.

public class Activity extends ContextThemeWrapper..{}

El ContextThemeWrapper da a la clase la capacidad de manipular y modificar el tema de lo que está en el contexto envuelto.

Además una Activity implementa varias interfaces:

public class Activity extends ContextThemeWrapper implements LayoutInflater.Factory2 Window.Callback KeyEvent.Callback View.OnCreateContextMenuListener ComponentCallbacks2{}
Hijos y nietos de la actividad

Son las subclases directas de la actividad y las subclases indirectas.

Aquí están las subclases directas:

No. Actividad Descripción
1. FragmentActivity La superclase utilizada por las actividades que quieren Fragments y Loader APIs utilizando la biblioteca de apoyo.
2. NativeActivity Para aquellos que quieran una actividad conveniente para ser implementada puramente en código nativo.
3. ListActivity Una actividad especializada en la visualización de una lista de elementos vinculados a una fuente de datos.
4. 4. ExpandableListActivity: Actividad especializada en mostrar una lista expandible de elementos vinculados a una fuente de datos.
5. Proporciona un mecanismo de alias a una actividad. Lo hace lanzando otra actividad y matándose a sí misma.
6. 6. AccountAuthenticatorActivity Superclase para crear actividades que implementen AbstractAccountAuthenticator.
7. 7. ~ActivityGroup~ Desaprobado en la API 13 tras la introducción de Fragments. Antes de eso era la forma de crear para crear una pantalla que tiene múltiples actividades incrustadas.

Estos son los hijos de la actividad.

Veamos ahora las subclases de los nietos/indirectos.

No. Actividad Actividad principal: Descripción.
1. AppCompatActivity FragmentActivity AppCompatActivity es la superclase para las actividades que planean utilizar las características de la barra de acción.
2. ~ActionBarActivity~ AppCompatActivity Deprecated. Antes se utilizaba para proporcionar características de la barra de acción a las actividades. Ahora ese papel ha pasado a AppCompatActivity.
3. TabActivity**~ ActivityGroup Deprecated way back in the API level 13. Ahora los fragmentos pueden hacer eso.
4. La superclase a utilizar para aquellos que pretenden mostrar una jerarquía de preferencias a los usuarios.
5. 5. LauncherActivity: ListActivity: Muestra una lista de todas las actividades que se pueden realizar para una determinada intención.

Capacidades La clase Activity proporciona sus hijos

Podemos, y hemos dicho que las actividades representan una cosa única enfocada que un usuario puede hacer.

Así que sabemos que nos permite usar y renderizar vistas y widgets con los que los usuarios pueden interactuar.

Sin embargo, ahora vamos a explorar funcionalidades más detalladas y específicas de un nivel inferior que la clase Activity proporciona a sus hijos.

1. Capacidades del contexto
  1. Comprobar varios permisos : Por ejemplo: el checkPermission(String permission, int pid, int uid) determinará si un determinado proceso e ID de usuario que se ejecuta en el sistema tiene el permiso pasado, checkUriPermission(Uri uri, int pid, int uid, int modeFlags) determinará si un determinado proceso e ID de usuario que se ejecuta en el sistema tiene permiso para acceder al Uri pasado, etc.
  2. Conectar o crear un servicio de aplicación : El Contexto puede ser usado para conectarse a un servicio de aplicación o crearlo si es necesario, esto se hace a través de la llamada al método bindService(Intent service, ServiceConnection conn, int flags).
    3.Crear otros Contextos : Por ejemplo, createConfigurationContext(Configuration overrideConfiguration) creará un nuevo objeto Contexto para el contexto actual pero con recursos ajustados a la configuración pasada, createPackageContext(String packageName, int flags) devuelve un nuevo objeto Contexto para el nombre de la aplicación dada.
  3. Lista de bases de datos y archivos asociados : databaseList() nos proporcionará un array de cadenas con las bases de datos privadas asociadas al paquete de aplicación de este Contexto mientras que fileList() devuelve un array de cadenas con los ficheros privados asociados al paquete de aplicación de este Contexto.
  4. Borrar la base de datos y el fichero asociados : El Contexto nos proporciona los métodos: deleteDatabase(String name) para borrar la Base de Datos SQLite asociada al paquete de aplicación de este Contexto y deleteFile(String name) para borrar el fichero privado dado asociado al paquete de aplicación de este Contexto.
    6.Obtención del Contexto de la Aplicación : La función getApplicationContext() de Context nos devolverá el objeto global único de la aplicación del proceso actual.
    7.Obtención de información de la aplicación : A través de getApplicationInfo() podemos obtener la información completa de la aplicación del paquete del Contexto actual.

Ejemplos de actividades rápidas

1. Cómo iniciar una Actividad

Para iniciar una actividad se necesita un objeto Intent. Vamos a crear un método que pueda iniciar por nosotros una actividad. Este método tomará un objeto contexto así como el nombre de la clase de la actividad objetivo, es decir, la actividad que queremos abrir.

    void start(Context c, Class e){
        Intent i = new Intent(,e);
        c.startActivity(i);
        //a.finish();
    }
2. Cómo terminar una actividad

Para terminar una actividad utilizamos el método finish().

    void killIntent(Context c){
        Intent i = new Intent(c,MainActivity.class);
        c.startActivity(i);
        c.finish();
    }
3. Cómo determinar si una actividad está en primer plano

Este método de ejemplo puede determinar por nosotros si una actividad está en primer plano o no. Devuelve un valor booleano basado en el resultado.

    public static boolean isForeground(Context context, String className) {
        if (context == null || TextUtils.isEmpty(className)) {
            returnfalse;
        }
        ActivityManager am = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
        List<ActivityManager.RunningTaskInfo> list = am.getRunningTasks(1);
        if (list != null && list.size() > 0) {
            ComponentName cpn = list.get(0).topActivity;
            if (className.equals(cpn.getClassName())) {
                return true;
            }
        }
        returnfalse;
    }

    public static boolean isForeground(Activity activity) {
        return isForeground(activity, activity.getClass().getName());
    }
4. Cómo manejar la retroalimentación

Digamos que quieres manejar adecuadamente el backpress en el sentido de que tal vez quieras mostrar al usuario un diálogo de alerta antes de salir de la actividad actual. En ese caso creas un método handleBackPress().

    public void handleBackPress() {
        mExitDialog = true;
        AlertDialog.Builder builder = new AlertDialog.Builder(getActivity(), R.style
                .AlertDialogStyle);
        builder.setTitle(R.string.leave_chat)
                .setMessage(R.string.leave_chat_desc)
                .setCancelable(false)
                .setNegativeButton(R.string.cancel,
                        new DialogInterface.OnClickListener() {
                            public void onClick(DialogInterface dialog, int id) {
                                mExitDialog = false;
                                dialog.cancel();
                            }
                        })
                .setPositiveButton(R.string.ok, new DialogInterface.OnClickListener() {
                    @Override
                    public void onClick(DialogInterface dialogInterface, int i) {
                        //showSaveHistoryDialog();
                    }
                });
        AlertDialog alert = builder.create();
        alert.show();
        alert.getWindow().setBackgroundDrawable(new ColorDrawable(getResources().getColor(R.color
                .black14)));
    }

En el caso anterior estamos mostrando un diálogo de alerta al usuario cuando hace clic en el botón de retroceso.

Android AppCompatActivity

La AppCompatActivity es una clase que actúa como la superclase para las actividades que quieren aprovechar las características de la barra de acción de la biblioteca de soporte.

Los requisitos para utilizar la android.support.v7.app.ActionBar dentro de tu actividad son

  1. Estar ejecutando API nivel 7 o superior.
  2. Entonces extender esta clase.
  3. Establezca su tema de actividad a android.support.v7.appcompat.R.style#Theme_AppCompat Theme.AppCompat o un tema similar.

Los temas se establecen en el AndroidManifest.xml por ejemplo

<activity
      android_name=".MainActivity"
      android_label="@string/app_name"
      android_theme="@style/AppTheme.NoActionBar">....</activity>

AppCompatActivity se define dentro del paquete android.support.v7.app:

package android.support.v7.app;

Deriva de android.support.v4.app.FragmentActivity:

public class AppCompatActivity extends FragmentActivity{}

E implementa varias interfaces:

public class AppCompatActivity extends FragmentActivity implements AppCompatCallback,TaskStackBuilder.SupportParentable, ActionBarDrawerToggle.DelegateProvider {}

Este es un ejemplo de una clase que deriva de AppCompatActivity:

import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
}

Configuración del tema AppCompatActivity.

El tema AppCompatActivity al igual que otros temas de actividad se puede establecer ya sea a través de androidmanifest

<activity
      android_name=".MainActivity"
      android_label="@string/app_name"
      android_theme="@style/AppTheme.NoActionBar">....</activity>

o programáticamente a través del método setTheme():

public void setTheme(@StyleRes final int resid) {}

Podemos crear un tema material personalizado para ser utilizado por AppCompatActivity:

<resources>

    <!-- Base application theme. -->
    <style name="AppTheme" parent="Theme.AppCompat.Light.DarkActionBar">
        <!-- Customize your theme here. -->
        <item name="colorPrimary">@color/colorPrimary</item>
        <item name="colorPrimaryDark">@color/colorPrimaryDark</item>
        <item name="colorAccent">@color/colorAccent</item>
    </style>

</resources>

Luego también podemos establecer ese tema globalmente a toda la aplicación de esta manera usando el atributo android:theme="...":

<application
        android_allowBackup="true"
        android_icon="@mipmap/ic_launcher"
        android_label="@string/app_name"
        android_roundIcon="@mipmap/ic_launcher_round"
        android_supportsRtl="true"
        android_theme="@style/AppTheme">
        <activity android_name=".MainActivity">

        </activity>
    </application>

Recuperación de la barra de acción AppCompatActivity.

AppCompatActivity nos da un método para recuperar una referencia a su barra de acciones:

public ActionBar getSupportActionBar(){}

Si no tiene una entonces se devuelve null.

Usando ToolBar como ActionBar en AppCompatActivity

Podemos utilizar android.support.v7.widget.Toolbar en lugar de una barra de acción. Las barras de herramientas tienen la ventaja de la flexibilidad en el uso y las personalizaciones.

Las ActionBars son normalmente parte de la decoración de la ventana opaca de la Activity. Por lo tanto son controladas por el framework.

Las barras de herramientas, por otro lado, pueden ser usadas dentro del diseño de su aplicación. Por lo tanto son flexibles.

Digamos que tenemos una barra de herramientas definida como sigue:

...
<android.support.v7.widget.Toolbar
            android_id="@+id/toolbar"
            android_layout_width="match_parent"
            android_layout_height="?attr/actionBarSize"
            android_background="?attr/colorPrimary"
            app_popupTheme="@style/AppTheme.PopupOverlay" />
...

dentro de nuestro activity_main.xml.

Podemos usarla como barra de acción usando la función setSupportActionBar() donde pasamos la referencia toolbar como parámetro.

public void setSupportActionBar(@Nullable Toolbar toolbar) {}

Ejemplo:

Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
setSupportActionBar(toolbar);

Para borrarla se pasa null.

Android Studio - Creación de un proyecto de actividad vacío

Cómo crear una actividad vacía en Android Studio

Cómo crear un proyecto en android studio con la plantilla Empty Activity. Vemos cómo usar Android studio para crear una actividad vacía.

Empty Activity es sólo una plantilla para el desarrollo de android. Es la plantilla más sencilla para empezar ya que nos genera un único archivo java y un único archivo xml de layout.

Este es el proceso.

  1. Primero crea un proyecto vacío en android studio. Ve a Archivo --> Nuevo proyecto.
  2. Escribe el nombre de la aplicación y elige el nombre de la empresa.
  3. Elige el SDK mínimo.
  4. Elija Actividad vacía.
    1. Hacer clic en Finish.

Esto nos generará un proyecto con lo siguiente:

No.
1. activity_main.xml XML Layout Se inflará en la vista MainActivity.Aquí añades tus vistas y widgets.
2. MainActivity.java Clase Su actividad de Lanzamiento

La actividad se registrará automáticamente en el android_manifest.xml. Las actividades de Android son componentes y normalmente necesitan ser registradas como un componente de la aplicación.
Si has creado la tuya manualmente entonces regístrala dentro de la <aplicación>...<aplicación> como sigue, reemplazando la MainActivity con el nombre de tu actividad:

        <activity android_name=".MainActivity">
            <intent-filter>
                <action android_name="android.intent.action.MAIN" />
                <category android_name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>

Puedes ver que una acción y una categoría se especifican como filtros de intención. La categoría hace que nuestra MainActivity sea una actividad lanzadora. Las actividades de lanzamiento se ejecutan primero cuando la aplicación androide se ejecuta.

Android Studio - Creando un Proyecto de Actividad Básica

Cómo crear un proyecto en android studio con una plantilla de actividad básica.

Este es un tutorial para principiantes para ver cómo crear un proyecto androide basado en la plantilla básica.

Este es el proceso:

  1. Primero cree un nuevo proyecto en android studio. Ir a Archivo --> Nuevo Proyecto.
  2. Escribe el nombre de la aplicación y elige el nombre de la empresa.
  3. Elige el SDK mínimo.
  4. Elija la actividad básica.
  5. Haga clic en Finalizar.

La actividad básica tendrá una barra de herramientas y un botón de acción flotante ya añadidos en el diseño

Normalmente se generan dos diseños con esta opción:

No. Tipo Descripción
1. Activity_main.xml: diseño XML: se infla en el diseño de la actividad principal, que suele contener un diseño de barra de herramientas y un botón de acción flotante.
2. Content_main.xml. XML Layout. Se incluirá en activity_main.xml.
3. 3. MainActivity.java: Clase de la actividad principal.

En este ejemplo he utilizado una actividad básica.

La actividad se registrará automáticamente en el android_manifest.xml. Las actividades de Android son componentes y normalmente necesitan ser registradas como un componente de la aplicación.

Si has creado la tuya manualmente entonces regístrala dentro de la <aplicación>...<aplicación> como sigue, sustituyendo el MainActivity por el nombre de tu actividad:


        <activity android_name=".MainActivity">

            <intent-filter>

                <action android_name="android.intent.action.MAIN" />

                <category android_name="android.intent.category.LAUNCHER" />

            </intent-filter>

        </activity>

Puedes ver que una acción y una categoría se especifican como filtros de intención. La categoría hace que nuestra MainActivity sea una actividad lanzadora. Las actividades de lanzamiento se ejecutan primero cuando se ejecuta la aplicación androide.

Ventaja de crear un proyecto de actividad básica

Usted puede elegir opcionalmente la actividad vacía sobre la actividad básica para este proyecto.

Sin embargo, la actividad básica tiene las siguientes ventajas:

No. Ventaja
1. Nos proporciona una barra de herramientas ya hecha que nos da las características de la barra de acción, pero fácilmente personalizable.
2. Nos proporciona un diseño de barra de acción que implementa los conceptos de barra de acción de material design.
3. Proporciona un FloatinActionButton que podemos utilizar fácilmente para iniciar acciones rápidas especialmente en ejemplos como estos.
4. Desacopla nuestras vistas de contenido y widgets personalizados de las características de la plantilla como la barra de herramientas.

Estructura del proyecto generada

AndroidStudio generará para ti un proyecto con configuraciones por defecto a través de un conjunto de archivos y directorios.

Aquí están los más importantes:

No. Archivo Responsabilidad mayor
1. build/ Un directorio que contiene los recursos que han sido compilados de la construcción de la aplicación y las clases generadas por las herramientas de android. Tal herramienta es el archivo R.java. El archivo R.java normalmente contiene las referencias a los recursos de la aplicación.
2. libs/ Para mantener las bibliotecas que utilizamos en nuestro proyecto.
3. Para mantener el código fuente de nuestra aplicación, esta es la carpeta principal con la que se trabaja.
4. Contiene nuestras clases java organizadas como paquetes.
5. Contiene nuestras carpetas de recursos del proyecto como sigue.
6. Contiene nuestros recursos dibujables.
7. Contiene nuestros recursos de diseño.
8. Contiene el código XML de nuestros recursos de menú.
9. Contiene el código XML de nuestros recursos de valores, que definen conjuntos de pares nombre-valor y pueden ser cadenas, estilos y colores.
10. 10. AndroidManifest.xml Este archivo se autogenera cuando creamos un proyecto androide y define la información básica que necesita el sistema androide como el nombre de la aplicación, el nombre del paquete, los permisos, las actividades, los intentos, etc.
11. 11. build.gradle Gradle Script utilizado para construir la aplicación androide.

Android Activities - Pasar primitivas de una actividad a otra

Vamos a ver cómo pasar tipos de datos primitivos de una actividad a otra. Pasamos:

  • Cadenas
  • Entero
  • Boolean(Vía CheckBox)

Primera actividad

Segunda Actividad

a una segunda actividad y mostrarlos en la segunda actividad.

Archivos Gradle

Añadiremos dependencias en el archivo build.gradle a nivel de la aplicación.

1. Build.gradle

Este es nuestro nivel de app en el archivo build.gradle:

    dependencies {
        implementation fileTree(dir: 'libs', include: ['*.jar'])
        testImplementation 'junit:junit:4.12'
        implementation 'com.android.support:appcompat-v7:24.2.1'
        implementation 'com.android.support:design:24.2.1'
    }

`

LAYOUT RESOURCES

Tenemos tres layouts xml;

  1. activity_main.xml
  2. content_main.xml
  3. activity_second.xml

1. activity_main.xml

  • El diseño de la plantilla para nuestra actividad principal.

    <?xml version="1.0" encoding="utf-8"?>
    <android.support.design.widget.CoordinatorLayout

        android_layout_width="match_parent"
        android_layout_height="match_parent"
        android_fitsSystemWindows="true"
        tools_context="com.tutorials.hp.primitivespassing.MainActivity">

        <android.support.design.widget.AppBarLayout
            android_layout_width="match_parent"
            android_layout_height="wrap_content"
            android_theme="@style/AppTheme.AppBarOverlay">

            <android.support.v7.widget.Toolbar
                android_id="@+id/toolbar"
                android_layout_width="match_parent"
                android_layout_height="?attr/actionBarSize"
                android_background="?attr/colorPrimary"
                app_popupTheme="@style/AppTheme.PopupOverlay" />

        </android.support.design.widget.AppBarLayout>

        <include layout="@layout/content_main" />

        <android.support.design.widget.FloatingActionButton
            android_id="@+id/fab"
            android_layout_width="wrap_content"
            android_layout_height="wrap_content"
            android_layout_gravity="bottom|end"
            android_layout_margin="@dimen/fab_margin"
            android_src="@android:drawable/ic_dialog_email" />

    </android.support.design.widget.CoordinatorLayout>

2. content_main.xml

  • Añadamos aquí nuestros edittexts y checkbox.

    <?xml version="1.0" encoding="utf-8"?>
    <RelativeLayout

        android_layout_width="match_parent"
        android_layout_height="match_parent"
        android_paddingBottom="@dimen/activity_vertical_margin"
        android_paddingLeft="@dimen/activity_horizontal_margin"
        android_paddingRight="@dimen/activity_horizontal_margin"
        android_paddingTop="@dimen/activity_vertical_margin"
        app_layout_behavior="@string/appbar_scrolling_view_behavior"
        tools_context="com.tutorials.hp.primitivespassing.MainActivity"
        tools_showIn="@layout/activity_main">

        <LinearLayout
            android_layout_width="match_parent"
            android_layout_height="wrap_content"
            android_orientation="vertical">

            <android.support.design.widget.TextInputEditText
                android_id="@+id/nameTxt"
                android_layout_width="match_parent"
                android_layout_height="wrap_content"
                android_enabled="true"
                android_focusable="true"
                android_hint="Name"
                android_textSize="25dp"
                android_textStyle="bold" />

            <android.support.design.widget.TextInputEditText
                android_id="@+id/txtID"
                android_layout_width="match_parent"
                android_layout_height="wrap_content"
                android_enabled="true"
                android_focusable="true"
                android_hint="ID"
                android_textSize="25dp"
                android_textStyle="bold" />

            <LinearLayout
                android_layout_width="match_parent"
                android_layout_height="wrap_content"
                android_orientation="horizontal"
                android_padding="5dp">

                <TextView
                    android_layout_width="250dp"
                    android_layout_height="wrap_content"
                    android_text="Technology Exists ??"
                    android_textSize="25dp"
                    android_textStyle="bold" />

                <CheckBox
                    android_id="@+id/techExists"
                    android_layout_width="wrap_content"
                    android_layout_height="wrap_content"
                    android_checked="true"
                    android_textSize="25dp" />
            </LinearLayout>
            <Button android_id="@+id/sendBtn"
                android_layout_width="wrap_content"
                android_layout_height="60dp"
                android_text="Send"
                android_clickable="true"
                android_padding="5dp"
                android_background="#009968"
                android_textColor="@android:color/white"
                android_textStyle="bold"
                android_textSize="20dp" />
        </LinearLayout>
    </RelativeLayout>

3. activity_second.xml

  • Aquí está el código para la segunda actividad.
  • Esta actividad recibirá los datos de la actividad principal y los mostrará aquí.

    <?xml version="1.0" encoding="utf-8"?>
    <RelativeLayout

        android_layout_width="match_parent"
        android_layout_height="match_parent"
        android_paddingBottom="@dimen/activity_vertical_margin"
        android_paddingLeft="@dimen/activity_horizontal_margin"
        android_paddingRight="@dimen/activity_horizontal_margin"
        android_paddingTop="@dimen/activity_vertical_margin"
        tools_context="com.tutorials.hp.primitivespassing.SecondActivity">

        <LinearLayout
            android_layout_width="match_parent"
            android_layout_height="wrap_content"
            android_orientation="vertical">

            <LinearLayout
                android_layout_width="match_parent"
                android_layout_height="wrap_content"
                android_orientation="horizontal"
                android_padding="5dp">

                <TextView
                    android_layout_width="250dp"
                    android_layout_height="wrap_content"
                    android_text="NAME"
                    android_textSize="25dp"
                    android_textStyle="bold" />

                <TextView
                    android_id="@+id/nameTxtSecond"
                    android_layout_width="match_parent"
                    android_layout_height="wrap_content"
                    android_text="value received"
                    android_textSize="25dp" />
            </LinearLayout>

            <LinearLayout
                android_layout_width="match_parent"
                android_layout_height="wrap_content"
                android_orientation="horizontal"
                android_padding="5dp">

                <TextView
                    android_layout_width="250dp"
                    android_layout_height="wrap_content"
                    android_text="ID"
                    android_textSize="25dp"
                    android_textStyle="bold" />

                <TextView
                    android_id="@+id/txtIDSecond"
                    android_layout_width="match_parent"
                    android_layout_height="wrap_content"
                    android_text="value received"
                    android_textSize="25dp" />
            </LinearLayout>

            <LinearLayout
                android_layout_width="match_parent"
                android_layout_height="wrap_content"
                android_orientation="horizontal"
                android_padding="5dp">

                <TextView
                    android_layout_width="250dp"
                    android_layout_height="wrap_content"
                    android_text="Technology Exists ??"
                    android_textSize="25dp"
                    android_textStyle="bold" />

                <CheckBox
                    android_id="@+id/techExistsSecond"
                    android_layout_width="wrap_content"
                    android_layout_height="wrap_content"
                    android_checked="true"
                    android_textSize="25dp" />
            </LinearLayout>
        </LinearLayout>
    </RelativeLayout>

CLASES JAVA

Tenemos dos clases o dos actividades:

  1. MainActivity.java
  2. SecondActivity.java

1. Clase MainActivity

  • Nuestra MainActivity.
  • Pasaremos los datos de esta actividad ti la segunda actividad.

    package com.tutorials.hp.primitivespassing;

    import android.content.Intent;
    import android.os.Bundle;
    import android.support.design.widget.FloatingActionButton;
    import android.support.design.widget.TextInputEditText;
    import android.support.v7.app.AppCompatActivity;
    import android.support.v7.widget.Toolbar;
    import android.view.View;
    import android.widget.Button;
    import android.widget.CheckBox;

    public class MainActivity extends AppCompatActivity {

        //DECLARE VIEWS
        private TextInputEditText txtName, txtID;
        private CheckBox chkTechnologyExists;
        private Button sendBtn;

        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
            Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
            setSupportActionBar(toolbar);

            this.initializeViews();

            FloatingActionButton fab = (FloatingActionButton) findViewById(R.id.fab);
            fab.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View view) {
                }
            });

            //WHEN SEND BTN IS CLICKED,SEND
            sendBtn.setOnClickListener(new View.OnClickListener() {
                @Override
                public void onClick(View view) {
                    sendData();
                }
            });
        }

        /*
        REFERENCE VIEWS WE ARE USING
         */
        private void initializeViews() {
            txtName = (TextInputEditText) findViewById(R.id.nameTxt);
            txtID = (TextInputEditText) findViewById(R.id.txtID);
            chkTechnologyExists = (CheckBox) findViewById(R.id.techExists);
            sendBtn = (Button) findViewById(R.id.sendBtn);

        }

        /*
        SEND DATA TO SECOND ACTIVITY
         */
        private void sendData() {
            //GET PRIMITIVE VALUES TO SEND
            String name = txtName.getText().toString();
            int id = Integer.parseInt(txtID.getText().toString());
            Boolean techExists = chkTechnologyExists.isChecked();

            //PACK THEM IN AN INTENT OBJECT
            Intent i = new Intent(this, SecondActivity.class);
            i.putExtra("NAME_KEY", name);
            i.putExtra("ID_KEY", id);
            i.putExtra("TECHEXISTS_KEY", techExists);

            //LETS LEAVE OUR TXTS CLEARED
            txtName.setText("");
            txtID.setText("");

            //START SECOND ACTIVITY
            this.startActivity(i);
        }
    }

2. Clase Second Activity

  • Nuestra segunda actividad.
  • Recibirá los datos de la actividad principal y los mostrará en textviews y checkbox.

    package com.tutorials.hp.primitivespassing;

    import android.support.design.widget.TextInputEditText;
    import android.support.v7.app.AppCompatActivity;
    import android.os.Bundle;
    import android.widget.CheckBox;
    import android.widget.Spinner;
    import android.widget.TextView;
    import android.widget.Toast;

    public class SecondActivity extends AppCompatActivity {

        //DECALRE SECOND ACTIVITY VIEWS
        TextView txtName2;
        TextView txtID2;
        CheckBox chkTechnologyExists2;

        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_second);

            //INITIALIZE THESE VIEWS
            txtName2 = (TextView) findViewById(R.id.nameTxtSecond);
            txtID2 = (TextView) findViewById(R.id.txtIDSecond);
            chkTechnologyExists2 = (CheckBox) findViewById(R.id.techExistsSecond);

            //RECEIVE DATA FROM MAIN ACTIVITY
            String name = getIntent().getStringExtra("NAME_KEY");
            int id = getIntent().getIntExtra("ID_KEY", 0);
            Boolean techExists = getIntent().getBooleanExtra("TECHEXISTS_KEY", false);

            //SHOW A TOAST
            Toast.makeText(SecondActivity.this, name, Toast.LENGTH_LONG).show();

            //SET THE DATA TO OUR LOCAL VIEWS
            txtName2.setText(name);
            txtID2.setText(String.valueOf(id));
            chkTechnologyExists2.setChecked(techExists);
        }
    }

Android ListActivity

Tutorial y ejemplos de Android ListActivity.

Una ListActivity es una actividad que muestra una lista de elementos mediante la vinculación a una fuente de datos como un array o un Cursor. ListActivity también nos expone manejadores de eventos cuando el usuario selecciona un elemento.

Esta es una clase que deriva de la clase Activity. ListActivity está pensada para ser usada cuando se planea usar un ListView. De hecho, alberga un objeto ListView que puede ser vinculado a diferentes fuentes de datos, normalmente un array o un Cursor que contiene los resultados de la consulta.

Definición de la API ListActivity

ListActivity, como hemos dicho deriva de la clase Activity.

public class ListActivity extends Activity

Esta es su jerarquía de herencia:

java.lang.Object
   ↳    android.content.Context
       ↳    android.content.ContextWrapper
           ↳    android.view.ContextThemeWrapper
               ↳    android.app.Activity
                   ↳    android.app.ListActivity

Subclases de ListActivity

Estas son las clases que derivan de ListActivity:

1. LauncherActivity Una clase que muestra una lista de todas las actividades que se pueden realizar para una determinada intención. Se lanza cuando se hace clic.
2. PreferenceActivity La clase base para que una actividad muestre una jerarquía de preferencias al usuario.

Diseño de Pantalla

ListActivity tiene un diseño por defecto que consiste en una única lista a pantalla completa en el centro de la pantalla. Sin embargo, si lo desea, puede personalizar el diseño de la pantalla estableciendo su propio diseño de vista con setContentView() en onCreate(). Para ello, tu propia vista DEBE contener un objeto ListView con el id code>&quot;@android:id/list&quot;</code (o list si está en código)

Opcionalmente, tu vista personalizada puede contener otro objeto de vista de cualquier tipo para mostrar cuando la vista de lista esté vacía. Este notificador de "lista vacía" debe tener un id "android:id/empty". Ten en cuenta que cuando una vista vacía está presente, la vista de lista se ocultará cuando no haya datos que mostrar.

El siguiente código demuestra un (feo) diseño de pantalla personalizado. Tiene una lista con fondo verde, y un mensaje alternativo rojo de "no hay datos".

 <?xml version="1.0" encoding="utf-8"?>
 <LinearLayout
         android_orientation="vertical"
         android_layout_width="match_parent"
         android_layout_height="match_parent"
         android_paddingLeft="8dp"
         android_paddingRight="8dp">

     <ListView android_id="@android:id/list"
               android_layout_width="match_parent"
               android_layout_height="match_parent"
               android_background="#00FF00"
               android_layout_weight="1"
               android_drawSelectorOnTop="false"/>

     <TextView android_id="@android:id/empty"
               android_layout_width="match_parent"
               android_layout_height="match_parent"
               android_background="#FF0000"
               android_text="No data"/>
 </LinearLayout>

Top Android ListActivity Ejemplos

En esta sección veremos varios ejemplos completos de ListActivity.

1. ListActivity y OnItemClick

En este primer ejemplo veremos cómo rellenar una ListActivity con datos de un simple array. Luego veremos cómo manejar los eventos OnItemClick.

API's que utilizamos

Empecemos por definir las distintas APIs que utilizaremos en este ejemplo.

(a). ListActivity

Esta clase pertenece a android.app. Es una actividad que muestra una lista de elementos vinculándose a una fuente de datos como un array o un Cursor, y expone manejadores de eventos cuando el usuario selecciona un elemento.

(b). Bundle

Bundle es un mapeo de valores String a varios tipos Parcelable.

Lee sobre bundle aquí.

(c). Vista

Esta es una clase que representa el bloque de construcción básico para los componentes de la interfaz de usuario. Una Vista ocupa un área rectangular en la pantalla y es responsable de dibujar y manejar eventos.

Lee sobre las vistas aquí.

(c). ArrayAdapter

Un arrayadapter es un BaseAdapter concreto que está respaldado por un array de objetos arbitrarios. Por defecto, esta clase espera que el id de recurso proporcionado haga referencia a un único TextView.

Lee sobre ArrayAdapter aquí.

(d). ListView

Un ListView es una vista que muestra elementos en una lista que se desplaza verticalmente. Los elementos provienen del ListAdapter asociado a esta vista.

Lee sobre ListView aquí.

MyListActivity.java

import android.app.ListActivity;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.ArrayAdapter;
import android.widget.ListView;
import android.widget.Toast;

public class MyListActivity extends ListActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //setContentView(R.layout.activity_my_list);

        String[] values = new String[] { "Android", "iPhone", "WindowsMobile",
                "Blackberry", "WebOS", "Ubuntu", "Windows7", "Max OS X",
                "Linux", "OS/2" };
        ArrayAdapter<String> adapter = new ArrayAdapter<String>(this,android.R.layout.simple_list_item_1,values);
        setListAdapter(adapter);

    }
    @Override
    protected  void  onListItemClick(ListView l, View v, int position, long id){

        String item = (String) getListAdapter().getItem(position);
        Toast.makeText(this, item + " selected", Toast.LENGTH_LONG).show();

    }
}

activity_my_list.xml

<?xml version="1.0" encoding="utf-8"?>
<android.support.constraint.ConstraintLayout

    android_layout_width="match_parent"
    android_layout_height="match_parent"
    tools_context="com.codekul.myandroidlistactivity.MyListActivity">

    <TextView
        android_layout_width="wrap_content"
        android_layout_height="wrap_content"
        android_text="Hello World!"
        app_layout_constraintBottom_toBottomOf="parent"
        app_layout_constraintLeft_toLeftOf="parent"
        app_layout_constraintRight_toRightOf="parent"
        app_layout_constraintTop_toTopOf="parent" />

</android.support.constraint.ConstraintLayout>

Descargar

No.
1. GitHub (https://github.com/1sumit/ListActivity/tree/master/app)
2. GitHub Creador original: @1sumit

2. Ejemplo de ListActivity y ArrayAdapter

Vamos a rellenar una ListActivity con CatNames y luego manejar los eventos Click. No necesitamos un diseño para esto.

MainActivity.java

import android.app.ListActivity;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.ArrayAdapter;
import android.widget.ListView;

public class MainActivity extends ListActivity {

    final String[] catNamesArray = new String[] { "Рыжик", "Барсик", "Мурзик",
            "Мурка", "Васька", "Томасина", "Бобик", "Кристина", "Пушок",
            "Дымка", "Кузя", "Китти", "Барбос", "Масяня", "Симба" };
    private ArrayAdapter<String> mAdapter;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        mAdapter = new ArrayAdapter<>(this,
                android.R.layout.simple_list_item_1, catNamesArray);
        setListAdapter(mAdapter);

    }

    @Override
    protected void onListItemClick(ListView l, View v, int position, long id) {
        super.onListItemClick(l, v, position, id);
    }
}

Descargar

No. Ubicación Enlace
1. GitHub 2. [Descarga] (https://github.com/disiol/ListActivity/tree/master/sample/archive/master.zip)
1. GitHub: Examinar 2. GitHub: Examinar
2. GitHub Creador original: @disiol

3. ListActivity con AsyncTask

MainActivity.java


import android.app.ListActivity;
import android.content.Intent;
import android.os.AsyncTask;
import android.view.View;
import android.widget.Adapter;
import android.widget.ListView;

import java.util.List;

public final class AppPickerActivity extends ListActivity {

  private AsyncTask<Object,Object,List<AppInfo>> backgroundTask;

  @Override
  protected void onResume() {
    super.onResume();
    backgroundTask = new LoadPackagesAsyncTask(this);
    backgroundTask.executeOnExecutor(AsyncTask.THREAD_POOL_EXECUTOR);
  }

  @Override
  protected void onPause() {
    AsyncTask<?,?,?> task = backgroundTask;
    if (task != null) {
      task.cancel(true);
      backgroundTask = null;
    }
    super.onPause();
  }

  @Override
  protected void onListItemClick(ListView l, View view, int position, long id) {
    Adapter adapter = getListAdapter();
    if (position >= 0 && position < adapter.getCount()) {
      String packageName = ((AppInfo) adapter.getItem(position)).getPackageName();
      Intent intent = new Intent();
      intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_WHEN_TASK_RESET);
      intent.putExtra("url", "market://details?id=" + packageName);
      setResult(RESULT_OK, intent);
    } else {
      setResult(RESULT_CANCELED);
    }
    finish();
  }

}

4. ListActivity - Haga clic para abrir una nueva actividad

Este es un ejemplo de ListActivity donde vemos cómo mostrar elementos en una ListActivity. Luego, cuando el usuario hace clic en un solo elemento, abrimos una nueva actividad.

MainActivity.java

import android.app.Activity;
import android.app.ListActivity;
import android.content.Intent;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;
import android.view.View;
import android.widget.ArrayAdapter;
import android.widget.ListView;

public class MainActivity extends ListActivity {

    String[] names;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        //setContentView(R.layout.activity_main);

        names = getResources().getStringArray(R.array.friends);
        setListAdapter(new ArrayAdapter<String>(this, R.layout.friend_item, names));

    }

    @Override
    protected void onListItemClick(ListView l, View v, int position, long id) {
        super.onListItemClick(l, v, position, id);

        Intent in = new Intent(this, SecondActivity.class);

        in.putExtra("message", getString(R.string.show_greetings)+ " " + names[(int) id] + "!" );

        startActivity(in);

    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.menu_main, menu);

        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        // Handle action bar item clicks here. The action bar will
        // automatically handle clicks on the Home/Up button, so long
        // as you specify a parent activity in AndroidManifest.xml.
        int id = item.getItemId();

        //noinspection SimplifiableIfStatement
        if (id == R.id.action_settings) {
            return true;
        }

        return super.onOptionsItemSelected(item);
    }
}

SecondActivity.java

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.view.Menu;
import android.view.MenuItem;
import android.widget.TextView;

public class SecondActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_second);

        Intent in = getIntent();

        TextView txtName = (TextView) findViewById(R.id.txtGreetingName);
        txtName.setText(in.getStringExtra("message"));
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.menu_second, menu);
        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        // Handle action bar item clicks here. The action bar will
        // automatically handle clicks on the Home/Up button, so long
        // as you specify a parent activity in AndroidManifest.xml.
        int id = item.getItemId();

        //noinspection SimplifiableIfStatement
        if (id == R.id.action_settings) {
            return true;
        }

        return super.onOptionsItemSelected(item);
    }
}

activity_main.xml

<RelativeLayout

    android_layout_width="match_parent"
    android_layout_height="match_parent"
    android_paddingLeft="@dimen/activity_horizontal_margin"
    android_paddingRight="@dimen/activity_horizontal_margin"
    android_paddingTop="@dimen/activity_vertical_margin"
    android_paddingBottom="@dimen/activity_vertical_margin"
    tools_context=".MainActivity">

    <TextView android_text="@string/hello_world"
        android_layout_width="wrap_content"
        android_layout_height="wrap_content"
        android_textSize="24sp"
        android_layout_alignParentTop="true"
        android_layout_centerHorizontal="true"
        android_layout_marginTop="54dp" />

</RelativeLayout>

activity_second.xml

<RelativeLayout
     android_layout_width="match_parent"
    android_layout_height="match_parent" android_paddingLeft="@dimen/activity_horizontal_margin"
    android_paddingRight="@dimen/activity_horizontal_margin"
    android_paddingTop="@dimen/activity_vertical_margin"
    android_paddingBottom="@dimen/activity_vertical_margin"
    tools_context="com.example.paulorogerio.friendgreeting.SecondActivity">

    <TextView android_text="@string/hello_world"
        android_layout_width="wrap_content"
        android_layout_height="wrap_content"
        android_textSize="24sp"
        android_gravity="center_vertical|center_horizontal"
        android_id="@+id/txtGreetingName"
        android_layout_alignParentTop="true"
        android_layout_centerHorizontal="true"
        android_layout_marginTop="55dp" />

</RelativeLayout>

friend_item.xml

<?xml version="1.0" encoding="utf-8"?>
<TextView
    android_layout_width="match_parent" android_layout_height="match_parent"
    android_text="Friend Name"
    android_gravity="center_vertical|center_horizontal"
    android_textSize="24sp"
    android_padding="20dp">

</TextView>

Descargar

No. Ubicación Enlace
1. GitHub 2. [Descarga] (https://github.com/paulonova/FriendGreeting/tree/master/sample/archive/master.zip)
1. GitHub: Navegar 2. GitHub: Navegar
2. GitHub Creador original: @paulonova

5. ListActivity - Populate From XML stored in Assets

En este ejemplo veremos cómo utilizar XmlPullParser para analizar el documento XML almacenado en el directorio Assets de nuestra aplicación.
A continuación, mostraremos los resultados del XML analizado que comprenderá imágenes y texto en nuestra ListActivity.

Cargaremos desde nuestro documento XML el título, el enlace y las imágenes en nuestro ListView. Abriremos nuestro XML desde la carpeta assets en un InputStream. Luego tendremos un método ParseXML() que analizará nuestro XML utilizando el XmlPullParser.

La clase ImagesAdapter adaptará las imágenes y el texto del XML en un ListView personalizado. Utilizará el ArrayAdapter como clase adaptadora base.

ParseXML.java

Este ParseXML es la actividad principal.

package com.example.parsexml;

import java.io.IOException;
import java.io.InputStream;
import java.util.ArrayList;

import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

import org.xml.sax.InputSource;
import org.xml.sax.XMLReader;

import android.app.Activity;
import android.os.Bundle;
import android.view.Menu;
import android.widget.ListView;

public class ParseXML extends Activity {
    InputStream xmlStream;
    ArrayList<ItemData> list;
    XMLHandler handler;
    ListView listView;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_parse_xml);
        try {
            xmlStream = this.getAssets().open("ItemXML.xml");
            ParseXML();
            list = handler.getItemList();
            LoadImagesFromUrl();
            ImageAdapter adapter = new ImageAdapter(ParseXML.this, R.layout.imagelist, list);
            listView = (ListView) findViewById(R.id.imageList);
            listView.setAdapter(adapter);

        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }

    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        getMenuInflater().inflate(R.menu.activity_parse_xml, menu);
        return true;
    }

    public void ParseXML(){

        try {
            SAXParserFactory spf = SAXParserFactory.newInstance();
            SAXParser sp = spf.newSAXParser();
            XMLReader reader = sp.getXMLReader();
            handler = new XMLHandler();
            reader.setContentHandler(handler);
            reader.parse(new InputSource(xmlStream));
        } catch (Exception e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
    public void LoadImagesFromUrl(){
        for (int i=0; i<list.size();i++){
            LoadChart loader = new LoadChart(ParseXML.this, list.get(i).link);
            loader.execute();
            list.get(i).bitmap = loader.getBitmap();
        }
    }
}

ItemData.java

Esta es la clase modelo y representa un único elemento XML que compondrá nuestro elemento ListView. Tendremos título, enlace así como mapa de bits.

package com.example.parsexml;

import android.graphics.Bitmap;

public class ItemData {
    String title;
    String link;
    Bitmap bitmap;
    public Bitmap getBitmap() {
        return bitmap;
    }
    public void setBitmap(Bitmap bitmap) {
        this.bitmap = bitmap;
    }
    public String getTitle() {
        return title;
    }
    public void setTitle(String title) {
        this.title = title;
    }
    public String getLink() {
        return link;
    }
    public void setLink(String link) {
        this.link = link;
    }

}

ImageAdapter.java

Esta es la clase adaptadora personalizada, derivada del ArrayAdapter. Utiliza el patrón ViewHolder para albergar las vistas a reciclar. Ese ViewHolder es una simple clase para mantener los widgets TextView e ImageView para su reciclaje, en lugar de que se inflen cada vez que se llama al método getView().

package com.example.parsexml;

import java.util.List;

import android.content.Context;
import android.view.LayoutInflater;
import android.view.View;
import android.view.ViewGroup;
import android.widget.ArrayAdapter;
import android.widget.ImageView;
import android.widget.TextView;

public class ImageAdapter extends ArrayAdapter{
    ViewHolder holder;
    Context ctx;
    List<ItemData> list;
    LoadChart loader;
    public ImageAdapter(Context context, int textViewResourceId,
            List<ItemData> objects) {
        super(context, textViewResourceId, objects);
        ctx = context;
        list = objects;

        // TODO Auto-generated constructor stub
    }
    private class ViewHolder{
        TextView titleView;
        ImageView img;
    }
    @Override
    public View getView(int position, View convertView, ViewGroup parent) {
        // TODO Auto-generated method stub
        if(convertView == null){
            LayoutInflater inflater = (LayoutInflater) ctx.getSystemService(ctx.LAYOUT_INFLATER_SERVICE);
            convertView = inflater.inflate(R.layout.imagelist, null);
            holder = new ViewHolder();
            holder.img = (ImageView) convertView.findViewById(R.id.linkimage);
            holder.titleView = (TextView) convertView.findViewById(R.id.title);

            convertView.setTag(holder);

        }
        else{
            holder = (ViewHolder) convertView.getTag();
        }
        holder.titleView.setText(list.get(position).title);
        loader = new LoadChart(ctx, holder.img, list.get(position).link);
        loader.execute();

        return convertView;

    }

}

XMLHandler.java

Esta clase derivará de la clase org.xml.sax.helpers.DefaultHandler. DefaultHandler es la clase base predeterminada para los controladores de eventos SAX2. En esta clase anulamos varios métodos como startElement (), endElement () y characters ().

<! - 45 ->

LoadChart.java

Esta clase se derivará de la clase asynctask abstracta. Por lo tanto, esto nos permite cargar nuestro XML en un hilo separado.

<! - 46 ->

Descargar

No. Ubicacion Enlace
1. GitHub Descarga
2. GitHub [Examinar] (https://github.com/bansal2211/ParseXML)
2. GitHub [Creador original: @ bansal2211] (https://github.com/bansal2211)

Android ListActivity: con imágenes, texto y OnItemClick ArrayAdapter

  • Android ListActivity Imágenes Texto *

Este es un tutorial de vista de lista personalizado de Android. Cómo mostrar imágenes y texto en una vista de lista. Estamos usando arrayadapter como nuestro adaptador de elección. También vemos cómo manejar los clics de elementos de vista de lista personalizados.

Sección 1: Clase CustomAdapter

Esta es nuestra clase CustomAdapter. Subclase android.widget.ArrayAdapter. Lea más sobre ArrayAdapter aquí.

Es nuestra clase de Adaptador.

<! - 47 ->

Sección 2: MainActivity

Nuestra principal actividad. Subclasificará la clase ListActivity.

<! - 48 ->

Sección 3: Diseños

ActivityMain.xml

Maquetación de nuestra actividad principal.

<! - 49 ->

Buen día.

Categorizado en:

Etiquetado en: