Android Tutorial
Empezando con Android

Observaciones

Versiones

Configuración de Android Studio

Android Studio es el IDE de desarrollo de Android que es oficialmente compatible y recomendado por Google. Android Studio incluye el Android SDK Manager , que es una herramienta para descargar los componentes de Android SDK necesarios para comenzar a desarrollar aplicaciones.

Instalar Android Studio y Android SDK herramientas del Android SDK :

1. Descarga e instala Android Studio .
2. Descargue las herramientas SDK Tools y SDK Platform más recientes abriendo Android Studio y luego siga las instrucciones de actualización de las herramientas SDK de Android . Debe instalar los últimos paquetes estables disponibles.

Si necesita trabajar en proyectos antiguos que se crearon con versiones anteriores del SDK, es posible que deba descargar estas versiones también.

Desde Android Studio 2.2, una copia del último OpenJDK viene con la instalación y es el JDK (Java Development Kit) recomendado para todos los proyectos de Android Studio. Esto elimina el requisito de tener instalado el paquete JDK de Oracle. Para utilizar el SDK incluido, proceda de la siguiente manera;

1. Abra su proyecto en Android Studio y seleccione Archivo> Estructura del proyecto en la barra de menú.
2. En la página de ubicación del SDK y en la ubicación de JDK , marque la casilla de verificación Usar JDK incorporado .
3. Haga clic en Aceptar .

Configurar Android Studio

Android Studio proporciona acceso a dos archivos de configuración a través del menú Ayuda :

• studio.vmoptions : Personalice las opciones para la Máquina Virtual Java (JVM) de Studio, como el tamaño del almacenamiento dinámico y el tamaño del caché. Tenga en cuenta que en las máquinas con Linux, este archivo puede llamarse studio64.vmoptions , dependiendo de su versión de Android Studio.
• idea.properties : Personalice las propiedades de Android Studio, como la ruta de la carpeta de complementos o el tamaño máximo de archivo admitido.

Cambiar / agregar tema

Puedes cambiarlo como prefieras. File->Settings->Editor->Colors & Fonts-> y seleccione un tema. También puede descargar nuevos temas desde http://color-themes.com/ Una vez que haya descargado el archivo .jar.zip , vaya a File -> Import Settings... y elegir el archivo descargado.

Compilando apps

Crea un nuevo proyecto o abre un proyecto existente en Android Studio y presiona el botón verde Play en la barra de herramientas superior para ejecutarlo. Si está en gris, debe esperar un segundo para permitir que Android Studio indexe correctamente algunos archivos, cuyo progreso se puede ver en la barra de estado inferior.

Si desea crear un proyecto desde el shell, asegúrese de tener un archivo local.properties , que Android Studio crea automáticamente. Si necesita crear el proyecto sin Android Studio, necesita una línea que comience con sdk.dir= seguida de la ruta a su instalación de SDK.

Abra un shell y vaya al directorio del proyecto. Ingrese ./gradlew aR y presione enter. aR es un acceso directo para assembleRelease , que descargará todas las dependencias por ti y creará la aplicación. El archivo final de APK estará en ProjectName/ModuleName/build/outputs/apk y se llamará ModuleName-release.apk .

Creando un Nuevo Proyecto

Configurar Android Studio

Comience por configurar Android Studio y luego ábralo. ¡Ahora, estás listo para hacer tu primera aplicación de Android!

Nota: esta guía se basa en Android Studio 2.2, pero el proceso en otras versiones es principalmente el mismo.

Configure su proyecto

Configuracion basica

Puedes comenzar un nuevo proyecto de dos maneras:

• Haga clic en Start a New Android Studio Project de Start a New Android Studio Project en la pantalla de bienvenida.
• Vaya a File → New Project si ya tiene un proyecto abierto.

A continuación, debe describir su solicitud completando algunos campos:

1. Nombre de la aplicación : este nombre se mostrará al usuario.

   Ejemplo: Hello World . Siempre puedes cambiarlo más tarde en el archivo AndroidManifest.xml .

