Primeros pasos con Android

Crear un nuevo proyecto

Configurar Android Studio

Comienza [configurando Android Studio](https://www.wikiod.com/es/android/primeros-pasos-con-android#Configuración de Android Studio) y luego ábrelo. Ahora, ¡estás listo para crear tu primera aplicación para Android!

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

Configure su proyecto

Configuracion basica

Puede iniciar un nuevo proyecto de dos maneras:

  • Haga clic en Iniciar un nuevo proyecto de Android Studio en la pantalla de bienvenida.
  • Vaya a ArchivoNuevo proyecto si ya tiene un proyecto abierto.

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

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

    Example: Hello World. You can always change it later in AndroidManifest.xml file.

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

    Example: stackoverflow.com.

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

    It should follow Reverse Domain Name Notation (aka Reverse DNS): Top Level Domain . Company Domain . [Company Segment .] Application Name.

    Example: com.stackoverflow.android.helloworld or com.stackoverflow.helloworld. You can always change your applicationId by overriding it in your gradle file.

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

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

Diálogo de nuevo proyecto

Seleccionar factores de forma y 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 Ayúdame a elegir

ingrese la descripción de la imagen aquí Gráfico de las distribuciones de la versión actual de Android, que se muestra al hacer clic en Ayudarme a elegir.

La ventana Distribución de la plataforma Android muestra la distribución de los 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 funciones introducidas en la versión correspondiente de Android. Esto lo ayuda a elegir el nivel mínimo de API que tiene todas las características que necesitan sus aplicaciones, para que pueda llegar a tantos dispositivos como sea posible. Luego haga clic en Aceptar.

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

Diálogo de versión SDK

Por ahora, selecciona solo Teléfono y Tablet.

El SDK mínimo es el límite inferior de 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 de Stack Exchange es compatible con Android 4.1+.

Aplicación de Stack Exchange Android Studio le dirá (aproximadamente) qué porcentaje de dispositivos serán compatibles con el SDK mínimo especificado.

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

Al decidir sobre el SDK mínimo, debe considerar las [Estadísticas de los paneles][8], que le brindarán información sobre la versión de los dispositivos que visitaron Google Play Store en todo el mundo durante la última semana.

[![Captura de pantalla de la distribución actual de Android][9]][9]

De: Dashboards en el sitio web para desarrolladores de Android.

Añadir una actividad

Ahora vamos a seleccionar una actividad por defecto para nuestra aplicación. En Android, una [Actividad][10] es una sola pantalla que se le presentará al usuario. Una aplicación puede albergar múltiples actividades y navegar entre ellas. Para este ejemplo, elija Actividad vacía 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 “Actividad” como sufijo para el nombre de la actividad y “actividad_” como prefijo para el nombre del diseño. Si los dejamos como predeterminados, Android Studio generará una actividad para nosotros llamada MainActivity y un archivo de diseño llamado activity_main. Ahora haga clic en Finalizar.

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][11].

[![Estructura básica de la aplicación][12]][12]

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 acceder 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 verificando las autoridades que firmaron los certificados de la aplicación y, en algunos casos, preguntando al usuario. Una aplicación también puede proteger sus propios componentes (actividades, servicios, receptores de transmisión y proveedores de contenido) con permisos. Puede emplear cualquiera de los permisos definidos por Android (enumerados en android.Manifest.permission) o declarados por otras aplicaciones. O puede definir el suyo propio.

<?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 actividad_principal.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í:

[![Diseño de diseño / Pestañas de texto][13]][13]

<?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 android:text establecida en “¡Hola mundo!”. Este es un bloque de texto que se mostrará al usuario cuando ejecute la aplicación.

Puede leer más sobre [Diseños y atributos][14].

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 usa el sistema de compilación Gradle para compilar y crear aplicaciones y bibliotecas 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 usarlo 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:

compilarSdkVersion

compileSdkVersion es su manera de decirle a Gradle con qué versión del SDK de Android 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.

Debe enfatizarse que cambiar su compileSdkVersion no cambia el comportamiento del tiempo de ejecución. Si bien pueden aparecer nuevas advertencias/errores del compilador al cambiar su compileSdkVersion, su compileSdkVersion no está incluida en su APK: se usa exclusivamente en el momento de la compilación.

Por lo tanto, se recomienda encarecidamente que siempre compile con el SDK más reciente. Obtendrá todos los beneficios de las nuevas verificaciones de compilación en el código existente, evitará las API obsoletas recientemente 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. La minSdkVersion es una de las señales que usa Google Play Store para determinar en cuál de los dispositivos de un usuario se puede instalar una aplicación.

