Mejoras para una cafetera de capsulas Nespresso


Tarde o temprano algún día nuestra querida cafetera de capsulas  empieza a perder agua   bien porque lleva tiempo sin usarla o bien   simplemente porque se ha quedado obstruida por el uso.

Obviamente una opción puede ser llevarla al servicio técnico , pero dadas las promociones que suelen llevar asociadas este tipo de maquinas no siempre es la opción mas recomendada  pues normalmente cualquier reparación, por muy simple que sea ,puede costar aproximadamente  entre 1/3 o 2/3 del precio  de la cafetera  por lo que no seria rentable.

Para  todas aquellas personas  que estén  interesas en reparar o simplemente mejorar su cafetera  va dedicado este post   destinado a ayudar a concienciarnos que no podemos desechar  indefinidamente  nuestra tecnología  sin indagar un poco maneras de darles una segunda oportunidad  o probar otras vías mas ecológicas.

 

Cuando detectamos una avería en nuestra cafetera, lo primero que se nos viene a la cabeza es la opción del servicio técnico ,pero si lo pensamos  no siempre es la opción  preferida por los consumidores: entre posibles repuestos que hagan falta para reemplazar, piezas, la mano de obra de los técnicos que se encarguen de la reparación… ¿al final cuánto cuesta reparar una cafetera  de capsulas? Muchas veces nos saldrá por lo mismo (o incluso más) que comprar una cafetera de capsulas nueva y obviamente ésta os debería dar menos problemas futuros que una maquina reparada

Cuando su cafetera no funciona, nada mejor que seguir un tutorial de vídeo antes de llevarse las manos a la cabeza o llamar corriendo al servicio técnico  sin detenerse a mirar nada, ¿no cree? Si prefiere reparar su cafetera usted mismo, puede echar un vistazo a infinidad de  vídeos en youtube donde nos  explican con gran detalles las soluciones a algunos de los problemas de cafetera de capsulas  más habituales.

Muy resumidamente si su cafetera de capsulas no funciona (Krups o Delonghi, da lo mismo el fabricante), puede ser por múltiples causas,pero las mas comunes son las siguintes:

  • La cafetera  pierde agua  tanto de forma esporádica como de forma continuada.Puede ser  simplemente la arandela del deposito de agua ( en caso de perdidas  por esa zona)  con la cual la reparación consistirá simplemente en reemplazar la arandela  o por el contrario  puede ser por la zona frontal   , lo cual es la  avería  mas común  y es la que vamos a tratar con profundidad es este post
  • No responden los pulsadores  porque algún componente se ha roto o deteriorado más de la cuenta.Esta  avería  es muy común  y también la vamos a  tratar  es este post
  • También tenemos que mencionar otra circunstancia muy común: la cafetera  no enciende. En estos casos, aparte de probar a sustituir la placa, es probable que la solución provenga de la sustitución de los condensadores.
  • Por supuesto pueden ocurrir  un sinfín de problemas mas : bomba  de presión , el elemento calefactor ,protecciones térmicas ,etc

 

Si queremos investigar nosotros mismos la causa del problema de nuestra máquina de café , tendremos que aprender a desmontarla y saber mirar en su interior. Desmontar una maquina no es difícil, ya que son todas similares y cuando se coge práctica con una ya se sabe desmontar todas del mismo modo.

La única complicación reside en los tornillos para acceder a su interior, ya que hace falta una herramienta específica para retirarlos (y para volverlos a apretar): una llave de vaso de 3.5 mm ovalada. No todo el mundo dispone de esta  herramientas,ero por suerte se puede construir  una con sus propios materiales con un simple tubo circular  calentándolo para darle la  forma  , o  bien simplemente usar unos alicates de puntas para quitarlos

cam00026

En primer lugar quitaremos todos los accesorios como son el deposito de agua,la caja de las capsulas , el recogedor de agua, etc.

En segundo lugar  quitaremos los tornillos de la parte de la tapa inferior .Como no todo el mundo disponemos de esta  herramientas,se puede construir  una  con un simple tubo circular  calentándolo para darle la  forma  , o  bien simplemente usar unos alicates de pu puntas para quitarlos  o incluso  unos alicates de corte cogiendo fuertemente los extremoscam00025

Una vez quitado los los  tornillos podemos soltar la tapa que alberga básicamente las conexiones así como los dos tubos del deposito.

 

cam00020cam00021cam00022

Lo siguiente es quitar las tapas laterales  y posteriores ( van  por presión )

cam00018cam00019cam00017

Ya que tenemos el cuerpo de lo primero es colocar el deposito de gua para comprobar donde pierde agua .

Como cápsulas para las pruebas , lo mas sencillo es usar capsulas rellenables  pues podremos repetir el  proceso muchas  veces sin desechar nuestro querido café.

CAM00030.jpg

Comprobaremos que esa es la pieza responsable  usando una capsula rellenable  y probando si esta el es culpable de las fugas de la cafetera.

