Cómo enviar correos desde Android con Apache Commons


Trabajando con Android, muchos buscamos  enviar mensajes de correo electrónico usando un servidor SMTP, utilizando autenticación y cifrado, dentro de  de la propia aplicación android de forma que sea completamente transparente para el usuario.

Por desgracia javax.mail en Android no es una buena opción, ya que depende de las clases awt (problemas por la herencia) y no siempre funciona:no en vano ,de hecho algunas personas han tratado de adaptar la librería dado  que no ser requiere todo el paquete awt , pero lamentablemente han tenido poco éxito con eso; !y eso sin mencionar a quienes que refactorizando javax.mail para Android  (que lleva muchos  años, sin ningún mantenimiento)!.

Apache Commons es un conjunto de proyectos de Apache Software Foundation, que originalmente formaron parte de Jakarta Project. El propósito de estos proyectos consiste en proveer componentes de software Java reutilizables, en código abierto. Según su grado de madurez y actividad, los proyectos se agrupan en las categorías: proper, sandbox o dormant.

Otra opción mas pragmática pues  es usar Apache Commons ,puesto que la comunidad ha añadido un SMTPSClient y un AuthenticatingSMTPClient para el cliente SMTP original ,el cual con la  aplicacion de un pequeño parche  para SSL y autenticación, se puede incrustar esta biblioteca en su aplicación para Android sin necesitar dependencias transitivas para enviar correo mediante la autenticación sobre una capa segura.

Autenticación SMTP y STARTTLS

STARTTLS es una extensión a los protocolos de comunicación de texto plano, que ofrece una forma de mejorar desde una conexión de texto plano a una conexión cifrada (TLS o SSL) en lugar de utilizar un puerto diferente para la comunicación cifrada.

El puerto utilizado para  envios de correos es generalmente 25 o el puerto 587 alternativo por lo que lo que se trata es de conectar al servidor SMTP en una conexión simple, se piden los comandos disponibles, y si se soporta STARTTLS,se  usa ,y el resto de la comunicación está cifrado.

Ahora tomemos el ejemplo de gmail, ya que el servidor es  smtp.gmail.com , como soporta autenticación y STARTTLS  podemos enviar facilmente correos si importamos la libreria Apache Commons

 

Un ejemplo de código funcional qeu podemos probar desdeAndroid Studio es el siguinte:


 com.google.android.gms.appindexing.Action;
 import com.google.android.gms.appindexing.AppIndex;
 import com.google.android.gms.appindexing.Thing;
 import com.google.android.gms.common.api.GoogleApiClient;

import org.apache.commons.net.smtp.AuthenticatingSMTPClient;
 import org.apache.commons.net.smtp.SMTPClient;
 import org.apache.commons.net.smtp.SMTPReply;
 import org.apache.commons.net.smtp.SimpleSMTPHeader;

 

 

public void sendEmail() {
 String hostname = "smtp.gmail.com";
 int port = 587;

String password = "xxxxxxxxx"; // aqui necesitamos la pwd de al cuenta de gmail 
 String login = "[email protected]";//aqui necesitamos la cuenta de gmail desde 
                                     //la que enviaremos los email desde la app

String from = login;             //aqui ponemos el mombre del correo de envio
                                 // es el enviante 

String subject = "subject";       //asunto del correo
 String text = "message";        //texto del correo  

try {
 AuthenticatingSMTPClient client = new AuthenticatingSMTPClient();
 String to = "[email protected]";  //destino del correo
 // optionally set a timeout to have a faster feedback on errors
 client.setDefaultTimeout(10 * 1000);
 // you connect to the SMTP server
 client.connect(hostname, port);
 // you say ehlo  and you specify the host you are connecting from, could be anything
 client.ehlo("localhost");
 // if your host accepts STARTTLS, we're good everything will be encrypted, otherwise we're done here
 if (client.execTLS()) {

client.auth(AuthenticatingSMTPClient.AUTH_METHOD.LOGIN, login, password);

checkReply(client);

client.setSender(from);
 checkReply(client);

client.addRecipient(to);
 checkReply(client);

Writer writer = client.sendMessageData();

if (writer != null) {
 SimpleSMTPHeader header = new SimpleSMTPHeader(from, to, subject);
 writer.write(header.toString());
 writer.write(text);
 writer.close();
 if (!client.completePendingCommand()) {// failure
 throw new Exception("Fallo al  enviar email " + client.getReply() + client.getReplyString());
 }
 } else {
 throw new Exception("Fallo al enviar email " + client.getReply() + client.getReplyString());
 }
 } else {
 throw new Exception("STARTTLS no fue aceptado " + client.getReply() + client.getReplyString());
 }

} catch (Exception e) {
 // some other problem
 Toast.makeText(MainActivity.this, "Problema enviado email.", Toast.LENGTH_SHORT).show();

}
 }