También juega un papel importante durante el desarrollo: de forma predeterminada, lint se ejecuta en tu proyecto y te advierte cuando usas cualquier API por encima de tu minSdkVersion, lo que te ayuda a evitar el problema del tiempo de ejecución de 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 versiones de plataforma más nuevas.

targetSdkVersion

targetSdkVersion es la forma principal en que Android proporciona compatibilidad con versiones anteriores al no aplicar cambios de comportamiento a menos que se actualice targetSdkVersion. Esto le permite usar nuevas API antes de trabajar con los cambios de comportamiento. La actualización para apuntar al SDK más reciente debe ser una alta prioridad para cada aplicación. Eso no significa que tenga que usar todas las funciones nuevas que se presenten ni que deba actualizar ciegamente su targetSdkVersion sin realizar pruebas.

targetSDKVersion es la versión de Android que es el límite superior para las herramientas disponibles. Si targetSDKVersion es inferior a 23, la aplicación no necesita solicitar permisos en tiempo de ejecución para una instancia, incluso si la aplicación se ejecuta en API 23+. TargetSDKVersion no evita que las versiones de Android superiores a la versión de Android seleccionada ejecuten la aplicación.

Puede encontrar más información sobre el complemento de Gradle:

  • [Un ejemplo básico][15]
  • [Introducción al complemento de Gradle para Android y el contenedor][16]
  • [Introducción a la configuración de los métodos build.gradle y DSL][17]

Ejecutando la aplicación

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

Configuración de un dispositivo Android

Para ejecutar una aplicación de Android Studio en su dispositivo Android, debe habilitar la “Depuración de USB” en las “Opciones de desarrollador” en la configuración de su dispositivo.

Configuración > Opciones de desarrollador > Depuración USB

Si Opciones de desarrollador no está visible en la configuración, vaya a Acerca del teléfono y toque el Número de compilación siete veces. Esto habilitará las Opciones de desarrollador para que aparezcan en su configuración.

Configuración > Acerca del teléfono > Número de compilación

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

Ejecutando desde Android Studio

Haga clic en el botón verde Ejecutar 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 https://www.wikiod.com/es/android/primeros-pasos-con-android 29572/setting-up-an-avd-android-virtual-device si necesita configurar uno) y haga clic en OK.

[![Botón Ejecutar][18]][18]

En los dispositivos que ejecutan Android 4.4 (KitKat) y posiblemente superior, se mostrará una ventana emergente para autorizar la depuración de USB. Haga clic en Aceptar para aceptar.

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

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 incluyen tareas básicas de limpieza 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 realizar con las herramientas JDK y SDK de Android. Las tareas de prueba sirven como verificación final, asegurando que su aplicación funcione como se espera en condiciones reales. Cuando haya terminado de preparar su aplicación para el lanzamiento, tendrá un archivo APK firmado, que puede distribuir directamente a los usuarios o distribuir a través de un mercado de aplicaciones como Google Play.

Estudio de Android

Dado que en los ejemplos anteriores se usa Gradle, la ubicación del archivo APK generado es: <Ubicación de su proyecto>/app/build/outputs/apk/app-debug.apk

IntelliJ

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

out/production/...

Nota: esto quedará obsoleto a veces alrededor de 1.0

Eclipse

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

bin/...

1: https://www.wikiod.com/es/android/gradle-para-android#Un archivo build.gradle básico 2: http://i.stack.imgur.com/GuxhP.png 3: https://i.stack.imgur.com/jT1Gl.png 4: https://www.wikiod.com/es/android/versiones-de-android 5: http://i.stack.imgur.com/WjYSV.png 6: https://play.google.com/store/apps/details?id=com.stackexchange.marvin&hl=en 7: https://i.stack.imgur.com/YYIjb.png [8]: https://developer.android.com/about/dashboards/index.html [9]: https://i.stack.imgur.com/N1YzZm.png [10]: https://developer.android.com/reference/android/app/Activity.html [11]: https://developer.android.com/studio/projects/index.html [12]: http://i.stack.imgur.com/NL9VZ.png [13]: http://i.stack.imgur.com/acYOg.png [14]: https://developer.android.com/guide/topics/ui/declaring-layout.html [15]: https://www.wikiod.com/es/android/gradle-para-android#Un archivo build.gradle básico#t=201609132029568551397 [16]: https://www.wikiod.com/es/android-gradle/primeros-pasos-con-android-gradle [17]: https://www.wikiod.com/es/android-gradle/configura-tu-compilacion-con-gradle [18]: https://i.stack.imgur.com/XOe2s.png