cam00001

Una de las principales causas de fugas de este tipo de cafeteras  suele ser la boquilla de salida  que es una pieza de plástico que suele mancharse de posos de  café  perdiendo ademas estanqueidad con el paso del tiempo lo cual normalmente hace que pierda liquido especialmente por los bordes o  incluso por todo el cuerpo.

Comprobada  que esa es la pieza responsable  desmotaremos el porta-capsulas para acceder a la boquilla la cual limpiaremos profundamente  especialmente en  la boquilla de salida eliminando sobre todo cualquier obstrucción de la boquilla

cam00003cam00004

Una vez limpiada volveremos a fijar el portacapsulas para desvelar en funcionamiento , usando una capsula rellenable , si se   ha solucionado el problema

 

cam00002

 

 

Mejora de la boquilla de salida

Por mucho que limpiemos a veces la tapa  de salida  a causa del  desgaste  se deforma  tanto la  tapa de la boquilla que suele seguir perdiendo por los laterales inferiores , por lo que  una mejora sencilla es  introducir en la boquilla de salida una pajita de plástico resistente cortada para  que encaje justo en el orificio interior

Ademas si no es suficiente  con la idea de reforzar la solución de contención con la pajita otra medida   es eliminar los plásticos interiores de la tapa ( sobre todo del orificio de salida) pues  sin duda lo que se busca es dar una salida directa sin fugas al liquido procedente del portacapsulas.

cam00011

 

cam00005cam00006cam00007

Tendremos que cortarla justo para dirija el liquido a la boquilla de salida y  al colocar la tapa liar unas vueltas de teflón por la unión de ambas piezas

cam00008

Normalmente con  las tres medidas  comentadas (pajita, eliminación de plástico interior  y teflon en la junta ) debería de  desaparecer las fugas del liquido

cam00012

 

Problema de pulsadores

Otro problema típico de este tipo de cafeteras son la perdida de funcionalidad  de los pulsadores  de forma permanente o de forma esporádica

Para llegar a los pulsadores tendremos que  seguir los pasos  anteriores hasta que localizamos los cables de los pulsadores

cam00015cam00016

cam00014

cam00013

Al llevar un led, se requieren tres cables: dos del propio contacto y uno para el  positivo del led

 

Para probar la electrónica  solo tenemos que cruzar el cable negro (+)  con el primer cable blanco

cam00009

 

 

Si funciona la cafetera cruzando durante unos segundos dichos contactos  deberemos limpiar  tanto los contactos de la plaquita como la propia goma conductora del botón que hará el contacto.En este punto destacar que hay personas que optan por conectar nuevos pulsadores físicamente ( los contactos como hemos comentado  anteriormente)

 

Mejora  cambio de tornillos

Otra mejora evidente que nos ayudara  a futuras reparaciones es cambiar los tornillos elipticos de engorrosa   manipulación por  simples tornillos philips mucho mas sencillos de actuar sobre ellos

cam00023

 

cam00024

 

cam00025

 

 

 

Mejora  usando   capsulas rellenable y reutilzables

Tanto para hacer pruebas , como para el día a día   es muy interesante  usar capsulas recargables sobre todo con maquinas posteriores a 2010

Esta medida, al contrario de lo que se piense ,no dañara la maquina ( como fácilmente  habrá podido comprobar si ha visto como funciona el portacapuslas ) y desde luego es mucho mas ecológica  ( al poderse usar hasta 50 veces )

Otra razón de peso es que esta opción es muchísimo  mas económica :unos 10€  para 10 capsulas reutilizables  para obtener un mínimo de 250 cafés que costarían unos 125€ en capsulas desechables  y por supuesto ecológica pues no debería ser sostenible desechar una capsula de platico por cada uso  pudiendo  reusar la capsula  una y otra vez .

Otras ventajas innegable de este sistema es la disponibildad (dado que el  café  siempre esta disponible en  cualquier autoservicio  por muy modesto que sea )   y ademas el grado de personalización  pues podemos añadir el café que mas nos guste en la proporciona que deseemos

Hablando de personalización ,si la rutina es demasiado grande (es decir, para la prensa francés), entonces tendrá un sabor débil y acuoso

Si usted tiene la rutina adecuada (que se pueden hacer en la mayoría de las casas de café o incluso en su supermercado local por sí mismo), entonces el resultado puede ser casi tan bueno como las vainas Nespresso.

También tiene que averiguar (fácilmente después de 3 o 4 pruebas) la cantidad de café espresso a añadir  y lo difícil de “apisonar” es decir de  presión del café.

 

CAM00030.jpg

CAM00032.jpg

CAM00031.jpg

Compatible con:

  •  Essenza Essenza de Krups y   U & Umilk
  •  Lattissima y Lattissma +
  •  Inissia  pixe
  •  CitiZ y CitiZ leche
  •  Gran Maestria y Maestria
  •  Concepto
  •  Le Cube

 

