¿Cual es mejor lenguaje de programación para aprender?

mayo 1, 2018mayo 1, 2018soloelectronicosDeja un comentario

Hay muchas comunidades potenciales que podrían ser encuestadas para este análisis. aunque GitHub y Stack Overflow se utilizan en casi en casi todos los análisis que vamos a ver debido indudablemente a su voluntaria, pero también a su grandisma exposición pública de los datos necesarios para el análisis.

Asimismo, todas las clasificaciones numéricas deben tomarse con sumo cuidado, porque estas pueden ser sustancialmente menos relevantes que la agrupación de lenguajes de programación (en muchos casos, un lugar en la lista no es distinguible del siguiente).

De todos modos la separación entre los niveles de lenguajes en la trama, sin embargo, es generalmente representativa de las diferencias sustanciales en la popularidad relativa.
Además, cuanto más abajo en los rankings un lenguaje de programacion va, menos datos hay disponibles para clasificar los lenguajes.

Más allá de los niveles superiores de lenguajes, dependiendo de la instantánea, la cantidad de datos a evaluar es mínima, y la ubicación real de los lenguajes se vuelve menos confiable cuanto más adelante en la lista se avanza. De todos modos aunque todos estas listas no puedan ser exactas al 100% ,estos rankings que vamos a ver son una buena referencia para entender como se están construyendo actualmente lo sistemas actuales ofreciéndonos una idea de cuales son las tecnologías preferidas

Ranking de PYPL

El índice de popularidad de PYPL se crea al analizar la frecuencia con la que se buscan los tutoriales de idiomas en Google.

Cuanto más se busca un tutorial de idioma, más popular se supone que es el lenguaje de programacion , asi que es un indicador adelantado dado que. ls datos brutos provienen de Google Trends.

Si cree en la sabiduría colectiva, el índice de Popularidad del Lenguaje de Programación de PYPL puede ayudarle a decidir qué lenguaje de programacion estudiar o cuál usar en un nuevo proyecto de software.

Lista mundial en Abril de 2018 comparado con datos un año hacia atrás :

Rank	Language	Share	Trend
1	Java	22.62 %	-0.8 %
2	Python	22.05 %	+5.2 %
3	Javascript	8.56 %	+0.2 %
4	PHP	8.22 %	-1.8 %
5	C#	7.95 %	-0.7 %
6	C	6.38 %	-1.1 %
7	R	4.26 %	+0.4 %
8	Objective-C	3.7 %	-1.0 %
9	Swift	2.92 %	-0.6 %
10	Matlab	2.31 %	-0.4 %
11	Ruby	1.7 %	-0.4 %
12	TypeScript	1.58 %	+0.5 %
13	VBA	1.39 %	+0.0 %
14	Visual Basic	1.27 %	-0.3 %

Ranking de GitHut

GitHut asociado al famoso repositorio de codigo Github también tiene su propio ranking

El ganador sin duda es #1(26,5%) Javascript desarrollado originalmente por Netscape en 2002. A pesar de tener nombres similares, Javascript no está relacionado con Java como todos sabemo

JavaScript (abreviado como js) es un lenguaje de programación interpretado orientado a objetos basado en prototipos, imperativo, débilmente tipado y dinámico.

Se ha estado usando años a tras principalmente en su forma del lado del cliente , implementado como parte de un navegador web permitiendo mejoras en la interfaz de usuario y páginas web dinámicas , pero actualmente ha tomado mucha transcendencia , y de ahi su posición en este ranking debido a su facilidad de uso en el lado del servidor(Server-side JavaScript o SSJS)

A partir de mediados de la década de los 2000, ha habido una proliferación de implementaciones de JavaScript para el lado servidor. Node.js es uno de los notables ejemplos de JavaScript en el lado del servidor, siendo usado en proyectos importantes

1	JavaScript	22.947% (-2.606%)
2	Python	16.127% (+0.848%)
3	Java	9.960% (+0.001%)
4	Go	7.236% (+1.238%)
5	Ruby	6.732% (+0.237%)
6	C++	6.423% (+0.779%)
7	PHP	6.094% (-1.242%)
8	TypeScript	4.807% (+1.999%)
9	C#	3.375% (-0.647%)
10	C	2.890% (-0.442%)
11	Shell	2.327% (+0.146%)
12	Scala	1.406% (-0.011%)
13	Swift	1.168% (-0.025%)

Ranking de Stack Overflow

Stack Overflow es uno de los sitios de preguntas y respuestas mas famosos para programadores de todo el mundo . Gracias a ello este ranking rastrea los lenguajes más populares en su encuesta anual para desarrolladores. Para el informe de 2018, Stack Overflow obtuvo respuestas de más de 100.000 desarrolladores, lo que lo convierte en un buen vistazo a las tecnologías más populares entre programadores.

Esto es lo que hay en la lista:

#1: Javascript: A pesar de tener nombres similares, Javascript no está relacionado con Java. Permite a los desarrolladores crear elementos interactivos en los sitios web, convirtiéndolo en uno de los lenguajes más omnipresentes de la web y el más popular del mundo.
#2: HTML: Aunque técnicamente no es un lenguaje de programación – es un «lenguaje de marcas» – HTML es la base para la estructura de cada sitio web.
#3: Cascading Style Sheets, o CSS: el lenguaje de programación más utilizado para diseñar sitios web y aplicaciones basadas en navegadores.
#4: SQL: Structured Query Language (Lenguaje de consulta estructurado). Permite tratar grandes cantidades de datos mediante el acceso y la gestión de bases de datos. La mayoría de las veces se usa en conjunción con otro lenguaje, como PHP.
#5: Java: Java fue inventado originalmente por Sun Microsystems en 1991 como lenguaje de programación para sistemas de televisión interactiva. Desde la compra de Sun, Oracle ha convertido a Java en una potencia. El lenguaje de programación es la forma más común de construir aplicaciones Android.
#6: Bash/Shell: Shell no es exactamente un lenguaje de programación. En su lugar, un script de shell instruye a un sistema operativo para que ejecute automáticamente una lista prediseñada de comandos. Por ejemplo, un script shell puede hacer que un sistema operativo convierta cada archivo «.bmp» en un «.jpg» siempre que se ejecute.
#7: Python: Python data de 1989 y es amado por sus fans por su código altamente legible. Muchos programadores creen que es el lenguaje más fácil de usar.
#8: C#: Este lenguaje, pronunciado «C-Sharp», fue desarrollado por Microsoft. Es un rival al aún más popular Java y ampliamente utilizado por los desarrolladores de software empresarial.
#9: PHP se utiliza para sitios web y aplicaciones que son pesados en datos. Incluso alimenta WordPress y Facebook. Pero muchos programadores odian PHP con pasión. «PHP no es tanto un lenguaje como una colección aleatoria de cosas arbitrarias, una explosión virtual en la fábrica de palabras clave y funciones», escribió Jeff Atwood, fundador de Stack Overflow.
#10: C++ es una rama del lenguaje de programación C. Fue creado originalmente en 1983, y se puede encontrar en todo, desde aplicaciones web de escritorio hasta infraestructura de servidores.
#11: C, uno de los lenguajes de programación más antiguos aún en uso común, fue creado a principios de la década de los 70. En 1978, el legendario manual del lenguaje, «The C Programming Language», fue publicado por primera vez.
#12: Typescript es relativamente joven según los estándares de lenguajes de programación. Lo creó Microsoft en 2012. Está estrechamente relacionado con el mega-popular JavaScript y diseñado para ejecutar grandes aplicaciones.
#13: Ruby ha ganado muchos elogios por ser fácil de leer y escribir. También es popular Rails, un framework complementario para Ruby que facilita la creación de aplicaciones web. El lema oficial de la lengua es «El mejor amigo de un programador».
#14: Swift fue lanzado por Apple 2014, promocionado como una mejor y más fácil manera de construir software. Swift se ha puesto de moda; Lyft, entre otros, lo utilizó para hacer su aplicación para iPhone.

Ranking de RedMonk

Redmonk sigue un proceso básico similar a los anteriores : extraen clasificaciones de idiomas de GitHub y Stack Overflow, y combinan una clasificación que intente reflejar la tracción de código (GitHub) y discusión (desbordamiento de pila). La idea no es ofrecer una representación estadísticamente válida del uso actual, sino más bien correlacionar la discusión y el uso del lenguaje en un esfuerzo por extraer ideas sobre posibles tendencias futuras de adopción.

La fuente de datos utilizada para estas consultas es el archivo GitHub. Consultan lenguajes de programación por solicitud de extracción de una manera similar a la que usó GitHub para ensamblar el Estado del Octoverse 2016.

En el lado positivo, en este ranking también eliminan la queja más común con respecto a los rankings históricamente: que las mediciones por repositorio pueden sobreestimar la importancia de un lenguaje determinado(JavaScript, con mayor frecuencia).

Para ser incluido en este análisis, un lenguaje debe ser observable dentro de GitHub y Stack Overflow.

Con todas las consideraciones aquí está la trama del primer trimestre para 2018.

No se hacen afirmaciones aquí de que estos rankings sean representativos del uso general más amplia mente. No son nada más ni nada menos que un examen de la correlación entre dos poblaciones que creen que son predictivas del uso futuro, de ahí su valor.

Es difícil dar un prevision a futuro del uso de cada lenguaje,pero desde luego lo que ya nadie duda es que Java va perdiendo cada vez mas protagonismo, protagonismo que va lentamente reemplazado por otros lenguajes como Javascript , Python , Ruby o C#

Cómo enviar correos desde Android con Apache Commons

enero 24, 2017diciembre 9, 2018soloelectronicosDeja un comentario

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 aplicación 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 envíos 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 fácilmente correos si importamos la libreria Apache Commons

Un ejemplo de código funcional que podemos probar desde Android Studio es el siguiente:

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 nombre del correo de envío

// es el enviante

String subject = «subject«;

//asunto del correo

String text = «message»;

//texto del correo try

{ AuthenticatingSMTPClientclient = 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 aplicación 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

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

enero 5, 2017soloelectronicos9 comentarios

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»

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

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)

diciembre 16, 2016diciembre 16, 2016soloelectronicos2 comentarios

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.

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

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.
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.
Haga clic en Next.
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.
En la pantalla Add an Activity to Mobile, selecciona Empty Activity y haz clic en Next.
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:

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).
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:

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