Como recompilar una aplicación en Android en otra version


Si esta  desarrollando un aplicación con Android Studio  , en el momento que se crea un proyecto nuevo habrá especificado el  API LEVEL de la  aplicación Android

Seguro que con bastante esfuerzo habrá desarrollado partir de la estructura inicial  su aplicación basándose en esa especificación ,pero una vez  finalizado el desarrollo  ( y las pruebas de la app) si  intenta subirla a Google Play,  quizás  en un segundo intento vez, habrá visto que da error en la subida del APK debido a que ya tiene un archivo con ese código de versión.

Este problema  también le puede ocurrir cuando desee probar su aplicación con otro terminal   que   cuente con una versión de Android inferior

En este post precisamente  vamos  a ver cómo cambiar el código de versión de una aplicación Android o el nivel del  API  para  solucionar  precisamente los problemas comentados  .Como vamos a ver es un procedimiento realmente sencillo, y no debería llevarnos ninguna complicación.

En primer lugar,  veamos  en la siguiente tabla las diferentes versiones del nivel de API de Android  en relación a la versión  que todos conocemos : la versión de la Plataforma

Versión de la plataforma Nivel de API VERSION_CODE
Android 7.0 24 N
Android 6.0 23 M
Android 5.1 22 LOLLIPOP_MR1
Android 5.0 21 LOLLIPOP
Android 4.4W 20 KITKAT_WATCH
Android 4.4 19 KITKAT
Android 4.3 18 JELLY_BEAN_MR2
Android 4.2 y 4.2.2 17 JELLY_BEAN_MR1
Android 4.1 y 4.1.1 16 JELLY_BEAN
Android 4.0.3 y 4.0.4 15 ICE_CREAM_SANDWICH_MR1
Android 4.0, 4.0.1 y 4.0.2 14 ICE_CREAM_SANDWICH
Android 3.2 13 HONEYCOMB_MR2
Android 3.1.x 12 HONEYCOMB_MR1
Android 3.0.x 11 HONEYCOMB
Android 2.3.4 10 GINGERBREAD_MR1
Android 2.3.3
Android 2.3.2 9 GINGERBREAD
Android 2.3.1
Android 2.3
Android 2.2.x 8 FROYO
Android 2.1.x 7 ECLAIR_MR1
Android 2.0.1 6 ECLAIR_0_1
Android 2.0 5 ECLAIR
Android 1.6 4 DONUT
Android 1.5 3 CUPCAKE
Android 1.1 2 BASE_1_1
Android 1.0 1 BASE
Si por la razón que sea  quiere cambiar el API Level, por ejemplo de API  16 ( correspondiente a : Android 4.1 Jelly Bean)  a API 22 ( correspondiente a : Android 5.1.0 (Lollipop)  sólo hay que seguir los siguientes pasos:
  •  Buscar la carpeta app del menú desplegable “Project” ( o la carpeta que contenga el nombre de nuestra app )
  •  Pulsación en el  Botón derecho => OPEN MODULE SETTINGS:
openmodules.png
  •  Nos aparecerá  otro menú  con cinco pestañas  posicionándose por defecto en Properties  donde especificamos la versión del complilador , la cual recomendamos dejar en la máxima versión( 7.1.1):
properties.PNG
  • Haremos clic sobre la tercera pestaña FLAVORS:
ejmplo
  •  Aparecen en esta pantalla   el nivel dela API minimo y  otras parametros . Pincharemos en el desplegable de MIN SDK VERSION, donde podemos escoger el nuevo API LEVEL ( clic sobre la flecha )  que deseemos:
androidversionmion
Una vez situados aquí, también  podemos  cambiar el código de la versión del APK, que es efectivamente el que tenemos seleccionado. El primer APK por defecto lleva versionCode 1, pero la siguiente versión debe llevar el 2 y así sucesivamente, de ahí a quGoogle Play de error si subimos un APK con la misma versionCode o código de versión.Lo que haremos será tan sencillo como cambiar la Version Code cada vez que generamos una nueva versión de la aplicación, es decir, un nuevo APK a publicar. Una vez hecho esto, tan solo tendremos que guardar el proyecto y volver a generar el APK.
  • GRADLE reconstruirá  automáticamente todo el proyecto ( SYNC )  al  darle al botón Aceptar
  • Este proceso podemos repetirlo cuantas veces deseemos con diferentes versiones para adaptar nuestro proyecto a las diferentes versiones de Android
 Con esta actuación ( y todas las que deseemos )   habremos configurado el fichero  build.gradle (Module:app) de forma segura   y  completamente funcional.

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

Usos para el OTG


USB On The Go es una de las funciones más olvidadas de Android,  y eso  a pesar de que la mayoría de terminales tiene soporte para esta tecnología por lo que estamos hablando de una característica que pasa muy desapercibida de cara al gran público. 

La tecnología OTG (On-The-Go) permite que el puerto USB de un dispositivo Android se pueda explotar de muchas formas diferentes siendo la más conocida de ellas  la posibilidad de conectar un ratón o teclado en el dispositivo, sin embargo, otros periféricos pueden ser de extrema utilidad cuando se utilizan correctamente en un dispositivo compatible con USB OTG Android.

El OTG es una tecnología para la que, en algunos usos muy concretos, se necesita un cable especial o adaptador para llegar a aprovechar todas las posibilidades que abarca  ofreciendonos una multitud de opciones que van desde conectar una memoria USB de forma directa a nuestro smartphone o cargar un terminal utilizando la batería de otro.

Los teléfonos de gama media y alta ya incluyen esta función, sin embargo l mejor es confirmar de forma directa en las especificaciones(detalles) técnicas del modelo, consultando por ejemplo la página web-site del fabricante  o también  instalando alguna app que detecte si su  smartphone  cuenta con esta función, como por  ejemplo USB OTG Checker para Android.

En esta recopilación hemos incluido algunos de los usos más atractivos de esta tecnología para permitir descubrir  todos los misterios sobre esta tecnología y aprende a usar un pendrive OTG para expandir la memoria de tu Android.

 

Antes de empezar, de las aplicaciones  posibles del uso  conector OTG, lo primero es adquirir un cable OTG ( on the go) que nos permitirá como vamos a ver  que ciertos dispositivos, por ejemplo: cámara fotográfica o teléfono móvil, actúen como host, por lo que se les puede conectar una memoria USB, un ratón, un teclado, un disco duro, un módem, etc

El longitud de  estos cables suele ser corta (tipicamente y 12cm) ,pero suficiente para conectar directamente a los tablets y móviles de android o de windows con función de OTG, para ver los fotografías, transforman los datos desde drivers o compilar archivos con el teclado o el ratón.

Otra opción interesante es  la  función de cargador, Se cargará los dispositivos USB cuando conecte dos teléfonos inteligentes, el host es el estado de salida de potencia cargador otro teléfono. (lógicamente no son soportado utilizar simultáneamente los función de OTG y de cargador)

 

 

Dado que las posibilidades son muy amplias, estos son algunos ejemplos de cosas que puedes hacer con un USB OTG.

  1. Pasar archivos de una memoria USB o disco externo al teléfono:Es posible que sea la opción que tenga un público más amplio. Pasar archivos de un pendrive a tu smartphone puede ser tan sencillo como conectar la memoria externa al teléfono. No es tan simple en el caso del disco duro externo y dependemos un poco del formato. Para que todo sea más sencillo necesitamos que esté configurado en FAT32.Las memorias USB, sin embargo, resultan mucho más fáciles de conectar. Sólo hay que poner a un lado del cable el Pendrive y a otro el smartphone via el cable adaptador OTG. Tambien existen memorias duales con conexion OTG y USB                                                                                                                                          .
  2. Antenas de televisión

    Hace unos años, las televisiones portátiles intentaron entrar en el mercado, pero no consiguieron mucho éxito. Ahora podemos intentar ver la televisión desde nuestro Android conectando una antena.

    Este es un complemente delicado, pues tenemos que asegurarnos que funcione con la frecuencia española de televisión y que incluya decodificado. Es un poco engorroso, pero nos podemos asegurar de ver la televisión sin gastar datos móviles cuando estamos fuera de nuestra casa. Eso sí, si estamos en transporte público debemos tener cuidado de no sacar el ojo a alguien con la antena

  3.  – Utilizar cualquier mando USB con Android:Otra opción tremendamente útil para los gamers. Hay muchos juegos para Android -especialmente adaptados de otras plataformas- que no se controlan bien con la pantalla táctil, y la posibilidad de usar el mando, por ejemplo, de la PlayStation es muy atractiva.No es muy diferente a cuando se conecta un mando por bluetooth y en teoría muchos gamepads que no son de consolas deberían funcionar al instante. Acto seguido tendra que configurarlo para cada juego, aunque en los emuladores de consolas se puede hacer de forma más sencilla.Es posible que los botones para manejar el juego no sean los habituales, pero es cuestión de acostumbrarse.Existen mandos optimizados (como el de Nexus Player). Aún así igual podemos reutilizar un viejo gamepad y darle una nueva vida.
  4. Conectar un teclado o un ratón:Esta es una de las funciones que pueden ser cubiertas muy fácilmente por el Bluetooth, aunque eso puede repercutir en la autonomía del terminal. Conectarlo a través de USB OTG puede ser una alternativa interesante.

 

  1. Convertir tu smartphone en el mando de tu cámara réflex:Hay una buena cantidad de cámaras réflex que incluyen aplicaciones que permiten controlarlas remotamente a través de WiFi o Bluetooth, pero hay otras que pueden ser controladas a través de la conexión USB. Quizá no sea tan versátil como la conexión inalámbrica, pero evitará vibraciones en exposiciones largas.           Uno de los usos más potentes de una tablet reside en sumar sus virtudes junto a las de una cámara DSLR. Además de presenciar la escena a capturar en una pantalla de gran formato, es interesante controlar aspectos como el enfoque o el tiempo de exposición desde nuestro Android. Los amantes de la fotografía, sin duda, disfrutarán de esta gran cualidad del formato OTG.
  2. – Conectarse a Internet por cable:¿Estás en una cueva prehistórica donde hay conexión peor cable pero no WiFi? ¿O estás descargando una aplicación grande y quieres que vaya más rápido? Con el adaptador adecuado podrás conectar tu smartphone a la red LAN a través de un cable ethernet.
  3. Imprimir desde su smartphone:Si tiene una impresora que no tiene conexión inalámbrica pero tienes el archivo que tienes que imprimir en el teléfono, puedes conectar ambos dispositivos a través de OTG.No es imprescindible que la impresora tenga conexión wireless para poder imprimir desde nuestro Android. Conectando un cable OTG tendremos el trabajo hecho.Se trata de una utilidad especialmente importante dado que, hoy en día, muchos de nosotros tratamos de evitar la mediación del ordenador siempre que sea posible. Tras recibir o descargar cualquier documento con el teléfono o la tableta, agilizaremos la impresión sin necesidad de encender el PC y también nos evitaremos los reenvíos.
  4. – Cargar tu teléfono usando otro smartphone:¿La batería destu smartphone está a punto de morir y el de tu amigo está casi al 100%? Conéctalos con un adaptador OTG y el que tenga una menor carga comenzará a robar batería del otro.
  5. Conectar un módem 3G a tu tableta:¿Te acuerdas de esos módems 3G que se usaban antes de que se pudiera compartir internet desde nuestro smartphone? Si tienes uno y tu tablet no tiene conexión 4G, puedes darle una segunda vida a través de la conexión USB OTG.
  6. Todo tipo de accesorios:La gente tiene muchísima imaginación y eso en muchas ocasiones se ve reflejado en los accesorios que encontramos para nuestros smartphones. Existe una variedad importante de accesorios para el USB OTG, desde ventiladores portátiles hasta flashes para selfies, pasando por teclados musicales y micrófonos.

¿Se le ocurren más usos para el USB OTG en Android? En el caso de que su móvil sea compatible con esta tecnología, ¿utiliza alguna de estas funciones en el día a día?

Y por cierto  !Feliz Navidad y próspero año nuevo 2017!

 

 

Regalos para apasionados de la tecnologia


En  la actualidad  se pueden encontrar todo tipo de artilugios tecnológicos a cualquier precio y para todos los gustos, pero a veces queremos llegar más lejos  construyendo nosotros mismos muestras propias creaciones . En esta linea, tanto para  potenciar nuestra creatividad ,como ayudarnos en nuestros proyectos hemos pensado en una lista de regalos tecnológicos que  quizás puedan servir de inspiración  .

Raspberri Pi 3

Actualmente es una de las placas mas potentes que existe (incluso mucho mas que Arduino y todos sus clones) gracias a su potente chipset Broadcom a 1.2 GHz con procesador ARM Cortex-A53 de 64 bits y cuatro núcleos,coprocesador multimedia de doble núcleo Videocore IV, memoria de 1 GB LPDDR2 y Bluetooth v4.1 así como sus conexiones :

  • Ethernet,
  • HDMI
  • VGA
  •  CSI,
  •  USB ( 4 puertos)
Esta nueva versión  integra un chip que la dota con conectividad Wifi y Bluetooth 4.1 de bajo consumo y cuenta con administración de energía mejorada que permite trabajar con más dispositivos USB,Permite usar más energía a los puertos USB. Podrás conectar más dispositivos a los puertos USB sin necesidad de usar hubs USB alimentados. También al no necesitar usar adaptadores WiFi por USB, tendrá más energía disponible en los puertos.
Raspberry pi 3
Para empezar a usar esta estupenda placa  tendremos que crear la imagen del SO en una SD  como describimos en este post. En cuanto a periféricos ,podemos conectar un ratón o teclado convencional con conexión usb ,  o la mejor opción ,optar por  un mini teclado y ratón  inalambricos a 2.4GHz que se pueden comprar por 15€ .Esta opción alimentada por baterías de litio , simplificará las conexiones al usar un sólo puerto usb para el dongle  y nos permitirá interactuar con la RPIII con mayor libertad.
raton y teclado en dongle
En cuanto a  la alimentación  podemos usar  un  cargador de móvil  convencional siempre que suministre al menos 1Amp (5VDC)  y si se pregunta por la caja , aunque se puede comprar lo mejor es construirnosla nosotros mismos ,al puro estilo maker.
La RPI como podemos ver en este blog , permite desde crear un ordenador económico  con Pixel (Debian) hasta un emulador de juegos clásicos ,un NAS, un hub domótico ,aplicaciones de IoT o el centro multimedia definitivo. Sale por 40 euros.

 

Kuman K11 Arduino

Para aquellas personas que opte por Arduino , exite un Kit de iniciación para Arduino con 31 componentes donde se incluye como no podia ser otra manera el corazón :na placa compatible con Arduino UNO R3.

Ademas por supuesto ,si le e gusta puede ir ampliando con más componentes. El precio del kit  básico incluido el Ardunino Uno R3 cuesta 46 euros.

 

 

Kit de inicacion para Arduino

Los componentes que incluye este kit son los siguientes;

  •  UNO R3 + cable USB x1
  •  Desarrollo Junta de Expansión x1
  • Mini tabla de pan x1
  •  Placa de pan 830 Point Solderless x1
  •  Caja de componentes SMD x1
  • LED (rojo) x5
  •  LED (amarillo) x5
  •  LED (verde) x5
  •  Buzzer activo x1
  •  Buzzer pasivo x1
  •  Mini botón x4
  •  Displays LED de siete segmentos (1 dígito) x2
  • Interruptores de bola x2
  • LDR (Resistencia dependientes de la luz) x3
  •  Potenciómetro x1
  •  Sensor de temperatura LM35 x1
  •  Sensor de llama x1
  • Sensor infrarrojo x1
  •  Resistencias de 220 ohmios x8
  • Resistencias de 1k ohmio x5
  • Resistencia de 10k ohmios x5
  • Cabezal de 40 pines x1
  • Hembra de 4pcs los 20cm al cable femenino x1 de Dupont
  •  Cables de puente x20
  • Batería 9V x1
  •  Clip de batería de 9V x1
  •  Control Remoto IR x1
  •  1602 Módulos LCD x1
  •  Servomotores SG90 9G x1
  •  Tarjeta de conductor ULN2003 x1
  •  Motor paso a paso 5V x1
  •  Caja de almacenaje x1

Este es un Super Starter Kit actualizado, desarrollado especialmente para aquellos principiantes que estén interesados en Arduino  con componentes de alta calidad,  pues como vemos, incluye un conjunto completo de componentes electrónicos útiles para Arduino conteniendo todos los componentes que necesita para comenzar su aprendizaje de programación para Arduino .

Es perfecto para las personas que desean iniciarse en el mundo del arduino o tengan alguna asignatura en sus estudios, ya que tiene una gran variedad de accesorios que le permiten “trastear” en el increíble mundo de Arduino ( la verdad no he visto que fuera necesario comprar nada mas). Todos los componentes ademas están organizados en una caja de plástico con separadores ,lo cual   se agradece para tenerlo todo recogido.

Los tutoriales detallados incluyendo la introducción del proyecto y el código fuente, contactando con el vendedor,   aunque en este humilde blog, o en Internet, encontrará miles de ejemplos para sacarle el máximo partido a este kit.

 

 

Memoria diminuta

Si su televisor o centro multimedia tiene capacidad para reproducir contenido desde una memoria USB, este modelo de Sandisk es USB 3.0 para una transferencia rápida de archivos desde su ordenador, y a la vez muy pequeño para que pase desapercibido en el puerto de su televisor.

El modelo de  64GB  sale por unos  17€  ,pero las hay de  128 GB  por  30€. ( o de capacidades inferiores de 16GB o 32GB rondando los precios entre 6€ y 10€)

 

memoria diminuta

SSD de 120 GB

Gracias a un disco sólido se  puede ampliar la vida útil de un ordenador y maximizar la inversión actual al sustituir la unidad de disco duro convencional ( que podrá seguir usando gracias a una económica  caja )   por una unidad de estado sólido (SSD) Kingston.

Esta es  la forma más rentable de mejorar de manera espectacular la capacidad de respuesta del sistema mejorando machismo el tiempo de arranque y en general el rendimiento  ya que el tiempo de acceso a disco  es espectacularmente mejor que en los discos convencionales.

Este modelo  incluyen una controladora LSI SandForce optimizada para memoria Flash de nueva generación con la que ofrecen el súmmum de la calidad y la fiabilidad de dos marcas líder de SSD. Al estar constituidas por componentes de estado sólido y no tener piezas móviles, son resistentes a los golpes y las caídas. Las unidades de estado sólido Kingston están respaldadas por soporte técnico gratuito y la legendaria fiabilidad Kingston

Este modelo de  SSD  con una capacidad de 120GB ( mas que suficiente para contener Windows 10) o de 2.5 pulgadas para potenciar su PC o para incluirlo en un NAS, sale por por poco dinero: 48 euros.

ssd de 12GB

Kit de herramientas

Ya sea para montar la última gráfica que le ha llegado ,así como para cambiar la pantalla rota de su smarthone ,la verdad es que  uno nunca sabe cuándo necesitará un set de herramientas tan completo pues incluye diferentes puntas para diferentes propósitos: puntiaguda para alta precisión, curvada para exactitud ergonómica y redondeada para levantar componentes más pesados

Son perfectas para tareas que requieran coger, sujetar, extraer y/o apretar con componentes .Incluye capa protectora contra la ESD para evitar dañar los componentes electrónicos sensibles

 

De iFixit y cuesta 55 euros. quizás un poco alto pero es sabido que esta marca destaca por su alta calidad ,asi que deberíamos  sopesar esta importante característica pues a veces nuestras herramientas no están a la altura de lo que esperamos de  ellas.

Clon de hromecast

La manera más sencilla y con más compatibilidad para ver contenido en un televisor controlando la fuente desde un smartphone. El original de Google cuesta sobre los 40€  pero hay  muchas versiones clónicas que hacen prácticamente la misma función  , por muchísimo  menos coste como por ejemplo el MiraScreen que cuesta sólo  14 euros. 

Este dispositivo soporta compartir Pantalla pudiendo usar Airplay, miracast o  DLNA (DLNA: Estándar) y la conectividad apoyada es  Wi-Fi: 802.11b / g / n inalámbrica de 2.4GHz WiFi 150Mbps  y  lleva  antena externa  WiFi para proporcionar 10M cobertura

La salida de vídeo es hasta 1080p HDMI de salida soportando  los formatos :

  • Video :AVI / DIVX / MKV / TS / DAT / MPG / MPRG / MOV / MP4 / RM / RMVB / WMV. Soporte de formatos de audio: MP1 / MP2 / MP3 / WMA / OGG / ADPCM-WAV / PCM-WAV / AAC.
  • Audio : .MP3, WAV.
  • Fotos : JPEG / BMP.

 

 

Mirascreen

El consumo de energía ultra bajo, consumiendo  pocas mA y es portátil compacto  para facilitar su transporte.

Hay  personas que lo usan en el coche  pues muchos reproductores de coche cuentan con soporte HDMI, de esta forma desde un teléfono inalámbrico podemos conectarlo  a la pantalla del coche convirtiendo su coche al instante en vehículo inteligente. Otras utilidad  de  est dispositivo es el  E-learning, reunión de negocios pues  nos liberamos de las ataduras de cable, siendo  las reuniones en inteligentes y eficientes. Tambien son perfectas para disfrutar de la gran pantalla como  Ver películas, jugar, crear su propio cine exclusivo,ver fotos juegos ,etc  .

Por cierto el mando a distancia se hace desde el propio  Teléfono ,Labtop o Tablet PC.

 

Sable electrónico Kylo Ren

Para terminar para los mas pequeños   ( o no ) , para practicar de cara a nuevos juegos de Star Wars o simplemente porque quiere ser  como un niño con zapatos nuevos. Este sable se ilumina y lo componen diferentes piezas teniendo el  mismo aspecto que la película.Incluye daga de luz  simulando clásicos sonidos y luces. Es ademas combinable con otros sables Master Jedi (se venden por separado)

Cuesta 30 euros.

sable laser

 

 

Error:(23, 17) Failed to resolve: junit:junit:4.12 en Android Studio


Este problema como vamos a ver, no se resuelve desinstalando  y volviendo a instalar Android Studio

El error   completo  ocurre cuando intentamos probar cualquier proyecto  ( incluso vacío ) ,   apareciendo el mensaje  Error:216 Failed to resolve: junit:junit:4.12

 

error

 

A continuación citamos los pasos para solucionar el problema:

  • Cerrar Android Studio
  • Descargar  el paquete junixfixerfile.zip   que contendrá  la librería junit-4.12.jar ,por ejemplo a partir de este enlace contrastado http://www.mediafire.com/file/413j0qfiixb4tda/junitfixerfile.zip
  • Descomprimir  el fichero con el winrar , seleccionando  la ruta    de las librerías de la aplicación  ,por  ejemplo  en la ruta  C:\Users\xxxxxxxxx\AndroidStudioProjects\MyApplication\app\libs (donde  xxxxx es su usuario logado en windows)

androidstudio1

 

 

 

 

 

 

 

 

 

 

 

 

 

  • Ahora ya puede abrir Android Estudio, volver a cargar su proyecto e intentar ejecutar su proyecto pues no debería dar ningún error

 

En caso de que seguidos los pasos anteriores persista el error , debería eliminar la  inferencia a la librería  Junit antigua  y colocar en su lugar la nueva librería.

Esto se hace pulsando  en File–>Proyect Structure.

Aquí , nos iremos a nuestra app( Modules–>App) y seleccionaremos Dependencies

 

Deependencias

Aquí deberíamos posicionarnos sobre la libreria junit  y darle el botón – (Remove)

Acto seguido daremos a añadir con el botón + ( a la derecha), seleccionaremos Libraries Deependencies –>Files dependencies   y nos  iremos a la ruta donde la nueva almacenamos  la nueva librería ( C:\Users\xxxxxxxxx\AndroidStudioProjects\MyApplication\app\libs)

Finalmente le damos a “Compile”  y  ya debería poderse ejecutar sin problemas sin volver a dar el error

Gradle sync failed: CreateProcess failed, error=216 con Android Studio


Para todos aquellos que se inician en el desarrollo de aplicaciones  para Android, es importante tener claro que entorno de desarrollo es el mejor y más completo para empezar con la primera aplicación, pues ese primer proyecto quizás  un buen día, pueda convertirse en una app de uso masivo y por lo tanto, reportar beneficios económicos.

Al principio  había desarrolladores  que usaban NetBeans , pero poco  después todas  la comunidad se paso programar  con  Eclipse   hasta  que salió a la luz Android Studio, que o todo apunta a que será el entorno que use todo el mundo pues en poco tiempo será lo único que el equipo de Android recomiende.

Está basado en IntelliJ IDEA, uno de los IDE para java de primer nivel (entre los mejores, con Eclipse, netbeans)

Ademas  soporta un  nueva forma de construir los apk. Más serio, mas versátil, mas potente, mas actual, y mas parecido a un proyecto en java.

En este post vamos a intentar solucionar un  típico  problema cuando empezamos a  desarrollar con  Android Studio  en equipos no muy modernos.

Este problema como vamos a ver, no se resuelve reinstalando   Android Studio

El error   completo  ocurre cuando intentamos probar cualquier proyecto  ( incluso vacío ) ,   apareciendo el mensaje “Gradle sync failed: CreateProcess failed, error=216 Consult IDE log for more details (Help | Show Log)”

Este es  un ejemplo:

error

 

El error  216  , que en ocasiones no es mostrado completo corresponde a este descriptivo “This version of %1 is not compatible with the version of Windows you’re running. Check your computer’s system information and then contact the software publisher

Esto sucede porque se incluye la versión de  64bit del JRE con Android Studio para Windows, lo cual  produce errores en sistemas de 32 bits.

La solución al problema pasa por dos pasos:

 

  • No utilice el JDK incorporado: vaya al cuadro de diálogo Archivo -> Estructura del proyecto, desmarque “Usar JDK incrustado” y seleccione el JRE de 32 bits que tenga instalado por separado en su sistema . Al menos debería ser  JDK8  o superior  .

 

android_studio

 

 

  • Disminuya la huella de memoria para Gradle en gradle.properties (Propiedades del proyecto), por ejemplo, establezca en -Xmx768m ( tendrá por defecto -Xmx1024m).Es decir debería quedar así:
org.gradle.jvmargs= -Xmx768m