Tutorial para instalar Android y AndEngine en Windows

Empezaré mi primera entrada con un tutorial para la instalación del Android SDK conjuntamente con la versión GLES2 de una de las librerias mas utilizadas en el desarrollo de aplicaciones para Android, la libreria AndEngine, en Windows 7.

Esta libreria nos provee las herramientas necesarias para la creación de juegos para esta plataforma, así como la posibilidad de añadir física 2D, tratamiento multijugador,... a nuestros juegos, de forma fácil e intuitiva.

Empezemos con los prerequisitos para la instalación de Android:

• Java 6 JDK: Primero de todo, es necesario tener instalada como mínimo la versión 6 del Java SDK. Podéis descargar la última versión clickando sobre el link anterior(también os podéis descargar la versión 7, aunque os traerá algún que otro problema que luego solucionaremos :D ).
  Una vez hecha la instalación, tenéis que definir la variable JAVA_HOME. Podéis seguir el siguiente tutorial para la definición de variables en Windows, clickando sobre esta dirección: http://amalaka.wordpress.com/2010/02/25/134/.
• Eclipse: Para este tutorial utilizaremos la IDE Eclipse, probablemente la IDE más utilizada (conjuntamente con NetBeans) para el desarrollo de aplicaciones Java. Podéis descargar la última versión desde el link anterior.
  Os recomiendo que si no váis a programar aplicaciones Java EE, os descarguéis la versión Eclipse IDE for Java developers.
  La instalación de Eclipse no tiene mas secreto que descomprir el archivo en el la carpeta que queramos, añadir la dirección de la carpeta principal a la variable PATH (de forma similar a la instalación de JAVA) y elegir el JAVA_HOME la primera vez que se ejecute eclipse.
• Apache Ant: Finalmente, para la instalación y compilación de las librerias de AndEngine, deberemos instalar la herramienta Apache Ant. Esta herramienta nos permite definir como compilar y generar nuestros proyectos JAVA, así como descargar automáticamente las librerias necesarias de los repositorios que definamos. Podéis encontrar Apache Ant desde el link anterior. Los pasos para instalar Apache Ant los podéis encontrar aquí.
  
  
  Además, tendremos que asegurarnos de que la libreria ant-contribs está instalada en el repositorio de librerias de Ant. Podemos descagar el .jar i el .pom desde el repositorio ibiblio.
  
  
  Una vez descargado, solo tenemos que copiar esos dos archivos en: %ANT_HOME%/lib donde ANT_HOME es el directorio de instalación de Apache Ant.

Una vez nos hemos asegurado de que cumplimos todos los requisitos, porfin podremos empezar con la instalación de Android!

Instalar el Android SDK

Para empezar, tenemos que instalar el Android Starter Package. Este instalador, que actualmente va por la revisión 20.0.3, contiene tanto el Android SDK, como el AVD Manager, y solo debermos instalarlo la primera vez (debido a que las siguientes actualizaciones se haran a través del AVD Manager).

Podemos descargar el starter package desde la página:
http://developer.android.com/sdk/index.html

En esa página, deberemos elegir el archivo android-sdk_rXX-windows.exe (por defecto) o clicando en other revisions, podreis descargar el android-sdk_rXX-windows.zip en caso de que el ejecutable no detecte las librerias JAVA.

En caso de descargar el .exe, solo deberemos ejecutar-lo i seguir el wizzard seleccionado las opciones por defecto. En cas de haber descargado el .zip, descomprimiremos el archivo en una carpeta qualquiera (mejor que no tenga espacios, como en "Porgram Files", debido a un error que luego explicaremos como solucionar) y ejecutaremos el AVD Manager, ejecutando el fichero SDK Manager.exe.

En ambas opciones de instalación, una vez entremos en el SDK Manager, tendréis que ir a la pestaña Available packages i seleccionar los packages que queráis instalar. Mínimo:

• Android SDK tools, revison XX (se instalan por defecto con el SDK)
• Android SDK Platform-tools, revison X (actualmente la versión 14)
• SDK Platform Android 4.0.3 (API 15)

Notad que realmente deberemos instarl·lar las versiones del SDK Platform Android para las que queramos desarrollar. No obstante, el branch GLES2 de AndEngine coge por defecto con la versión 4.0.3, aunque se puede vincular a todas las versiones de Android a partir de la 2.2.

Tambien és interesante que si quereis crear aplicaciones de pago o con anuncios, os bajéis el contenido de la carpeta extras referentes a estos puntos. 

Una vez seleccionadas las optiones, pulsad el botón install N packages y esperad a que se descarguen todas las actualizaciones.

Instalar el plugin ADT para Eclipse

Una vez acabe de instalar todas las actualizaciones, aprovecharemos para instal·lar el plugin ADT para Eclipse. Este plugin nos permite trabajar de manera integrada con el Android SDK desde Eclipse. Para hacerlo, deberemos entrar en Eclipse e ir al menú Help -> Install New Software....

Una vez dentro, en el campo work with, informar la siguiente dirección:
https://dl-ssl.google.com/android/eclipse/

I seleccionar Developer Tools y aceptar. Una vez descargado el plugin se instalará automaticamente i reiniciarà Eclipse. Una vez hecho esto, ya podemos empezar a trabajar con Android!! No obstante, primero vamos a instalar las librerias de AndEngine ^^.

Instalar las librerias AndEngine

Para instalar las librerias de AndEngine, primero deberemos integrar git con Eclipse, dirigiendonos nuevamente al menú Help -> Install New Software... y una vez dentro, en el campo work with, informar la siguiente dirección:
http://download.eclipse.org/egit/updates

Finalmente seleccionaremos  Eclipse GIT Team Provider e instalaremos el plugin.

Ahora sí, por fin, clonaremos el repositorio de AndEngine. Explicaremos el proceso para las librerias de AndEngine, y luego solo tendreis que realizar los mismos pasos para las extensiones (de las cuales daré la dirección del repositorio).

Para clonar el repositorio, tendremos que entrar nuevamente a Eclipse. Una vez dentro, entraremos en el menú: File -> Import...-> Projects from Git -> URI y informaremos la dirección del repositorio de github:
https://github.com/nicolasgramlich/AndEngine

En el apartado Authentication, tendremos que poner nuestro User i Password de la cuenta de Github (si no tenemos podemos crear una cuenta gratuita aquí, con el botón create a free account), y en el apartado Initial Branch seleccionaremos GLES2. Finalmente dejaremos las otras opciones por defecto y pulsaremos el boton Finish.

¡Importante! La primera versión del AndEngine se puede seleccionar marcando la revisión Master, pero esta ha dejado de estar mantenida por el creador, así que recomendamos empezar utilizando la resivión GLES2.

Una vez creado el nuevo proyecto, tendremos que modificar algunas opciones para la compilación:

• Modificar las opciones del proyecto: Esto es para los que hayáis elegido descargaros la versión 7 del JDK. Dado que el código de AndEngine está preparado para compilarse con la versión 6 del JDK, tendremos que modificar la versión con la que compilaremos. Para hacerlo entraremos en Project -> Properties -> Java Compiler, seleccionaremos Enable project especific settings y finalmente seleccionaremos como Compiler compliance level la versión 1.6
• Crear directotios vacíos: Dado que las carpetas vacias no se sincronizan, es posible que aparezcan errores del Build Path pidiendo estas carpetas. Solo tendremos que crearlas manualmente en la raíz del proyecto.
• Cambiar la versión de Android: Las librerias del AndEngine se deberan compilar con la versión del Android SDK para la que querais programar. Por eso, primero debereis seleccionar la versión de Android con la que trabajar para el proyecto AndEngine. Para hacerlo, debereis ir a la vista package explorer (abierta por defecto pero accesible desde: Window > Show View > Package Explorer) y posteriormente, hacer click con el botón derecho en el proyecto AndEngine y seleccionar Properties. En el apartado Android, tendremos que seleccionar la versión de entre las instaladas en el apartado Project Build Target.  