Configuración de Android Studio

[Android Studio][as] es el IDE de desarrollo de Android 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.

Instalación de las herramientas Android Studio y Android SDK:

  1. Descargue e instale Android Studio.
  2. Descargue las herramientas SDK y las herramientas de plataforma SDK más recientes abriendo Android Studio y luego siguiendo las instrucciones [Actualizaciones de herramientas SDK de Android] sdkmanager. Debe instalar los últimos paquetes estables disponibles.

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

Desde Android Studio 2.2, se incluye una copia de la última versión de OpenJDK con la instalación y es el JDK recomendado (Java Development Kit) para todos los proyectos de Android Studio. Esto elimina el requisito de tener instalado el paquete JDK de Oracle. Para usar 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 Ubicación de SDK y en Ubicación de JDK, marque la casilla de verificación Usar JDK incrustado.
  3. Haga clic en Aceptar.

Configurar Android Studio

Android Studio brinda 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 de la memoria caché. Tenga en cuenta que en las máquinas con Linux, este archivo puede llamarse studio64.vmoptions, según 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 de archivo máximo admitido.

Cambiar/añadir tema

Puede cambiarlo como prefiera. Archivo->Configuración->Editor->Colores y fuentes-> 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 Archivo -> Configuración de importación... y seleccione el archivo descargado.

Compilar aplicaciones

Cree un nuevo proyecto o abra un proyecto existente en Android Studio y presione el botón verde Reproducir ingrese la descripción de la imagen aquí en la barra de herramientas superior para ejecutarlo. Si está 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 la instalación de su SDK.

Abra un shell y vaya al directorio del proyecto. Ingresa ./gradlew aR y presiona enter. aR es un atajo para assembleRelease, que descargará todas las dependencias por usted y construirá la aplicación. El archivo APK final estará en ProjectName/ModuleName/build/outputs/apk y se llamará ModuleName-release.apk.

Programación de Android sin IDE

Este es un [ejemplo de Hello World][helloWorld] minimalista que utiliza solo las herramientas más básicas de Android.

Requisitos y supuestos

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

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

Configuración del SDK de Android

Después de desempaquetar la versión SDK:

  1. Instale paquetes adicionales mediante el administrador de SDK. Don’t use android update sdk --no-ui as instructed in the bundled Readme.txt; it downloads some 30 GB of unnecessary files. Instead use the interactive SDK manager android sdk to get the recommended minimum of packages.

  2. Agregue los siguientes directorios JDK y SDK a su RUTA de ejecución. This is optional, but the instructions below assume it.

    • JDK/bin
    • SDK/platform-tools
    • SDK/tools
    • SDK/build-tools/LATEST (as installed in step 1)
  3. Cree un dispositivo virtual Android. Use the interactive AVD Manager (android avd). You might have to fiddle a bit and search for advice; the [on-site instructions][createAVD] aren’t always helpful.

    (You can also use your own device)

  4. Ejecute el dispositivo:

     emulator -avd DEVICE
    
  5. Si la pantalla del dispositivo parece estar bloqueada, deslícela para desbloquearla.

    Leave it running while you code the app.

Codificando la aplicación

  1. Cambie a un directorio de trabajo vacío.

  2. Cree el archivo fuente:

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

    Content:

     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 );
         }
     }
    
  3. Agregue un manifiesto:

     touch AndroidManifest.xml
    

    Content:

     <?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>
    
  4. Haz un subdirectorio para los recursos declarados:

     mkdir res
    

    Leave it empty for now.

Construyendo el código

  1. Genere la fuente para las declaraciones de recursos. Substitute here the correct path to your SDK, and the installed API to build against (e.g. “android-23”):

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

    Resource declarations (described further below) are actually optional. Meantime the above call does nothing if res/ is still empty.

  2. Compile el código fuente a 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
    
  3. Traduce el código de bytes de Java a Android (.class → .dex):

    First using Jill (.class → .jayce):

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

    Then Jack (.jayce → .dex):

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

    Android bytecode used to be called “Dalvik executable code”, and so “dex”.

    You could replace steps 11 and 12 with a single call to Jack if you like; it can compile directly from Java source (.java → .dex). But there are advantages to compiling with javac. It’s a better known, better documented and more widely applicable tool.

  4. Empaquete 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
    

    That results in a partial APK file (Android application package).

  5. Haz el APK completo 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
    

    It warns, “THIS TOOL IS DEPRECATED. See –help for more information.” If --help fails with an ArrayIndexOutOfBoundsException, then instead pass no arguments:

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

    It explains that the CLI (ApkBuilderMain) is deprecated in favour of directly calling the Java API (ApkBuilder). (If you know how to do that from the command line, please update this example.)

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

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