private static void checkReply(SMTPClient sc) throws Exception {
 if (SMTPReply.isNegativeTransient(sc.getReplyCode())) {
 throw new Exception("Transient SMTP error " + sc.getReply() + sc.getReplyString());
 } else if (SMTPReply.isNegativePermanent(sc.getReplyCode())) {
 throw new Exception("Permanent SMTP error " + sc.getReply() + sc.getReplyString());
 }
 }

/**
 * ATTENTION: This was auto-generated to implement the App Indexing API.
 * See https://g.co/AppIndexing/AndroidStudio for more information.
 */
 public Action getIndexApiAction() {
 Thing object = new Thing.Builder()
 .setName("Main Page") // TODO: Define a title for the content shown.
 // TODO: Make sure this auto-generated URL is correct.
 .setUrl(Uri.parse("http://[ENTER-YOUR-URL-HERE]"))
 .build();
 return new Action.Builder(Action.TYPE_VIEW)
 .setObject(object)
 .setActionStatus(Action.STATUS_TYPE_COMPLETED)
 .build();
 }

@Override
 public void onStart() {
 super.onStart();

// ATTENTION: This was auto-generated to implement the App Indexing API.
 // See https://g.co/AppIndexing/AndroidStudio for more information.
 client2.connect();
 AppIndex.AppIndexApi.start(client2, getIndexApiAction());
 }

@Override
 public void onStop() {
 super.onStop();

// ATTENTION: This was auto-generated to implement the App Indexing API.
 // See https://g.co/AppIndexing/AndroidStudio for more information.
 AppIndex.AppIndexApi.end(client2, getIndexApiAction());
 client2.disconnect();
 }

No hay mucho que añadir aquí, por supuesto, la manipulación de excepciones podría ser optimizado si utiliza sus propias clases de excepción y por ejemplo tanto el login como el pwd de gmail  pueden ser capturados en los ajustes de la aplicacion para personalizarlo a voulntas.

Autenticación SMTP y SSL con Commons Net

Algunos servidores SMTP están configurados para aceptar sólo SSL  por lo  hay que asegurar la comunicación antes de emitir cualquier comando al servidor siendo generalmente el puerto usado el 465.

Por ejemplo  LaPoste.net oferece cuentas gratuitas de correo electrónico ofrecidas por la publicación francesa, asi que enviar correos desde  ahi seria similar a esto:

 public void sendEmail() throws Exception {  
    String hostname = "smtp.laposte.net";
    int port = 465;
    String password = "password";
    String login = "firstname.lastname";
    String from = login + "@laposte.net";
    String subject = "subject" ;
    String text = "message";
    // this is the important part : you tell your client to connect using SSL right away
   AuthenticatingSMTPClient client = new AuthenticatingSMTPClient("TLS",true);
    try {
      String to = "[email protected]";
      // optionally set a timeout to have a faster feedback on errors
      client.setDefaultTimeout(10 * 1000);
      client.connect(hostname, port);
      client.ehlo("localhost");
      client.auth(AuthenticatingSMTPClient.AUTH_METHOD.LOGIN, login, password);
      checkReply(client);
     client.setSender(from);
     checkReply(client);
      client.addRecipient(to);
      checkReply(client);
      Writer writer = client.sendMessageData();

      if (writer != null) {
        SimpleSMTPHeader header = new SimpleSMTPHeader(from, to, subject);
        writer.write(header.toString());
        writer.write(text);
        writer.close();
        if(!client.completePendingCommand()) {// failure
          throw new Exception("Failure to send the email "+ client.getReply() + client.getReplyString());
        }
      } else {
        throw new Exception("Failure to send the email "+ client.getReply() + client.getReplyString());
      }

    } catch (Exception e) {
        throw e;
    } finally {
        client.logout();
        client.disconnect();
    }
  }

No repitimos el método checkReply () aquí, ya que es el mismo para ambos fragmentos de código

Usted habrá notado que el uso de SSL de inmediato significa que usted no tiene que buscar la respuesta execTls () (de hecho no funcionará si lo hace).

Dependencias

