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!