Instalando y ejecutando

  1. Instale la aplicación en el dispositivo Android:

    adb install -r app.apk
    
  2. Inicie la aplicación:

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

    It should run and say hello.

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

Declarar un recurso

Esta sección es opcional. Las declaraciones de recursos no son necesarias para una aplicación simple de “hola mundo”. 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 referenciarlo.

  1. Agregue un archivo de recursos:

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

    Content:

    <?xml version='1.0'?>
    <resources>
        <string name='appLabel'>Saying hello</string>
    </resources>
    
  2. Haga referencia al recurso del manifiesto XML. This is a declarative style of reference:

    <!-- <application a:label='Saying hello'> -->
         <application a:label='@string/appLabel'>
    
  3. Haga referencia al mismo recurso de la fuente de Java. This is an imperative reference:

    // v.setText( "Hello world" );
       v.setText( "This app is called "
         + getResources().getString( R.string.appLabel ));
    
  4. Pruebe las modificaciones anteriores reconstruyendo, reinstalando and re-running the app (steps 10-17).

    It should restart and say, “This app is called Saying hello”.

Desinstalar la aplicación

adb uninstall dom.domain

Ver también

  • [pregunta original][originalQ] - La pregunta original que motivó este ejemplo
  • [ejemplo de trabajo][relukExample]: un script de compilación funcional que usa los comandos anteriores

Fundamentos de la aplicación

Las aplicaciones de Android están escritas en Java. Las herramientas del SDK de Android compilan el código, los datos y los archivos de recursos en un APK (paquete de Android). Generalmente, 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 nada 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 del dispositivo como tarjeta 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 juega 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). Estos son los cuatro tipos de componentes de la aplicación:

  1. Actividades: Una actividad representa una sola 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 funcionan juntas para crear una experiencia de usuario (UX).
  2. Servicios: Un servicio se ejecuta en segundo plano para realizar operaciones de ejecución prolongada o para realizar trabajos para procesos remotos. Un servicio no proporciona ninguna interfaz de usuario, solo se ejecuta 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 de aplicaciones compartidas. 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 pueda acceder la aplicación. . A través de los proveedores de contenidos, otras Apps 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 los contactos). Los proveedores de contenido también se pueden usar para guardar los datos que son privados para la aplicación para mejorar la integridad de los datos.
  4. Receptores de transmisión: Un receptor de transmisión responde a las transmisiones de anuncios de todo el sistema (por ejemplo, una transmisión que anuncia que la pantalla se apagó, la batería está baja, etc.) o de aplicaciones (por ejemplo, para permitir que otras aplicaciones saber que algunos datos se han descargado en el dispositivo y están disponibles para su uso). Los receptores de transmisión no tienen interfaces de usuario, pero pueden mostrar una notificación en la barra de estado para alertar al usuario. Por lo general, los receptores de transmisió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 realizar una llamada, enviar un 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 se puede ejecutar un proceso en primer plano por aplicación en un momento dado en un sistema Android) e instancia 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 único 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, sin embargo, el sistema Android sí puede. 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 Instancia de contexto para obtener acceso a los recursos del proyecto y la información global sobre el entorno de la aplicación.

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

Otro ejemplo más, estás en un restaurante sentado en una mesa, cada mesa tiene un asistente, cuando quieras pedir comida, le pides 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 los recursos de su aplicación y el asistente es su contexto, lo que le brinda una forma de acceder a los recursos como los alimentos.

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

Se escribe una descripción más detallada 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 Documentación para desarrolladores de Android,

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

Para configurar un AVD, siga estos pasos:

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

Ícono del administrador de AVD

2. Debería ver un cuadro de diálogo como este:

Cuadro de diálogo Administrador de AVD

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

Diálogo de configuración de dispositivos virtuales

4. Seleccione cualquier dispositivo que desee, luego haga clic en Siguiente:

Elegir imagen del sistema

5. Aquí debe elegir una versión de Android para su emulador. Es posible que también deba descargarlo primero haciendo clic en Descargar. Después de elegir una versión, haga clic en Siguiente.

Configuración avanzada

6. Aquí, ingrese un nombre para su emulador, la orientación inicial y si desea mostrar un marco a su alrededor. Después de elegir todo esto, haga clic en Finalizar.

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

AVD