2. Dominio de la empresa : este es el calificador para el nombre del paquete de su proyecto.

   Ejemplo: stackoverflow.com .

3. Nombre del paquete (también conocido como applicationId ): este es el nombre completo del paquete del proyecto.

   Debe seguir la Notación de nombre de dominio inversa (también conocido como DNS inverso ): Dominio de nivel superior . Dominio de la empresa . [ Segmento de la empresa . ] Nombre de la aplicación .

   Ejemplo: com.stackoverflow.android.helloworld o com.stackoverflow.helloworld . Siempre puede cambiar su ID de aplicación anulando en su archivo de gradle .

No use el prefijo predeterminado "com.example" a menos que no tenga la intención de enviar su solicitud a Google Play Store. El nombre del paquete será su aplicación únicaId en Google Play.

4. Ubicación del proyecto : este es el directorio donde se almacenará su proyecto.

Seleccione los factores de formulario y el nivel de API

La siguiente ventana le permite seleccionar los factores de forma compatibles con su aplicación, como teléfono, tableta, TV, Wear y Google Glass. Los factores de forma seleccionados se convierten en los módulos de la aplicación dentro del proyecto. Para cada factor de forma, también puede seleccionar el Nivel de API para esa aplicación. Para obtener más información, haga clic en Ayudarme a elegir

Gráfico de las distribuciones actuales de la versión de Android, que se muestra al hacer clic en Ayudarme a elegir.

La ventana de Distribución de la plataforma de Android muestra la distribución de dispositivos móviles que ejecutan cada versión de Android, como se muestra en la Figura 2. Haga clic en un nivel de API para ver una lista de características introducidas en la versión correspondiente de Android. Esto le ayuda a elegir el nivel de API mínimo que tiene todas las funciones que sus aplicaciones necesitan, para que pueda alcanzar la mayor cantidad de dispositivos posible. Luego haga clic en Aceptar .

Ahora, elija qué plataformas y versión de Android SDK será compatible con la aplicación.

Por ahora, seleccione solo Teléfono y Tableta .

El SDK mínimo es el límite inferior para su aplicación. Es una de las señales que utiliza Google Play Store para determinar en qué dispositivos se puede instalar una aplicación. Por ejemplo, la aplicación Stack Exchange es compatible con Android 4.1+.

Android Studio le dirá (aproximadamente) qué porcentaje de dispositivos será compatible dado el SDK mínimo especificado.

Los niveles de API más bajos se dirigen a más dispositivos, pero tienen menos funciones disponibles.

Al decidir sobre el SDK mínimo , debe considerar las estadísticas de Dashboards , que le brindarán información sobre la versión de los dispositivos que visitaron la tienda de Google Play a nivel mundial durante la última semana.

Desde: Dashboards en el sitio web del desarrollador de Android.

Añadir una actividad

Ahora vamos a seleccionar una actividad por defecto para nuestra aplicación. En Android, una Activity es una pantalla única que se presentará al usuario. Una aplicación puede albergar múltiples actividades y navegar entre ellas. Para este ejemplo, elija Empty Activity y haga clic en siguiente.

Aquí, si lo desea, puede cambiar el nombre de la actividad y el diseño. Una buena práctica es mantener la Activity como un sufijo para el nombre de la actividad, y la activity_ como un prefijo para el nombre del diseño. Si dejamos esto como predeterminado, Android Studio generará una actividad para nosotros llamada MainActivity y un archivo de diseño llamado activity_main . Ahora haga clic en Finish .

Android Studio creará y configurará nuestro proyecto, lo que puede llevar algún tiempo dependiendo del sistema.

Inspeccionando el proyecto

Para comprender cómo funciona Android, echemos un vistazo a algunos de los archivos que se crearon para nosotros.

En el panel izquierdo de Android Studio, podemos ver la estructura de nuestra aplicación de Android .

Primero, abramos AndroidManifest.xml haciendo doble clic en él. El archivo de manifiesto de Android describe parte de la información básica sobre una aplicación de Android. Contiene la declaración de nuestras actividades, así como algunos componentes más avanzados.