No es compatible con:

  •  Citiz D110
  •  En Delonghi Nespresso 97. W
  •  Nesspress vertuoline
  •  Nespresso casa modelo C150 y C250 uso empresarial
  •  Nespresso modelo, como: Agula, GEMIN, ZENUS.
  • Dolce Gusto

capsulas.png

Por cierto, estas capsulas reutilizables  de calidad  se pueden comprar por unos 10€  en Amazon, lo cual en conjunto nos permitirán como mínimo hacer  unos 250 tomas  de nuestro mejor cafe favorito  ,los cuales  costarían  unos 125€ en formato desechable

 

Captura de video en windows


Es posible que por motivos tan diversos como crear un vídeotutorial en youtube o capturar una partida de un videojuego, necesitemos grabar en vídeo las acciones que realizamos en la pantalla de nuestro ordenador, incluso con nuestra voz de apoyo, o añadiendo la actividad de nuestra webcam.

 

Microsoft tiene un software para editar vídeo muy interesante llamado Expression Encoder 4. Existen varias versiones de pago, mucho más completas como Studio Web Pro (149 dólares), Expression Encoder 4 Pro (199 dólares) y Studio Ultimate (599 dólares).

Sin embargo, Expression Encoder 4 es gratuito y pueden realizarse tareas de edición, así como capturar actividad en pantalla con el codec Expression Encoder Screen Capture  qeu lleva incorporado en su ultima versión

Con este sw como vamos a ver podemos capturar nuestro escritorio, webcam e incluso streaming con resultados de muy alta calidad  .El interfaz es muy potente dando muchísimas posibilidades tanto de edición como de exportación de los resultado a cualquier formato comercial

Para capturar cualquier cosa  que pase por la pantalla, iniciaremos Microsoft Expression Encoder 4 Screen Capture
capture
Una vez iniciado el programa  , daremos al botón rojo de grabación  (el que esta situado en la esquina superior derecha) para iniciar la configuración inicial del capturadoe del video.
recorte microsoft encoder
Ahora aparecerá un recuadro rojo completamente parametrizable que ajustemos al tamaño que nos interese (por supuesto incluso puede capturar en pantalla completa)
Acto seguido, cuando hayamos fijado el área capturar, pulsaremos al botón rojo de grabación para  empezar la captura de video
Veremos que enseguida aparece un recuadro para pausar  o cancelar la grabación , al tiempo que nos informa del tamaño  y la duración del vídeo
 botonrd
Una vez decidamos parar la grabación el trabajo nos aparecerá  reflejado en la pantalla inicial con extensión .xsec
Es momento de la post-edicion ,para lo cual situándonos sobre el fichero .xseco   pulsaremos sobre el botón “send to encoder” , lo cual provocara que se ejecute el encoder automáticamente  con el fichero  citado
encoder
En el encoder sobra decir que tenemos una amplisimo repertorio de herramientas y opciones como recortar ,cambiar calidad de audio y video, añadir subtitulos,etc
video
Si simplemente queremos convertir nuestra captura a un archivo multimedia , llevaremos al marcador al final del video y pulsaremos
File –>Encode  selected item
Un vez finalizado el trabajo , el fichero quedara en la ruta  C:\Users\miusuario\Documents\Expression\Expression Encoder\Output

URL | Expression Encoder 4 ~28MB

Nuevos sistemas de carga


Los cables microUSB, se han convertido  en un estándar de de facto para cargar no solo nuestro smartphone  sino todos nuestros gadgets como cámaras,navegadores,reproductores de mp3,etc. Desgraciadamente estos cables  terminados en microusb no son tan ergonómicos como podría esperarse  , quizás  por culpa de su reducido espacio ,  haciendo que tengamos que rotarlos muchas  veces 180 grados para que encaje: da igual lo que hagamos, es algo que está por encima de la comprensión humana.

En efecto los cables microusb son un engorro pues para empezar necesitamos las dos manos libres para realizar la conexión y un buen ojo para encajar el conector en su posición correcta, ademas es sabida esta molestia por parte de los fabricante que de hecho todo parece  apuntar que desaparecerá  en  el futuro el conector microusb realizándose la carga de modo inalámbrico ( de hecho ya  se puede acoplar un receptor de carga   a cualquier smartphone como vimos en este post).

Mientras tengamos este conector , no obstante surgen nuevas ideas que nos pueden aliviar esa molestia  como la que vamos a ver …

Fruto de la innovación intentado solucionar los  muchos problemas de los conectores  micro-usb en efecto han surgido los sistemas de carga magnéticos  basado en un pequeño “tapón” magnético que se conecta a la entrada USB del terminal y un simple adaptador que se coloca en el cable, de forma que basta con acercar el cable al terminal  éste encajará automáticamente solo gracias a la “magia” del magnetismo. Además, permite sincronizar datos perfectamente.