Eso es todo; Si desea hacer que estos ejemplos funcionen en su entorno, debe descargar la liberia  apache commons net 3.3 jar    y agregar el jar apache commons net 3.3 a su proyecto

 

 

coomons

Anuncios

Envío de e-mail sin intervención del usuario en Android Studio


El SDK de Android facilita muchísimo el envío de correos electrónicos desde una aplicación, pues sólo necesitamos incluir   el permiso correspondiente en el fichero AndroidManifiest.xml  y luego ya podemos usarlo en un nuestra   clase principal

Por ejemplo  esta  es una forma de incluir lo  permisos necesarios  en el fichero AndroidManifiest.xml:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.usuario.ejemplo" >
    <uses-permission android:name="android.permission.INTERNET"/>

    <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>

Con los permisos  otorgados,    en el  fichero  MainActivity .java  necesitaremos  incluir una referencia a dicho modulo:

import android.net.Uri;

Y  ya desde el propio  fichero  MainActivity .java   crearemos la clase de envio de  correos  ,la cual  podremos invocar desde cualquier parte  para enviar el correo

    protected void sendEmail() {
        Log.e("Test email:", "enviando email");
        String[] TO = {""};
        String[] CC = {""};
        Intent emailIntent = new Intent(Intent.ACTION_SEND);

        emailIntent.setData(Uri.parse("mailto:"));
        emailIntent.setType("text/plain");
        emailIntent.putExtra(Intent.EXTRA_EMAIL, TO);
        emailIntent.putExtra(Intent.EXTRA_CC, CC);
        emailIntent.putExtra(Intent.EXTRA_SUBJECT, "Your subject");
        emailIntent.putExtra(Intent.EXTRA_TEXT, "Email message goes here");

        try {
            startActivity(Intent.createChooser(emailIntent, "Send mail..."));
            finish();
            Log.e("Test email:", "Fin envio email");

        } catch (android.content.ActivityNotFoundException ex) {
            Toast.makeText(MainActivity.this, "There is no email client installed.", Toast.LENGTH_SHORT).show();
        }
    }
};

Por desgracia, esta vía es sólo válida si se desea enviarlos a través de la  propia aplicación de correo incorporada.

Para la mayoría de las situaciones este  método  funciona muy bien, y como hemos visto con muy poco código  , pero   silo que quiere es enviar algo y no quiere  ver  ninguna entrada  o  intervención del usuario ya  no es tan fácil.
En las siguientes lineas vamos a ver  cómo enviar un correo electrónico en background, es decir in que el usuario  sea consciente de ello ya que  la aplicación hará todo por detrás
Antes de comenzar, necesitará descargar tres librerías  a través del siguiente enlace:

https://code.google.com/archive/p/javamail-android/downloads

Esta es una versión especial de la API de JavaMail, que ha sido escrita específicamente para Android por Jon Simon.

googlecode

Esta librerias debemos  añádirlas como bibliotecas externas para que sean accesibles por la clase Mail.

Una forma sencilla de hacerlo es copiar directamente  estos ficheros  donde se encuentre el fichero activitymain,java ( por ejemplo   en c:\Users\miususairo\AndroidStudioProjects\ejemplo\app\src\main\java\com\example\misusuario\ejemplo\ )

De este modo, será visible el contenido desde la carpeta java de nuestro  proyecto;

libreias

Ahora ya sólo nos queda  pinchar sobre cada librería de las tras copiadas , con el boton derecho  y seleccionaremos “Add  as Library”

addas.png

.

Al pulsar esta opción  nos pide donde añadira la librerria , qeu simplemnte  aceptaremos

create.PNG

Ahora vamos  a ver  el codigo completo de la clase que nos permitira usar esta tres librerias que hemos imporatado para poder enviar correos mediante nuestra cuenta de gmail sin intervencion de Android

import java.util.Date; 
import java.util.Properties; 
import javax.activation.CommandMap; 
import javax.activation.DataHandler; 
import javax.activation.DataSource; 
import javax.activation.FileDataSource; 
import javax.activation.MailcapCommandMap; 
import javax.mail.BodyPart; 
import javax.mail.Multipart; 
import javax.mail.PasswordAuthentication; 
import javax.mail.Session; 
import javax.mail.Transport; 
import javax.mail.internet.InternetAddress; 
import javax.mail.internet.MimeBodyPart; 
import javax.mail.internet.MimeMessage; 
import javax.mail.internet.MimeMultipart; 
 
 
public class Mail extends javax.mail.Authenticator { 
  private String _user; 
  private String _pass; 
 