Si una aplicación necesita acceso a una característica protegida por un permiso, debe declarar que requiere ese permiso con un elemento <uses-permission> en el manifiesto. Luego, cuando la aplicación se instala en el dispositivo, el instalador determina si otorga o no el permiso solicitado mediante la verificación de las autoridades que firmaron los certificados de la aplicación y, en algunos casos, le pregunta al usuario. Una aplicación también puede proteger sus propios componentes (actividades, servicios, receptores de difusión y proveedores de contenido) con permisos. Puede emplear cualquiera de los permisos definidos por Android (listados en android.Manifest.permission) o declarados por otras aplicaciones. O puede definir su propia cuenta.

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.stackoverflow.helloworld">

    <application
        android:allowBackup="true"
        android:icon="@mipmap/ic_launcher"
        android:label="@string/app_name"
        android:supportsRtl="true"
        android:theme="@style/AppTheme">
        <activity android:name=".MainActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>
</manifest>

A continuación, abramos activity_main.xml que se encuentra en app/src/main/res/layout/ . Este archivo contiene declaraciones para los componentes visuales de nuestra MainActivity. Verás diseñador visual. Esto le permite arrastrar y soltar elementos en el diseño seleccionado.

También puede cambiar al diseñador de diseño xml haciendo clic en "Texto" en la parte inferior de Android Studio, como se ve aquí:

<?xml version="1.0" encoding="utf-8"?>
<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    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.stackexchange.docs.helloworld.MainActivity">

    <TextView
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Hello World!" />
</RelativeLayout>

Verá un widget llamado TextView dentro de este diseño, con la propiedad de android:text establecida en "¡Hola mundo!". Este es un bloque de texto que se mostrará al usuario cuando ejecute la aplicación.

Puedes leer más sobre Diseños y atributos .

A continuación, echemos un vistazo a MainActivity . Este es el código Java que se ha generado para MainActivity .

public class MainActivity extends AppCompatActivity {

    // The onCreate method is called when an Activity starts
    // This is where we will set up our layout
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        // setContentView sets the Activity's layout to a specified XML layout
        // In our case we are using the activity_main layout
        setContentView(R.layout.activity_main);
    }
}

Como se define en nuestro manifiesto de Android, MainActivity se iniciará de forma predeterminada cuando un usuario inicie la aplicación HelloWorld .

Por último, abra el archivo llamado build.gradle ubicado en app/ .
Android Studio utiliza el sistema de compilación Gradle para compilar y construir bibliotecas y aplicaciones de Android.

apply plugin: 'com.android.application'

android {
signingConfigs {
         applicationName {
             keyAlias 'applicationName'
             keyPassword 'password'
             storeFile file('../key/applicationName.jks')
             storePassword 'anotherPassword'
         }
     }
    compileSdkVersion 26
    buildToolsVersion "26.0.0"

    defaultConfig {
        applicationId "com.stackexchange.docs.helloworld"
        minSdkVersion 16
        targetSdkVersion 26
        versionCode 1
        versionName "1.0"
        signingConfig signingConfigs.applicationName
    }
    buildTypes {
        release {
            minifyEnabled false
            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
        }
    }
}

dependencies {
    compile fileTree(dir: 'libs', include: ['*.jar'])
    testCompile 'junit:junit:4.12'
    compile 'com.android.support:appcompat-v7:26.0.0'
}

Este archivo contiene información sobre la compilación y la versión de su aplicación, y también puede usarla para agregar dependencias a bibliotecas externas. Por ahora, no hagamos ningún cambio.

Es recomendable seleccionar siempre la última versión disponible para las dependencias:

• buildToolsVersion : 26.0.0
• com.android.support:appcompat-v7 : 26.0.0 (julio de 2017)
• base de fuego : 11.0.4 (agosto de 2017)

compileSdkVersion

compileSdkVersion es su forma de decirle a Gradle con qué versión del SDK de Android debe compilar su aplicación. El uso del nuevo SDK de Android es un requisito para usar cualquiera de las nuevas API agregadas en ese nivel.