Ademas, este  sistema es reversible, por lo que da igual de que lado acerquemos el cable, pues en  ambos lados  se enchufará igualmente, lo cual es ciertamente interesante para no  estar pendiente de   revisar de que lado ponemos el conector

El “tapon -conector” que introducimos en el terminal mide 9,25 milímetros de ancho, y sobresale  muy poco (1,5 de profundo y 4,75 mm de alto), mientras que el adaptador del cable  propiamente dicho mide 12 mm( mas o  menos lo que mide un conector “normal”) .
cable-magnetico

Pero la comodidad de este sistema  no es la única ventaja,  pues hay otra ventaja ya que  estos  adaptadores  son a prueba de polvo y suciedad, y por supuesto  también de agua o líquidos  por lo que protegerá nuestro  terminal de  posible salpicaduras en la zona del conector de carga

!ah y por cierto algunos modelos de cables magnéticos  incluyen  una luz LED que nos confirmará que el teléfono está cargando correctamente.

Respecto al precio no es muy disparatado pues por menos  5€  con gastos de envió se puede conseguir en Amazon 

 

Posiblemente este tipo de cables sea la mejor opción para todas aquellas personas que tengan dificultades para cargar no solo  teléfonos Android sino  tabletas que se carguen por el  puerto Micro USB( como la mayoria de modelos de Samsung, Xiaomi, Meizu, Huawei, HTC, Oneplus, Google, Blackberry,etc )  o incluso para cámaras digitales, juguetes o  iPad.

Como habilitar gratuitamente Google Analitycs en wordpress.com


Google Analytics es una herramienta gratuita que permite monitorizar todo el tráfico de un sitio web pudiendo conocer datos importantes acerca de los usuarios como pueden ser el comportamiento de los usuarios,procedencia, tipo de plataforma,nevegador ,etc  ,todo  ellos estadistas  que van  a permitir cambiar los esfuerzos de sus creadores orientándolos a un correcto funcionamiento del  sitio web.

Gracias a que blogger  es un producto de Google , el producto Google Analitycs viene integrado por defecto ,por lo que desde el primer momento tendrán disponible el servicio  ,pero para las personas que tengan un blog alojado en wordpress.com  la situación es bien distinta pues como para poder utilizar Google Analytics, además de registrarse en este servicio, es necesario configurar un perfil y copiar el código Javascript correspondiente en el HTML , y en wordpress.com no esta admitido javascript ( a no ser que contratemos el servico premium) de partida no es una tarea sencilla a no ser que deseemos pagar por ello …,pero no se preocupe pues existen algunas otras opciones.

planes

 

 

Cloudflare es un servicio para webs que ofrece multitud de opciones y beneficios para usuarios medianamente avanzados (seguridad, velocidad…)así como también puede servir para habilitar de forma sencilla la monitorización de estadísticas con Google Analytics.

En este caso, el único requisito es tener el blog con dominio propio, contratado el servicio “Custom Domain” de WordPress.com. Son 18$ al año. Es decir, sería la opción más económica de todas. Este coste es similar a lo que nos costaría contratar un dominio propio en cualquier otro proveedor. Así que es buena opción.

Los pasos a seguir serían los siguientes:

  • Lo primero de todo, tal y como hemos indicado anteriormente, es crear una cuenta en Google Analytics y configurar un perfil  para nuestro blog, obteniendo la ID de seguimiento.
  • Lo segundo: acceeder a Cloudflare:

cloudflare.PNG

Con el la opción gratuita es suficiente,asi  que accederemos a este formulario de acceso directo : https://www.cloudflare.com/a/sign-up

cloud2

Una vez registrado en Cloudflare, es necesario crear un perfil para el blog, introduciendo el dominio.

cloud1

Ahora nos mostrara los servidores de DNS que atienden a nuestro dominio

dns

Después nos toca seleccionar el plan  gratuito:

plan

Acto seguido ,Cloudflare nos indicará que debemos cambiar los registros DNS de nuestro dominio.

changeto

status

  • Para cambiar los DNS de nuestro dominio hay que acudir al administrador de dominios de WordPress.com,  para lo cual  tenemos que acceder al panel de administrador de wordpress. Alli  nos  iremos a Tienda–>Mis dominios

misdominios

  • Pulsaremos ahora en Editar dominios y seleccionaremos la segunda opción: servidores de DNS

servidoes-de-nombres

  • Aquí es donde debemos modificar los registros de DNS, sustituyendo los existentes por los que nos ha indicado CloudFlare (puede encontrar más información (en inglés) aquí.)

  • Tras haber actualizado los registros DNS del dominio, debe volver al administrador de aplicaciones de Cloudflare.
  • Debe hacer click en “Administrar APP”, elegir el dominio de tu blog anteriormente configurado, buscar Google Analytics en las aplicaciones y  volver a hacer click en “Setup” y añadir la ID  previamente obtenida en Google Analytics. Siguiendo este link llegará a la APP Google Analytics

google-analitycs

getcode