Una vez hecho esto, ya podremos compilar el proyecto AndEngine mediante las teclas CTRL + B o dirigiendonos al menú: Project > Build All

Con esto habremos instalado tanto el Android SDK, como el entorno de trabajo en Eclipse y las librerias base del AndEngine. No obstante, quedan muchas librerias que extienden las librerias de AndEngine como por ejemplo la libreria: AndEnginePhysicsBox2DExtension, que es la encargada de proveer recursos de física 2D a nuestros juegos.

El proceso a seguir para su instalación es el mismo, a diferencia de la dirección del repositorio de GitHub en el que se encuentran. Las direcciones de los repositorios de las extensiones de AndEngine son los siguientes.

Libería	Repositorio
AndEngineAugmentedRealityExtension	https://github.com/nicolasgramlich/AndEngineAugmentedRealityExtension
AndEngineLiveWallpaperExtension	https://github.com/nicolasgramlich/AndEngineLiveWallpaperExtension
AndEngineMODPlayerExtension	https://github.com/nicolasgramlich/AndEngineMODPlayerExtension
AndEngineMultiplayerExtension	https://github.com/nicolasgramlich/AndEngineMultiplayerExtension
AndEnginePhysicsBox2DExtension	https://github.com/nicolasgramlich/AndEnginePhysicsBox2DExtension
AndEngineRobotiumExtension	https://github.com/nicolasgramlich/AndEngineRobotiumExtension
AndEngineScriptingExtension	https://github.com/nicolasgramlich/AndEngineScriptingExtension
AndEngineScriptingExtensionGenerator	https://github.com/nicolasgramlich/AndEngineScriptingExtensionGenerator
AndEngineSVGTextureRegionExtension	https://github.com/nicolasgramlich/AndEngineSVGTextureRegionExtension
AndEngineTexturePackerExtension	https://github.com/nicolasgramlich/AndEngineTexturePackerExtension
AndEngineTMXTiledMapExtension	https://github.com/nicolasgramlich/AndEngineTMXTiledMapExtension

Además, tambien disponemos de dos proyectos con ejemplos prácticos de cada una de las librerias tanto de las extensiones como del core. Estas estan disponibles en dos nuevos repositorios que también podemos descargar mediante el plugi EGIT de eclipse como los proyectos anteriores, cambiando la dirección por:

Archivos de ejemplo	Repositorio
AndEngineExamples	https://github.com/nicolasgramlich/AndEngineExamples
AndEngineRobotiumExtensionExample	https://github.com/nicolasgramlich/AndEngineRobotiumExtensionExample

¿Cómo utilizar AndEngine?

Perfecto, si has seguido los pasos indicados hasta aquí, ya tienes todo lo necesario para crear el primer APK utilizando las librerias de AndEngine. No obstante, si ya habías utilizado la versión GLES1 del AndEngine, notarás que al compilar no se genera un .jar. Entonces... ¿Cómo utilizar AndEngine?

El creador de AndEngine ha definido la versión GLES2 de AndEngine y sus extensiones, como un conjunto de proyectos de librerías de Android. Para asegurarnos de que estan así definidos, tendremos que ir a las propiedades del proyecto (botón derecho sobre el proyecto AndEngine y pulsar Properties), ir al apartado Android y comprobar que está marcado el checkbox Is Library.

Entonces, solo quedará crear nuestro código de ejemplo y referenciar el proyecto AndEngine como liberia. Empecemos por crear un nuevo proyecto Android.

Para crear un nuevo proyecto Android, deberemos entrar en eclipse y ir al menú:
File > New > Project... y seleccionar Android Application Project.