Se debe enfatizar que cambiar su compileSdkVersion no cambia el comportamiento del tiempo de ejecución. Si bien pueden aparecer nuevos avisos / errores de compilación al cambiar su compileSdkVersion , su compileSdkVersion no está incluido en su APK: se utiliza únicamente en tiempo de compilación.

Por lo tanto, se recomienda encarecidamente que siempre compile con el último SDK. Obtendrá todos los beneficios de las nuevas comprobaciones de compilación en el código existente, evitará las API recientemente obsoletas y estará listo para usar nuevas API.

minSdkVersion

Si compileSdkVersion establece las API más nuevas disponibles para usted, minSdkVersion es el límite inferior para su aplicación. minSdkVersion es una de las señales que utiliza Google Play Store para determinar en qué dispositivos de un usuario se puede instalar una aplicación.

También juega un papel importante durante el desarrollo: de manera predeterminada, la pelusa se ejecuta contra su proyecto, advirtiéndole cuando use cualquier API por encima de minSdkVersion , lo que lo ayuda a evitar el problema de tiempo de ejecución al intentar llamar a una API que no existe. Verificar la versión del sistema en tiempo de ejecución es una técnica común cuando se usan API solo en las versiones más nuevas de la plataforma.

targetSdkVersion

targetSdkVersion es la principal forma en que Android proporciona compatibilidad hacia adelante al no aplicar cambios de comportamiento a menos que se actualice targetSdkVersion . Esto le permite utilizar nuevas API antes de trabajar a través de los cambios de comportamiento. La actualización para apuntar al último SDK debe ser una alta prioridad para cada aplicación. Eso no significa que tenga que usar cada nueva función introducida ni debería actualizar ciegamente su targetSdkVersion sin probar.

targetSDKVersion es la versión de Android que es el límite superior para las herramientas disponibles. Si targetSDKVersion es menor que 23, la aplicación no necesita solicitar permisos en tiempo de ejecución para una instancia, incluso si la aplicación se está ejecutando en API 23+. TargetSDKVersion no impide que las versiones de Android sobre la versión seleccionada de Android ejecuten la aplicación.

Puedes encontrar más información sobre el plugin Gradle:

• Un ejemplo basico
• Introducción al plugin Gradle para Android y la envoltura
• Introducción a la configuración de los métodos build.gradle y DSL.

Ejecutando la aplicación

Ahora, vamos a ejecutar nuestra aplicación HelloWorld. Puede ejecutar un dispositivo virtual de Android (que puede configurar utilizando AVD Manager en Android Studio, como se describe en el siguiente ejemplo) o conectar su propio dispositivo Android a través de un cable USB.

Configuración de un dispositivo Android

Para ejecutar una aplicación desde Android Studio en su dispositivo Android, debe habilitar la USB Debugging en las Developer Options en la configuración de su dispositivo.

Settings > Developer options > USB debugging

Si las Developer Options no están visibles en la configuración, navegue hasta About Phone y toque el Build Number siete veces. Esto permitirá que las Developer Options aparezcan en tu configuración.

Settings > About phone > Build number

También es posible que deba cambiar la configuración de build.gradle para construir en una versión que tenga su dispositivo.

Ejecutando desde Android Studio

Haga clic en el botón verde Run de la barra de herramientas en la parte superior de Android Studio. En la ventana que aparece, seleccione el dispositivo en el que desea ejecutar la aplicación (inicie un dispositivo virtual de Android si es necesario, o consulte Configuración de un AVD (dispositivo virtual de Android) si necesita configurar uno) y haga OK en OK .

En dispositivos con Android 4.4 (KitKat) y posiblemente superior, se mostrará una ventana emergente para autorizar la depuración USB. Haga OK en OK para aceptar.

La aplicación ahora se instalará y ejecutará en su dispositivo o emulador de Android.

Ubicación del archivo APK