cloudflare_analytics3

 

 

on

 

Ahora si volvemos al panel de apps  veremos que esta activado Google analytics para nuestro sitio web

 

ga

 

 

Aparte de la opción comentada  existen otras tres opciones:

  • NOJSSTATS: GOOGLE ANALYTICS SIN JAVASCRIPT:Esta es la forma más sencilla de habilitar Google Analytics en un blog de WordPress.com. Se puede utilizar tanto en un blog con dominio propio (tublog.com) como en un blog alojado en un subdominio de WordPress.com (ejemplo.wordpress.com). El único requisito es adquirir al menos el más económico de los planes de pago de WordPress.com, llamado “Custom design“(30$/año),lo cual  nos permitirá editar el CSS.
  • MIGRACIÓN A HOSTING PROPIO: Instalar WordPress en un hosting propio ,  permite instalar Google Analytics por la vía normal (manualmente o con algún plugin). Muchos proveedores, como Dreamhost, ofrecen la opción de instalar y configurar WordPress de forma muy sencilla, a través de lo que se llama “one click install”.Hay que dedicarle un poco de tiempo para poder aprender todas las opciones que puede ofrecer, y configurarlas sin riesgo.  Se pueden instalar nuevos temas, personalizarlos a su antojo, utilizar infinidad de plugins… Es la única forma de tener control total sobre su blog.
  • WORDPRESS VIP :La única opción de mantener su blog en WordPress.com y poder tener el mayor control posible de tu blog es contratando el servicio VIP. El plan más sencillo cuesta 3750$… ¡al mes! Es preferible hacer una inversión de tiempo y montar su blog en hosting propio, o acudir a alguna empresa que se lo pueda hacer a un precio más asequible (dependiendo de la customización que quiera).

 

Cambiar servidores de nombres en wordpress


Cuando usted registra un dominio con WordPress.com, estos  apuntan a su blog de WordPress.com. Pero no tiene que usarlo de esa manera, usted puede hacer que su dominio apunte a cualquier sitio que quiera.

Si usted está moviendo su sitio a otro host, nos proponen transferir su dominio al nuevo host para que su dominio y su hosting sean administrados en el mismo lugar.

En algunos casos sin embargo, esta opción puede no estar disponible. Por ejemplo, si usted acaba de registrar su dominio, no podrá transferirlo por 60 días. También, algunos anfitriones simplemente no soportan transferencias de registro de dominio.

Puede apuntar su dominio a su nuevo anfitrión incluso si no puede transferir el registro, por cambio de servidores de nombres de dominio.

Cambio de servidores de nombres

Puede gestionar su dominio en la opción dominios del panel de wordpres de administracion, haciendo clic en el dominio que desee administrar.

select_domain

Para cambiarlo haga clic en DNS y servidores de nombres.
edit_dns

De forma predeterminada, los servidores de nombre se establecerá en    WordPress.com name servers ( servidores de nombres de WordPress). Para cambiar los servidores de nombres, cambiar esto apagado haciendo clic en el deslizador a la derecha.
update_name_servers

Vuelva a colocar los servidores de nombre de WordPress.com con servidores de nombre de su host nuevo. Debe introducir al menos dos servidores de nombres o  hasta cuatro el apoyo.
change_nameservers

Haga clic en el botón azul de Servidores de nombres de costumbre guardar para guardar los cambios.

Los cambios pueden tomar hasta 72 horas para llegar a ser activo, pero por lo general toma sólo unos minutos.

Conocer los nuevos servidores de nombre

Los nuevos servidores de nombre que necesitará entrar dependen de su nuevo host. La mejor manera de saber es buscar la sección de ayuda de su anfitrión o en contacto con su apoyo. Esta es una lista de servidores de nombres para hosts popular:

Nota: Para apuntar su dominio a un sitio alojado con GoDaddy, puede seguir estas instrucciones en lugar de otro.

 

En próximo post veremos una de las utilidades de cambiar los DNS’s en wordpress: utilizar un servicio de terceros para poder usar Google Analytics con una cuenta de worppress que tenga asociado un dominio

Fuente wordpress.com

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 Android no es tan complicado (parte 2)


En un post  anterior veíamos que  el panorama del entorno necesario para programar un aplicación   que se ejecute sobre cualquier dispositivo Android  ha cambiado sustancialmente  reduciéndose  simplemente a una potente herramienta   gratuita  , que ademas proporciona Google: Android Studio.

En este  post seguiremos  profundizando en el desarrollo de aplicaciones con Android Studio deteniéndonos en uno de los aspectos mas llamativos de cualquier aplicación : la  interfaz gráfica de usuario

Android proporciona un vocabulario de XML que corresponde a las subclases de View y ViewGroup, de modo que puede definir su IU en XML usando una jerarquía de elementos de IU y  los diseños son subclases de ViewGroup