  private String[] _to; 
  private String _from; 
 
  private String _port; 
  private String _sport; 
 
  private String _host; 
 
  private String _subject; 
  private String _body; 
 
  private boolean _auth; 
   
  private boolean _debuggable; 
 
  private Multipart _multipart; 
 
 
  public Mail() { 
    _host = "smtp.gmail.com"// default smtp server 
    _port = "465"// default smtp port 
    _sport = "465"// default socketfactory port 
 
    _user = ""// username 
    _pass = ""// password 
    _from = ""// email sent from 
    _subject = ""// email subject 
    _body = ""// email body 
 
    _debuggable = false// debug mode on or off - default off 
    _auth = true// smtp authentication - default on 
 
    _multipart = new MimeMultipart(); 
 
    // There is something wrong with MailCap, javamail can not find a handler for the multipart/mixed part, so this bit needs to be added. 
    MailcapCommandMap mc = (MailcapCommandMap) CommandMap.getDefaultCommandMap(); 
    mc.addMailcap("text/html;; x-java-content-handler=com.sun.mail.handlers.text_html"); 
    mc.addMailcap("text/xml;; x-java-content-handler=com.sun.mail.handlers.text_xml"); 
    mc.addMailcap("text/plain;; x-java-content-handler=com.sun.mail.handlers.text_plain"); 
    mc.addMailcap("multipart/*;; x-java-content-handler=com.sun.mail.handlers.multipart_mixed"); 
    mc.addMailcap("message/rfc822;; x-java-content-handler=com.sun.mail.handlers.message_rfc822"); 
    CommandMap.setDefaultCommandMap(mc); 
  } 
 
  public Mail(String user, String pass) { 
    this(); 
 
    _user = user; 
    _pass = pass; 
  } 
 
  public boolean send() throws Exception { 
    Properties props = _setProperties(); 
 
    if(!_user.equals("") && !_pass.equals("") && _to.length > 0 && !_from.equals("") && !_subject.equals("") && !_body.equals("")) { 
      Session session = Session.getInstance(props, this); 
 
      MimeMessage msg = new MimeMessage(session); 
 
      msg.setFrom(new InternetAddress(_from)); 
       
      InternetAddress[] addressTo = new InternetAddress[_to.length]; 
      for (int i = 0; i < _to.length; i++) { 
        addressTo[i] = new InternetAddress(_to[i]); 
      } 
        msg.setRecipients(MimeMessage.RecipientType.TO, addressTo); 
 
      msg.setSubject(_subject); 
      msg.setSentDate(new Date()); 
 
      // setup message body 
      BodyPart messageBodyPart = new MimeBodyPart(); 
      messageBodyPart.setText(_body); 
      _multipart.addBodyPart(messageBodyPart); 
 
      // Put parts in message 
      msg.setContent(_multipart); 
 
      // send email 
      Transport.send(msg); 
 
      return true; 
    } else { 
      return false; 
    } 
  } 
 
  public void addAttachment(String filename) throws Exception { 
    BodyPart messageBodyPart = new MimeBodyPart(); 
    DataSource source = new FileDataSource(filename); 
    messageBodyPart.setDataHandler(new DataHandler(source)); 
    messageBodyPart.setFileName(filename); 
 
    _multipart.addBodyPart(messageBodyPart); 
  } 
 
  @Override 
  public PasswordAuthentication getPasswordAuthentication() { 
    return new PasswordAuthentication(_user, _pass); 
  } 
 
  private Properties _setProperties() { 
    Properties props = new Properties(); 
 
    props.put("mail.smtp.host", _host); 
 
    if(_debuggable) { 
      props.put("mail.debug""true"); 
    } 
 
    if(_auth) { 
      props.put("mail.smtp.auth""true"); 
    } 
 
    props.put("mail.smtp.port", _port); 
    props.put("mail.smtp.socketFactory.port", _sport); 
    props.put("mail.smtp.socketFactory.class""javax.net.ssl.SSLSocketFactory"); 
    props.put("mail.smtp.socketFactory.fallback""false"); 
 
    return props; 
  } 
 
  // the getters and setters 
  public String getBody() { 
    return _body; 
  } 
 
  public void setBody(String _body) { 
    this._body = _body; 
  } 
 
  // more of the getters and setters ….. 
} 



En este  código inicializamos las propiedades, y configuramos los valores por defecto.

Además, estamos configurando los tipos mime para javamail.