Cuando prepara su aplicación para el lanzamiento, configura, crea y prueba una versión de lanzamiento de su aplicación. Las tareas de configuración son sencillas, e involucran tareas básicas de limpieza de código y modificación de código que ayudan a optimizar su aplicación. El proceso de compilación es similar al proceso de compilación de depuración y se puede hacer usando las herramientas JDK y Android SDK. Las tareas de prueba sirven como una verificación final, asegurando que su aplicación se desempeña como se espera en condiciones reales. Cuando haya terminado de preparar su aplicación para el lanzamiento, tiene un archivo APK firmado, que puede distribuir directamente a los usuarios o distribuir a través de un mercado de aplicaciones como Google Play.

Android Studio

Como en los ejemplos anteriores se usa Gradle, la ubicación del archivo APK generado es: <Your Project Location>/app/build/outputs/apk/app-debug.apk

IntelliJ

Si usted es un usuario de IntelliJ antes de cambiar a Studio y está importando su proyecto de IntelliJ directamente, entonces nada cambió. La ubicación de la salida será la misma en:

out/production/...

Nota: esto será desaprobado a veces alrededor de 1.0

Eclipse

Si está importando directamente el proyecto Eclipse de Android, ¡no lo haga! Tan pronto como tenga dependencias en su proyecto (archivos jar o proyectos de biblioteca), esto no funcionará y su proyecto no se configurará correctamente. Si no tiene dependencias, entonces el apk se encontraría en la misma ubicación que lo encontraría en Eclipse:

bin/...

Programación de Android sin un IDE.

Este es un ejemplo minimalista de Hello World que usa solo las herramientas más básicas de Android.

Requisitos y suposiciones

• Oracle JDK 1.7 o posterior
• Herramientas de Android SDK (solo las herramientas de línea de comandos )

Este ejemplo asume Linux. Puede que tenga que ajustar la sintaxis para su propia plataforma.

Configurando el SDK de Android

Después de desempacar la versión SDK:

1. Instalar paquetes adicionales utilizando el administrador de SDK. No use la android update sdk --no-ui como se indica en el android update sdk --no-ui Readme.txt; Descarga unos 30 GB de archivos innecesarios. En su lugar, use el administrador de SDK interactivo para android sdk para obtener los paquetes mínimos recomendados.

2. Agregue los siguientes directorios JDK y SDK a su PATH de ejecución. Esto es opcional, pero las instrucciones a continuación lo asumen.

   • JDK / bin
   • SDK / plataforma-herramientas
   • SDK / herramientas
   • SDK / build-tools / LATEST (como se instaló en el paso 1)

3. Crea un dispositivo virtual Android. Utilice el AVD Manager interactivo ( android avd AVD). Puede que tenga que juguetear un poco y buscar consejo; Las instrucciones en el sitio no siempre son útiles.

   (También puedes usar tu propio dispositivo)

4. Ejecuta el dispositivo:

   emulator -avd DEVICE
   

5. Si la pantalla del dispositivo parece estar bloqueada, desliza para desbloquearla.

   Deja que se ejecute mientras codificas la aplicación.

Codificando la aplicación

6. Cambiar a un directorio de trabajo vacío.

7. Haz el archivo fuente:

   mkdir --parents src/dom/domain
   touch src/dom/domain/SayingHello.java
   

   Contenido:

   package dom.domain;
   import android.widget.TextView;
   
   public final class SayingHello extends android.app.Activity
   {
       protected @Override void onCreate( final android.os.Bundle activityState )
       {
           super.onCreate( activityState );
           final TextView textV = new TextView( SayingHello.this );
           textV.setText( "Hello world" );
           setContentView( textV );
       }
   }
   

8. Añadir un manifiesto:

   touch AndroidManifest.xml
   

   Contenido:

   <?xml version='1.0'?>
   <manifest xmlns:a='http://schemas.android.com/apk/res/android'
    package='dom.domain' a:versionCode='0' a:versionName='0'>
       <application a:label='Saying hello'>
           <activity a:name='dom.domain.SayingHello'>
                <intent-filter>
                   <category a:name='android.intent.category.LAUNCHER'/>
                   <action a:name='android.intent.action.MAIN'/>
                   </intent-filter>
               </activity>
           </application>
       </manifest>
   