A continuación, rellenaremos el nombre de la applicación, el nombre del proyecto y el nombre del package. Además, elejiremos la versión del Android SDK con la que compilaremos y la versión mínima para ejecutar nuestra applicación. Opcionalmente, podemos marcar / desmarcar la opcióm de crear un icono personalizado, para en una pantalla posterior elegir entre varios cliparts, texto o imagenes. Nosotros desmarcaremos la opción de crear el icono personalizado y una vez rellenados todos los otros parámetros, pulsaremos Next.  

En la siguiente pantalla se nos preguntará si queremos crear una actividad por defecto, a lo que diremos que no queremos crear ninguna (desmarcando el checkbox Create Activity) y acabaremos pulsando el botón Finish.

Una vez creado el proyecto, deberemos referenciar las librerias de AndEngine. Para hacerlo, deberemos entrar en las propiedades del proyecto y en el apartado Library añadir el proyecto AndEngine (y todos los otros proyectos de librerias Android que necesitemos), tal y como vereis en la siguiente captura de pantalla.

A continuación, solo tenemos que substituir el código de la clase HelloWorld por el código adjunto a continuación:

package test.andengine.helloworld;

import org.andengine.engine.camera.Camera;
import org.andengine.engine.options.EngineOptions;
import org.andengine.engine.options.ScreenOrientation;
import org.andengine.engine.options.resolutionpolicy.FillResolutionPolicy;
import org.andengine.entity.scene.Scene;
import org.andengine.entity.scene.background.Background;
import org.andengine.entity.text.Text;
import org.andengine.opengl.font.Font;
import org.andengine.opengl.font.FontFactory;
import org.andengine.opengl.texture.TextureOptions;
import org.andengine.ui.activity.SimpleBaseGameActivity;
import org.andengine.util.color.Color;

import android.app.ActivityManager;
import android.content.Context;
import android.content.pm.ConfigurationInfo;
import android.graphics.Typeface;
import android.util.Log;
 
public class HelloWorld extends SimpleBaseGameActivity {
    
 private Scene mCurrentScene;
 private Camera mCamera;
 private Font   mFont;
 private static final int CAMERA_WIDTH = 854;
    private static final int CAMERA_HEIGHT = 480;

    //A reference to the current scene
    
    @Override
    public EngineOptions onCreateEngineOptions()
    {
     //Debug
     boolean GLES2Suport = detectOpenGLES20();
     Log.d("test.andengine.helloworld.HelloWorld", "Android GLES2.0 Support: " + (GLES2Suport?"true":"false"));
     System.out.print(GLES2Suport);
     
     mCamera = new Camera(0, 0, CAMERA_WIDTH, CAMERA_HEIGHT);
        EngineOptions engineOptions = new EngineOptions(true, ScreenOrientation.PORTRAIT_FIXED, 
        new FillResolutionPolicy(), mCamera);
        return engineOptions;
    }

    @Override
    protected void onCreateResources() {
     this.mFont = FontFactory.create(this.getFontManager(), 
             this.getTextureManager(), 256, 256, TextureOptions.BILINEAR, 
             Typeface.create(Typeface.DEFAULT, Typeface.BOLD), 32);
     this.mFont.load();
    }

    @Override
    protected Scene onCreateScene()
    {
          Scene mCurrentScene = new Scene();
          Text helloWorldText;
          String hwText = "Hello World!";
          
          mCurrentScene.setBackgroundEnabled(true);
          mCurrentScene.setBackground(new Background(0.09804f, 0.6274f, 0.8784f));
                   
       helloWorldText = new Text(100, 160, this.mFont, hwText, this.getVertexBufferObjectManager()); 
       helloWorldText.setPosition( (CAMERA_WIDTH - helloWorldText.getWidth()) / 2, 
                                (CAMERA_HEIGHT - helloWorldText.getHeight()) / 2);
       helloWorldText.setColor(Color.BLACK);
       
       mCurrentScene.attachChild(helloWorldText);
        
       return mCurrentScene;
    }
    