Generalmente, los objetos View son widgets de IU como botones o campos de texto y los objetos ViewGroup son contenedores de vistas invisibles que definen la disposición de las vistas secundarias, como en una cuadrícula o en una lista vertical.

 

 

 

 

Diseño interfaz

Aunque existen infinitas  posibilidades de diseño del interfaz ,para empezar,  usaremos un diseño sencillo lineal que coloca todos los elementos gráficos uno a continuación del otro:

  • En la ventana Project de Android Studio, abra el fichero activity_main.xml( app > res > layout > activity_main.xml).Este archivo XML define el diseño de tu actividad y contiene la vista de texto predeterminada “Hello World”.
  • Cuando abra un archivo de diseño, lo primero que ve es el editor de diseño, pero muchos programadores prefieren trabajar directamente con el XML; por lo tanto, haga clic en la pestaña Text en la parte de abajo de la ventana para pasar al editor de texto.
  • Borre todo el contenido del fichero  e introduzca  el siguiente XML:
    <?xml version="1.0" encoding="utf-8"?>
    <LinearLayout
        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:orientation="horizontal">
    </LinearLayout>

LinearLayout es un grupo de vistas (una subclase de ViewGroup) que dispone las vistas secundarias en sentido vertical u horizontal, según lo especificado por el atributo android:orientation. Cada elemento secundario de un LinearLayout aparece en la pantalla en el orden en que aparece en XML.

Se necesitan otros dos atributos, android:layout_width y android:layout_height, para especificar el tamaño de todas las vistas.

Debido a que LinearLayout es la vista de raíz en el diseño, debería ocupar el área de la pantalla completa que está disponible para la app al establecer el ancho y el alto en "match_parent". Este valor declara que la vista debería expandir su ancho o alto para coincidir con el ancho o alto de la vista primaria.

Agregar un campo de texto

En el archivo activity_main.xml, dentro del elemento <LinearLayout>, agregue el siguiente elemento <EditText>:

<LinearLayout
    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:orientation="horizontal">


   <EditText android:id="@+id/edit_message" 
    android:layout_weight="1"
    android:layout_width="0dp" 
    android:layout_height="wrap_content"
    android:hint="@string/edit_message" />


</LinearLayout>

A continuación, se ofrece una descripción de los atributos del <EditText> que ha agregado:

  • android:id:Esto proporciona un identificador único para la vista, que puede usar para hacer referencia al objeto desde elcódigo de la app, como leer y manipular el objeto .El signo de arroba (@) se requiere cuando se hace referencia a cualquier objeto de recursos de XML y va seguido por el tipo de recursos (id en este caso), una barra diagonal y el nombre del recurso ().El signo más (+) antes del tipo de recurso se necesita solo cuando se está definiendo un ID de recurso por primera vez. Cuando compila la app, las herramientas del SDK usan el nombre del ID para crear un nuevo ID de recurso en el archivo R.java de tu proyecto que hace referencia al elemento EditText. Con el ID de recurso declarado una vez de esta forma, otras referencias al identificador no necesitan el signo más. Es necesario el uso del signo más solo cuando se especifica un nuevo ID de recurso y no se necesita para los recursos concretos, como strings o diseños. Consulta el cuadro lateral para más información sobre los objetos del recurso.
  • android:layout_width y android:layout_height:En lugar de usar tamaños específicos para el ancho y el alto, el valor "wrap_content" especifica que la vista solo debe ser lo suficientemente grande para ajustarse al contenido de la vista. Si en cambio usa "match_parent", el elemento EditText ocupará la pantalla porque coincidirá con el tamaño del elemento primario LinearLayout. Para más información, consulta la guía de Diseños.Fijar el ancho en cero (0 dp) hace que la casilla de entrada ocupe el ancho de pantalla y mejora el rendimiento del diseño, ya que el uso de "wrap_content" como ancho exige que el sistema calcule un ancho, lo cual a la larga es irrelevante porque el valor de peso requiere otro cálculo de ancho para completar el espacio restante.
  • android:hint :Esta es una string predeterminada para mostrar cuando el campo de texto esté vacío. En lugar de usar una string codificada como valor, el valor "@string/edit_message" hace referencia a un recurso de string definido en un archivo separado. Debido a que esto hace referencia a un recurso concreto (no simplemente un identificador), no necesita el signo más. Sin embargo, debido a que aún no se ha  identificado el recurso de string, aparecera  un error del compilador. Este recurso de string tiene el mismo nombre que el ID del elemento: edit_message. Sin embargo, las referencias a los recursos siempre tienen ámbitos por tipo de recurso (como id o string); por lo tanto, usar el mismo nombre no genera conflictos.

 

Agregar recursos

De manera predeterminada, en un proyecto de Android se incluye un archivo de recursos en string en  un  fichero  llamado    strings.xml ( res > values > strings.xml) .