9. Haga un subdirectorio para los recursos declarados:

   mkdir res
   

   Déjalo vacío por ahora.

Construyendo el código

10. Generar la fuente para las declaraciones de recursos. Sustituya aquí la ruta correcta a su SDK y la API instalada contra la que construir (por ejemplo, "android-23"):

    aapt package -f \
      -I SDK/platforms/android-API/android.jar \
      -J src -m \
      -M AndroidManifest.xml -S res -v
    

    Las declaraciones de recursos (que se describen más adelante) son en realidad opcionales. Mientras tanto, la llamada anterior no hace nada si res / todavía está vacío.

11. Compile el código fuente en el bytecode de Java (.java → .class):

    javac \
      -bootclasspath SDK/platforms/android-API/android.jar \
      -classpath src -source 1.7 -target 1.7 \
      src/dom/domain/*.java
    

12. Traduzca el código de bytes de Java a Android (.class → .dex):

    Primero usando Jill (.class → .jayce):

    java -jar SDK/build-tools/LATEST/jill.jar \
      --output classes.jayce src
    

    Entonces Jack (.jayce → .dex):

    java -jar SDK/build-tools/LATEST/jack.jar \
      --import classes.jayce --output-dex .
    

    El código de bytes de Android solía llamarse "código ejecutable de Dalvik", y por lo tanto "dex".

    Podría reemplazar los pasos 11 y 12 con una sola llamada a Jack si lo desea; puede compilar directamente desde la fuente Java (.java → .dex). Pero hay ventajas de compilar con javac . Es una herramienta más conocida, mejor documentada y más ampliamente aplicable.

13. Empaquetar los archivos de recursos, incluido el manifiesto:

    aapt package -f \
      -F app.apkPart \
      -I SDK/platforms/android-API/android.jar \
      -M AndroidManifest.xml -S res -v
    

    Eso resulta en un archivo APK parcial (paquete de aplicación de Android).

14. Haz la APK completa usando la herramienta ApkBuilder :

    java -classpath SDK/tools/lib/sdklib.jar \
      com.android.sdklib.build.ApkBuilderMain \
      app.apkUnalign \
      -d -f classes.dex -v -z app.apkPart
    

    Advierte, "ESTA HERRAMIENTA ESTÁ DEPRECTA. Vea --help para obtener más información". Si --help falla con una ArrayIndexOutOfBoundsException , en su lugar no pase ningún argumento:

    java -classpath SDK/tools/lib/sdklib.jar \
      com.android.sdklib.build.ApkBuilderMain
    

    Explica que la CLI ( ApkBuilderMain ) está en desuso a favor de llamar directamente a la API de Java ( ApkBuilder ). (Si sabe cómo hacerlo desde la línea de comandos, actualice este ejemplo).

15. Optimizar la alineación de datos de la APK ( práctica recomendada ):

    zipalign -f -v 4 app.apkUnalign app.apk
    

Instalación y ejecución

16. Instala la aplicación en el dispositivo Android:

    adb install -r app.apk
    

17. Inicia la aplicación:

    adb shell am start -n dom.domain/.SayingHello
    

    Debería correr y saludar.

Eso es todo. Eso es lo que se necesita para saludar con las herramientas básicas de Android.

Declarar un recurso

Esta sección es opcional. No se requieren declaraciones de recursos para una aplicación simple "hello world". Si tampoco son necesarios para su aplicación, entonces podría simplificar un poco la compilación omitiendo el paso 10 y eliminando la referencia al directorio res / del paso 13.

De lo contrario, aquí hay un breve ejemplo de cómo declarar un recurso y cómo hacer referencia a él.

18. Agrega un archivo de recursos:

    mkdir res/values
    touch res/values/values.xml
    

    Contenido:

    <?xml version='1.0'?>
    <resources>
        <string name='appLabel'>Saying hello</string>
    </resources>
    

19. Referencia el recurso desde el manifiesto XML. Este es un estilo declarativo de referencia:

    <!-- <application a:label='Saying hello'> -->
         <application a:label='@string/appLabel'>
    

20. Referencia el mismo recurso desde la fuente de Java. Esta es una referencia imperativa:

    // v.setText( "Hello world" );
       v.setText( "This app is called "
         + getResources().getString( R.string.appLabel ));
    

21. Pruebe las modificaciones anteriores reconstruyendo, reinstalando y volviendo a ejecutar la aplicación (pasos 10-17).

    Debería reiniciarse y decir: "Esta aplicación se llama Decir hola".

Desinstalando la aplicación

adb uninstall dom.domain

Ver también

• Pregunta original - La pregunta original que motivó este ejemplo.
• ejemplo de trabajo : un script de compilación de trabajo que utiliza los comandos anteriores

Fundamentos de la aplicación

Las aplicaciones de Android están escritas en Java. Las herramientas de Android SDK compilan los archivos de código, datos y recursos en un APK (paquete de Android). En general, un archivo APK contiene todo el contenido de la aplicación.

Cada aplicación se ejecuta en su propia máquina virtual (VM) para que la aplicación pueda ejecutarse aislada de otras aplicaciones. El sistema Android funciona con el principio de privilegio mínimo. Cada aplicación solo tiene acceso a los componentes que requiere para hacer su trabajo, y no más. Sin embargo, hay formas para que una aplicación comparta datos con otras aplicaciones, como compartir la identificación de usuario de Linux entre aplicaciones, o las aplicaciones pueden solicitar permiso para acceder a datos de dispositivos como tarjetas SD, contactos, etc.

Componentes de la aplicación

Los componentes de la aplicación son los componentes básicos de una aplicación de Android. Cada componente desempeña un papel específico en una aplicación de Android que tiene un propósito distinto y tiene ciclos de vida distintos (el flujo de cómo y cuándo se crea y destruye el componente). Aquí están los cuatro tipos de componentes de la aplicación:

1. Actividades: una actividad representa una única pantalla con una interfaz de usuario (UI). Una aplicación de Android puede tener más de una actividad. (por ejemplo, una aplicación de correo electrónico puede tener una actividad para enumerar todos los correos electrónicos, otra para mostrar el contenido de cada correo electrónico y otra para redactar un nuevo correo electrónico). Todas las actividades en una Aplicación trabajan juntas para crear una experiencia de usuario (UX).
2. Servicios: un servicio se ejecuta en segundo plano para realizar operaciones de larga ejecución o para realizar un trabajo en procesos remotos. Un servicio no proporciona ninguna IU, se ejecuta solo en segundo plano con la entrada del usuario. (Por ejemplo, un servicio puede reproducir música en segundo plano mientras el usuario está en una aplicación diferente, o puede descargar datos de Internet sin bloquear la interacción del usuario con el dispositivo Android).
3. Proveedores de contenido: un proveedor de contenido administra los datos compartidos de la aplicación. Hay cuatro formas de almacenar datos en una aplicación: puede escribirse en un archivo y almacenarse en el sistema de archivos, insertarse o actualizarse en una base de datos SQLite, publicarse en la web o guardarse en cualquier otra ubicación de almacenamiento persistente a la que la aplicación pueda acceder. . A través de los proveedores de contenido, otras aplicaciones pueden consultar o incluso modificar los datos. (por ejemplo, el sistema Android proporciona un proveedor de contenido que administra la información de contacto del usuario para que cualquier aplicación que tenga permiso pueda consultar a los contactos). Los proveedores de contenido también se pueden usar para guardar los datos privados de la aplicación para una mejor integridad de los datos.
4. Receptores de transmisión: un receptor de transmisión responde a las transmisiones de anuncios de todo el sistema (p. Ej., Una transmisión que anuncia que la pantalla se ha apagado, que la batería está baja, etc.) o desde Aplicaciones (p. Ej., Para que otras aplicaciones sepan que se han detectado algunos datos). descargado al dispositivo y está disponible para su uso). Los receptores de transmisión no tienen interfaces de usuario, pero pueden mostrar notificaciones en la barra de estado para alertar al usuario. Por lo general, los receptores de difusión se utilizan como puerta de entrada a otros componentes de la aplicación, que consisten principalmente en actividades y servicios.

Un aspecto único del sistema Android es que cualquier aplicación puede iniciar el componente de otra aplicación (por ejemplo, si desea hacer una llamada, enviar SMS, abrir una página web o ver una foto, hay una aplicación que ya lo hace y su aplicación puede hacer uso de él, en lugar de desarrollar una nueva actividad para la misma tarea).

Cuando el sistema inicia un componente, inicia el proceso para esa aplicación (si aún no se está ejecutando, es decir, solo un proceso de primer plano por aplicación puede ejecutarse en un momento dado en un sistema Android) y crea una instancia de las clases necesarias para ese componente. Por lo tanto, el componente se ejecuta en el proceso de esa aplicación a la que pertenece. Por lo tanto, a diferencia de las aplicaciones en otros sistemas, las aplicaciones de Android no tienen un solo punto de entrada (no hay un método main() ).

Debido a que el sistema ejecuta cada aplicación en un proceso separado, una aplicación no puede activar directamente los componentes de otra aplicación, como puede hacerlo el sistema Android. Por lo tanto, para iniciar el componente de otra aplicación, una aplicación debe enviar un mensaje al sistema que especifique la intención de iniciar ese componente, luego el sistema iniciará ese componente.

Contexto

Las instancias de la clase android.content.Context proporcionan la conexión al sistema Android que ejecuta la aplicación. Se requiere Instance of Context para obtener acceso a los recursos del proyecto y la información global sobre el entorno de la aplicación.

Pongamos un ejemplo fácil de digerir: considera que estás en un hotel y quieres comer algo. Llama al servicio de habitaciones y les pide que le traigan cosas o que limpien cosas para usted. Ahora piense en este hotel como una aplicación de Android, usted mismo como una actividad, y la persona de servicio de habitación es su contexto, que le brinda acceso a los recursos del hotel, como servicio de habitaciones, alimentos, etc.

Sin embargo, otro ejemplo: usted está en un restaurante sentado en una mesa, cada mesa tiene un asistente, cuando quiera pedir alimentos, le pide al asistente que lo haga. Luego, el asistente hace su pedido y sus alimentos se sirven en su mesa. Nuevamente, en este ejemplo, el restaurante es una aplicación de Android, las mesas o los clientes son componentes de la aplicación, los alimentos son sus recursos de la aplicación y el asistente es su contexto, lo que le brinda una manera de acceder a los recursos como alimentos.

La activación de cualquiera de los componentes anteriores requiere la instancia del contexto. No solo lo anterior, sino también casi todos los recursos del sistema: creación de la IU mediante vistas (que se analiza más adelante), creación de instancias de servicios del sistema, inicio de nuevas actividades o servicios, todo requiere un contexto.

Una descripción más detallada se escribe aquí .

Configuración de un AVD (dispositivo virtual de Android)

TL; DR Básicamente, nos permite simular dispositivos reales y probar nuestras aplicaciones sin un dispositivo real.

Según la documentación del desarrollador de Android ,

una definición de dispositivo virtual de Android (AVD) le permite definir las características de un teléfono, tableta, Android Wear o dispositivo de TV Android que desee simular en el emulador de Android. AVD Manager lo ayuda a crear y administrar AVD fácilmente.

Para configurar un AVD, siga estos pasos:

1. Haga clic en este botón para abrir el Administrador de AVD:

2. Deberías ver un diálogo como este:

3. Ahora haga clic en el botón + Create Virtual Device... Esto abrirá el diálogo de configuración del dispositivo virtual:

4. Seleccione el dispositivo que desee y haga clic en Next :

5. Aquí debes elegir una versión de Android para tu emulador. Es posible que también necesite descargarlo primero haciendo clic en Download . Después de haber elegido una versión, haga clic en Next .

6. Aquí, ingrese un nombre para su emulador, orientación inicial y si desea mostrar un marco a su alrededor. Después de haber elegido todos estos, haga clic en Finish .

7. Ahora tienes un nuevo AVD listo para lanzar tus aplicaciones en él.