También hay o un comentario que describe por qué necesitamos esto: Hay algo mal con MailCap, javamail no puede encontrar un controlador para la parte multipart / mixed, por lo que este bit tiene que ser añadido

Y probablemente ha notado que hay 2 constructores – uno sobrepasa al otro, solo en caso de que quiera pasar el nombre de usuario y la contraseña al instanciar la clase

 

El método más importante es  send()  pues  estamos poniendo todos los datos de las propiedades y el envío del correo. Puede llamar a este método en cualquier momento si desea agregar un archivo adjunto, pero asegúrese de llamar  a  _setProperties   antes del método de envío.

Dicha clase  configura las propiedades para la recuperación de correo: predeterminado para la autenticación SMTP pues debe  tenerse en cuenta que todo esto es predeterminado para conectarse al servidor SMTP de Gmail (Google).

A continuación se muestra un ejemplo de cómo utilizar el contenedor de correo en una actividad de Android.

 

@Override 
public void onCreate(Bundle icicle) { 
  super.onCreate(icicle); 
  setContentView(R.layout.main); 
 
  Button addImage = (Button) findViewById(R.id.send_email); 
  addImage.setOnClickListener(new View.OnClickListener() { 
    public void onClick(View view) { 
      Mail m = new Mail("[email protected]""password"); 
 
      String[] toArr = {"[email protected]""[email protected]"}; 
      m.setTo(toArr); 
      m.setFrom("[email protected]"); 
      m.setSubject("This is an email sent using my Mail JavaMail wrapper from an Android device."); 
      m.setBody("Email body."); 
 
      try { 
        m.addAttachment("/sdcard/filelocation"); 
 
        if(m.send()) { 
          Toast.makeText(MailApp.this"Email was sent successfully.", Toast.LENGTH_LONG).show(); 
        } else { 
          Toast.makeText(MailApp.this"Email was not sent.", Toast.LENGTH_LONG).show(); 
        } 
      } catch(Exception e) { 
        //Toast.makeText(MailApp.this, "There was a problem sending the email.", Toast.LENGTH_LONG).show(); 
        Log.e("MailApp""Could not send email", e); 
      } 
    } 
  }); 
} 

Programar en Andoid ya no es tan complicado (parte 1)


Android es un s.o .basado en el núcleo Linux  que aparece en octubre de 2003 no en Google sino en la empresa Android In , empresa que mas tarde seria adquirida por Golgle.  Android fue presentado en 2007 junto la fundación del Open Handset Alliance (un consorcio de compañías de hardware, software y telecomunicaciones) para avanzar en los estándares abiertos de los dispositivos móviles vendiéndose  el primer móvil con el sistema operativo Android ( HTC Dream) en octubre de 2008.Los dispositivos de Android venden más que las ventas combinadas de Windows Phone e IOS .

Según Symantec en comparación con iOS, Android es un sistema explícitamente menos vulnerable  citando  13 vulnerabilidades graves para Android y 387 vulnerabilidades graves para iOS. El estudio también habla de los ataques en ambas plataformas, y en este caso Android se queda con 113 ataques nuevos en 2012 a diferencia de iOS que se queda en 1 solo ataque. Incluso así Google y Apple se empeñan cada vez más en hacer sus sistemas operativos más seguros incorporando más seguridad tanto en sus sistemas operativos como en sus mercados oficiales.

 

Tradicionalmente  para programar en Android se requerían bastantes herramientas que habia que configurar  manualmente : en primer lugar  teníamos que irnos a la página de Oracle en la sección de descargas, y  buscar el Java JDK (Java Development Kit) y descargar e instalarlo, despues  teníamos que descargar la versión de Eclipse especial  para Java (Eclipse IDE for Java Developers)  que al igual que en el paso previo  , tenia  que estar en consonancia  con la  versión de sistema operativo  y el procesador…

El siguiente paso era descargar el SDK que  nos proporciona Google, donde es ahí en realidad TODO lo que necesitamos para desarrollar: documentación, ejemplos, iconos Finalmente  a diferencia de todo lo descargado e instalado, el ultimo  paso (el más largo) era instalar el ADT dentro de Eclipse y configurarlo para que funcionaran todas las herramientas  dentro del propio Eclipse.

Afortunadamente  todos estos pasos comentados anteriormente comentados , aunque hay aun muchos des arrolladores que siguen en la actualidad usándolos, actualmente se han simplificado en un único paso : descargando e instalando una única  herramienta recomendada por Google : Android Studio.

 

androis-studio