Parar, agregar  strings nuevas al fichero strings.xml siga los siguientes pasos.

  1. Desde la ventana Project, abra res > values > strings.xml.
  2. Agregue dos strings de modo que el archivo se vea de esta forma:
    <?xml version="1.0" encoding="utf-8"?>
    <resources>
        <string name="app_name">My First App</string>
        <string name="edit_message">Introduzca un mensaje</string>
        <string name="button_send">Enviar</string>
    </resources>

Para el texto en la interfaz de usuario, siempre especifique cada string como un recurso. Los recursos de strings de texto  permiten administrar todos los textos de IU en una sola ubicación, lo que hace que sea mucho  más fácil encontrar y actualizar el texto.

Externalizar las strings también  permite localizar su aplicacion ara diferentes idiomas al proporcionar definiciones alternativas para cada recurso de string.

 

Agregar un botón

Vuelva al archivo activity_main.xml y agregue un botón después del widget <EditText>.

El archivo debería tener el siguiente aspecto:

      
  <Button
          android:layout_width="wrap_content"
          android:layout_height="wrap_content"
          android:text="@string/button_send" />

Como vemos este botón no necesita el atributo android:id porque no se hará referencia a él desde el código de la actividad.

Actualmente, la configuración del diseño hace que los widgets EditText y Button tengan el tamaño necesario para ajustarse a su contenido, como se muestra a continuación

Esto funciona bien para el botón, pero no tan bien para el campo de texto porque el usuario podría escribir algo más largo. Sería bueno rellenar el ancho de la pantalla excedente con el campo de texto. Puedes hacerlo dentro de un LinearLayout con la propiedad de peso, que puedes especificar usando el atributo android:layout_weight.

El valor weight es un número que especifica la cantidad del espacio restante que cada vista debería consumir, relativo a la cantidad consumida por vistas del mismo nivel. Esto funciona como la cantidad de ingredientes en una receta de una bebida: “2 partes de refresco, 1 parte de sirope” significa que dos tercios de la bebida son de refresco. Por ejemplo, si le das a una vista un valor de weight de 2 y a otra un valor de weight de 1, la suma es 3, de manera que la primera vista completa 2/3 del espacio restante y la segunda vista completa el resto. Si agregas una tercera vista y le das un valor de weight de 1, la primera vista (con un peso de 2) ahora obtiene 1/2 del espacio restante, mientras que las dos restantes obtienen 1/4.

El valor de weight predeterminado para todas las vistas es 0, de manera que si especificas cualquier valor de weight superior a 0 para solo una vista, dicha vista completa el espacio restante después de que se asigne el espacio requerido a todas las vistas.

El resultado de modificar el  fichero   activity_main.xml, deberia ofrecer el siguiente aspecto:

 

Lo siguiente es qué apariencia debería tener el archivo de diseño activity_main.xml completo:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
   xmlns:tools="http://schemas.android.com/tools"
   android:orientation="horizontal"
   android:layout_width="match_parent"
   android:layout_height="match_parent">
    <EditText android:id="@+id/edit_message"
        android:layout_weight="1"
        android:layout_width="0dp"
        android:layout_height="wrap_content"
        android:hint="@string/edit_message" />
    <Button
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="@string/button_send" />
</LinearLayout>


Dar funcionalidad al  botón

Una vez hemos definido el botón  tenemos asignarle una funcionalidad, para lo cual podemos seguir los siguientes pasos:

  1. En el archivo res > layout > activity_main.xml, agrega el atributo android:onClick al elemento <Button>, como se muestra a continuación:
    <Button
          android:layout_width="wrap_content"
          android:layout_height="wrap_content"
          android:text="@string/button_send"
          android:onClick="sendMessage" />
        

    Este atributo indica al sistema que llame al método sendMessage() de tu actividad cuando un usuario haga clic en el botón.

  2. En el archivo java > com.example.myfirstapp > MainActivity.java, agregar el código auxiliar del método sendMessage() como se muestra a continuación:
    public class MainActivity extends AppCompatActivity {
        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);
            setContentView(R.layout.activity_main);
        }
    
        /** Called when the user clicks the Send button */
        public void sendMessage(View view) {
            // Do something in response to button
        }
    }

    Para que el sistema haga coincidir este método con el nombre del método proporcionado a android:onClick, la firma debe ser exactamente como se muestra. Específicamente, el método debe:

    • Ser público
    • Tener un valor de retorno vacío
    • Tener un objeto View como el único parámetro (esto será el View al que se le hizo clic)

Luego, completarás este método para leer el contenido del campo de texto y entregar dicho texto a otra actividad.

Crear una intent

Un Intent es un objeto que proporciona enlace de tiempo de ejecución entre componentes separados (como dos actividades) representando la “intención de hacer algo” de una app.

En el fichero MainActivity.java, agregue el código que aparece a continuación para sendMessage():