    public final boolean detectOpenGLES20() 
    {
     ActivityManager am = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);
     ConfigurationInfo info = am.getDeviceConfigurationInfo();
     return (info.reqGlEsVersion >= 0x20000);
    }
    
    public final Scene getCurrentScene(){
     return mCurrentScene;
    }
    
    public final Camera getCurrentCamera(){
     return mCamera;
    }
    
    public final Font getDefaultFont(){
     return mFont;
    }
               
}

I una vez hemoscreado la clase principal, tendremos que modificar el AndoridManifest.xml, añadiendo el siguiente código:

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
          package="test.andengine.helloworld"
          android:versionCode="1"
          android:versionName="1.0">

    <uses-sdk android:minSdkVersion="9" android:targetSdkVersion="15" />
    <uses-feature android:glEsVersion="0x00020000" android:required="true" />

    <!-- <uses-permission android:name="android.permission.BLUETOOTH_ADMIN" /> -->  
    <!-- <uses-permission android:name="android.permission.BLUETOOTH" />  -->
    <!-- <uses-permission android:name="android.permission.ACCESS_WIFI_STATE"/>  -->
    <!-- <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>  -->
    <!-- <uses-permission android:name="android.permission.CAMERA"/>  -->
    <!-- <uses-permission android:name="android.permission.INTERNET"/>  -->
    <!-- <uses-permission android:name="android.permission.READ_PHONE_STATE"/>  -->
    <!-- <uses-permission android:name="android.permission.VIBRATE"/>  -->
    <!-- <uses-permission android:name="android.permission.ACCESS_COARSE_LOCATION"/>  -->
    <uses-permission android:name="android.permission.WAKE_LOCK"/>
    
    <application android:label="@string/app_name"
                 android:icon="@drawable/ic_launcher"
                 android:theme="@style/AppTheme">
  <activity android:name=".HelloWorld"
                  android:label="@string/app_name"
                  android:configChanges="orientation" 
                  android:theme="@style/AppTheme">
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />
                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

</manifest>

Para acabar, antes de poder provar nuestro proyecto deberemos crear un dispositivo virtual de pruebas con el AVD Manager (Android Virtual Device). Este plugin que se instala con el ADT plugin de Eclipse, nos permite crear un dispositivo virtual para probar los APK sin necesidad de subirlos a nuestro movil.

Para crear un nuevo dispositivo de pruebas, nos dirigiremos al menú: Window > AVD Manager y pulsaremos el botón New. Con lo que nos aparecerá la siguiente ventana:

En esta pantalla tendremos que informar los datos del dispositivo virtual que utilizaremos para probar nuestros juegos y aplicaciones. Para poder probar las aplicaciones construidas con AndEngine GLES2, es muy importante seleccionar como mínimo la versión 4.0.3 de Andorid, el processador Intel Atom x86 i añadir en el hardware la entrada GPU emulation a yes. Si no configuramos estos parámetros NO PODREMOS PROBAR LAS APLICACIONES CON EL EMULADOR. No obstante, si podremos descargar las aplicacines a nuestro teléfono y probarlas directamente.

Ahora sí y ya para finalizar este tutorial, solo quedará lanzar el emulador y ejecutar el programa de prueba. Para lanzar el emulador, volveremos al AVD Manager (Window > AVD Manager) pero esta vez seleccionaremos el dispositivo que habíamos creado y pulsaremos el botón Start:

 

Esto abrirá una nueva ventana con el simulador del dispositivo. Una vez salga la pantalla de bloqueo, desbloquearemos el dispositivo virtual y ejecutaremos nuestro proyecto. Para hacerlo iremos a la vista package explorer, pulsaremos botón derecho sobre el proyecto HelloWorld (o el nombre que le hayamos dado) y seleccioanaremos: Run As > Android Application, seleccioanando el dispositivo virtual que acabamos de encender.

Con esto acabamos el tutorial de instalación de Android con el AndEngine GLES2. Espero que os haya servido! Y no dudéis en comentar.