Antiguamente se instalaba el Eclipes, Java , el DSK , pero como hemos vistos la opción mas recomendada actualmente  es descargar e instalar la herramienta recomendada por Google que puede descargar desde aqui: Android Studio.

Este nuevo sw de Google incluye todas las herramientas necesarias para desarrollar con Android incluso su propia  versión de java de 64 bits por lo que deberemos tener en cuenta que en principio solo deberíamos instalar en una maquina actual con arquitectura de 64bits

Una vez  instalada la herramienta

  1. En Android Studio, cree un nuevo proyecto:
    • Si no tiene un proyecto abierto, en la ventana Welcome to Android Studio haz clic en Start a new Android Studio project.
    • Si tiene un proyecto abierto, selecciona File > New Project.
  2. En la pantalla New Project, ingresa los siguientes valores:
    • Nombre de la aplicación: “My First App”
    • Dominio de la empresa: “example.com”

    Android Studio completara el nombre del paquete y la ubicación, pero puede editar estos datos si lo desea.

  3. Haga clic en Next.
  4. En la pantalla Target Android Devices, conserva los valores predeterminados y haz clic en Next.El SDK mínimo requerido es la primera versión de Android que admite su app, lo cual se indica a través del nivel de API. Para lograr la compatibilidad con la mayor cantidad posible de dispositivos, debe establecer esto en la versión más antigua disponible que permite a su app proporcionar su conjunto de funciones fundamentales.
  5. En la pantalla Add an Activity to Mobile, selecciona Empty Activity y haz clic en Next.
  6. En la pantalla Customize the Activity, conserve los valores predeterminados y haz clic en Finish.

Después de procesar, Android Studio se abre y aparecerá la estructura de una app “Hello World” con varios  archivos predeterminados. Por supuesto  podemos  agregar funcionalidad a algunos de estos archivos, como veremos en  un siguiente post.

Ahora es tiempo de  revisar los archivos más importantes. Primero, asegúrese  de que la ventana Project esté abierta (selecciona View > Tool Windows > Project) y la vista Android esté seleccionada en la lista desplegable de la parte superior. Podrás ver los siguientes archivos:

  • app > java > com.example.myfirstapp > MainActivity.java:Este archivo aparecerá en Android Studio después de que finalice el Asistente de proyecto nuevo. Contiene la definición de clase de la actividad que creo anteriormente. Cuando compila y ejecuta la app,  Activity inicia y carga el archivo de diseño con el mensaje “Hello World!”.
  • app > res > layout > activity_main.xml: es el archivo XML que define el diseño de la actividad. Contiene un elemento TextView con el texto “Hello world!”.
  • app > manifests > AndroidManifest.xml: es el archivo de manifiesto  que describe las características fundamentales de la app y define cada uno de sus componentes  (botones , cajas de texto , fondos , etc. )
  • Gradle Scripts > build.gradle:Android Studio usa Gradle para compilar y generar tu app. Existe un archivo build.gradle para cada módulo de tu proyecto, así como también un archivo build.gradle para el proyecto entero. Generalmente, solo será importante el archivo build.gradle del módulo. En este caso, es el app o módulo de aplicación.

 

Después  de comprobar la estructura de un programa básico en  Android , toca configurar su dispositivo físico Android  para probar el código pues lo cierto es que aunque es posible hacerlo con emulador lo ideal es mejor hacerlo sobre un terminal físico .

Este paso o se hace de la siguiente manera:

  1. Conecte su dispositivo a su máquina de desarrollo con un cable USB. Si está desarrollando en Windows, es posible que necesite instalar el controlador USB adecuado para su dispositivo (para obtener ayuda para instalar los controladores, consulte el documento Controladores OEM USB).
  2. Habilite USB debugging en el dispositivo. Para ello, dirígase a Settings > Developer options. (En Android 4.2 y versiones posteriores, Developer options está oculto de manera predeterminada. Para que esté disponible, diríjase a Settings > About phone y presiona Build number siete veces. Cuando regreses a la pantalla anterior, verás Developer options.)

Ejecute su app desde Android Studio de la siguiente manera:

  1. En Android Studio, seleccione su proyecto y haga clic en Run en la barra de herramientas.
  2. En la ventana Select Deployment Target, selecciona su dispositivo, y haga clic en OK.
  3. Android Studio instalara la app en su dispositivo conectado y lo iniciara automáticamente

!Enhorabuena  ya ha creado su propia app para Android, y de hecho ya tenemos las bases para desarrollar cualquier cosa  que se nos ocurra!