public class MainActivity extends AppCompatActivity {
    public final static String EXTRA_MESSAGE = "com.example.myfirstapp.MESSAGE";
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }

    /** Called when the user clicks the Send button */
    public void sendMessage(View view) {
        Intent intent = new Intent(this, DisplayMessageActivity.class);
        EditText editText = (EditText) findViewById(R.id.edit_message);
        String message = editText.getText().toString();
        intent.putExtra(EXTRA_MESSAGE, message);
        startActivity(intent);
    }
}

Android Studio mostrará errores Cannot resolve symbol porque este código hace referencia a clases que no están importadas. Puede resolver algunos de estos errores con la funcionalidad de “importación de clase” de Android Studio presionando Alt + Intro (u Opción + Regresar en Mac).

Sus importados deben terminar de la siguiente forma:

import android.content.Intent;
import android.support.v7.app.AppCompatActivity;
import android.os.Bundle;
import android.view.View;
import android.widget.EditText;

En sendMessage() tienen lugar muchísimos procesos. Por ello, explicaremos lo que sucede.

El constructor de Intent toma dos parámetros:

  • Un Context como su primer parámetro (se usa this porque la clase Activity es una subclase de Context)
  • La Class del componente de la app a la cual el sistema debe entregar la Intent (en este caso, la actividad que debería iniciarse).

    Nota: La referencia a DisplayMessageActivity emitirá un error en Android Studio porque la clase aún no existe. Ignora el error por ahora; pronto crearás la clase.

El método putExtra() agrega el valor de EditText a la intent. Una Intent puede llevar tipos de datos como pares clave-valor denominados extra. La clave es una EXTRA_MESSAGE constante pública porque la actividad siguiente usa la clave para devolver el valor de texto. Es bueno definir claves para los campos extra de intents usando el nombre del paquete de tu app como prefijo. Esto garantiza que las claves sean únicas, en caso de que tu app interactúe con otras apps.

El método startActivity() inicia una instancia del DisplayMessageActivity especificado por la Intent. Ahora debes crear la clase.

Crear la segunda actividad

  1. En la ventana Project, haz clic con el botón secundario en la carpeta app y selecciona New > Activity > Empty Activity.
  2. En la ventana Configure Activity, ingresa “DisplayMessageActivity” en Activity Name y haz clic en Finish

Android Studio automáticamente realiza tres acciones:

  • Crea el DisplayMessageActivity.java de la clase con una implementación del método onCreate() obligatorio.
  • Crea el archivo de diseño activity_display_message.xml correspondiente.
  • Agrega el elemento <activity> obligatorio en AndroidManifest.xml.

Si ejecutas la app y haces clic en el botón Send en la primera actividad, la segunda actividad se iniciará, pero estará vacía. Esto sucede porque la segunda actividad usa el diseño predeterminado vacío proporcionado por la plantilla.

Mostrar el mensaje

A continuación puede, modificar la segunda actividad para que muestre el mensaje que pasó la primera.

  1. En DisplayMessageActivity.java, agregue el siguiente código al método onCreate():
    @Override
    protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);
       setContentView(R.layout.activity_display_message);
    
       Intent intent = getIntent();
       String message = intent.getStringExtra(MainActivity.EXTRA_MESSAGE);
       TextView textView = new TextView(this);
       textView.setTextSize(40);
       textView.setText(message);
    
       ViewGroup layout = (ViewGroup) findViewById(R.id.activity_display_message);
       layout.addView(textView);
    }
  2. Presione Alt + Intro (u Opción + Regresar en Mac) para importar las clases faltantes. Los importados deben tener la siguiente terminación:
    import android.content.Intent;
    import android.support.v7.app.AppCompatActivity;
    import android.os.Bundle;
    import android.view.ViewGroup;
    import android.widget.TextView;

Tienen lugar muchísimos procesos. Veamos la explicación:

  1. La llamada getIntent() captura la intent que inició la actividad. Toda Activity se invoca a través de una Intent, independientemente de cómo el usuario navegue hasta el punto en cuestión. La llamada getStringExtra() muestra los datos de la primera actividad.
  2. De manera programática, se crea un elemento TextView y se establece el tamaño y mensaje de este.
  3. Se agrega el elemento TextView al diseño identificado por R.id.activity_display_message. Se transmite el diseño a ViewGroup porque es la superclase de todos los diseños y contiene el método addView().

Nota: Es posible que el diseño XML generado por versiones anteriores de Android Studio no incluya el atributo android:id. La llamada findViewById() fallará si el diseño no tiene el atributo android:id. En este caso, abra el fichero  activity_display_message.xml y agregue el atributoandroid:id="@+id/activity_display_message" al elemento de diseño.

Ejecucion de  la app

Para ver el aspecto que ahora tendrá su  app en tu dispositivo, haga clic en Run en la barra de herramientas .

Cuando se abra, escriba un mensaje en el campo de texto y haga clic en Send. La segunda actividad reemplaza a la primera en la pantalla, con lo cual se mostrara el mensaje que ingresoe en la primera actividad.

Eso es todo. ¡Ha creado una  nueva app de Android!

 

Mas información en  developer.android.com