NFC en la Raspberry Pi

Hace tiempo que no escribo en el blog debido a insertar-excusa-que-no-haya-usado-antes-aquí, pero me apetecía compartir el resultado de pasar unas pocas de tardes buscando una buena alternativa para utilizar NFC en la Raspberry Pi.

Las primeras semanas me centré en hacer funcionar el lector NFC ACR122u de ACS, lector que ya había utilizado en la empresa en la que trabajo para hacer una serie de investigaciones con Linux y que arrojaron un resultado aceptable. Pobre de mi, pensaba que con la Raspberry Pi y la misma librería automágica nfcpy que había utilizado en el pasado, encontrar una alternativa estable iba a ser pan comido. No fue así. La Raspberry Pi es un Linux, eso es cierto, concretamente una Debian. Pero la arquitectura no es i386, es ARM (más propia de pequeños dispositivos como smartphones y tablets). A pesar de funcionar más o menos regularmente, el lector ACR122u fallaba de manera aleatoria y sin explicación. Tal y como me comenta un experto en la materia como es Stephen Tiedemann (creador de nfcpy) en este hilo, además de que el lector es de lo peor para estas cosas, el subsistema USB de la Raspberry se muestra muy inestable en cuanto a periféricos más concretos como este (ratones, teclados y demás material básico funciona sin problemas).

El lector NFC ACR122U

El lector NFC ACR122U

Con el primer golpe en la frente, decido no hacerle caso a Stephen que me recomienda probar con una placa PN532 conectable vía serie en plan Arduino, usando electrónica, placas y demás. En su lugar, me tomé la libertad de realizar una pequeña inversión en la placa EXPLORE-NFC NXP PN512 que no tiene soporte por parte de nfcpy pero tiene programas de ejemplo ya escritos en C puro. Esta placa se engancha al puerto de expansión GPIO como si de un conector USB se tratase.

La placa explore-nfc

La placa explore-nfc

Hay programas escritos para los 3 modos de operación de NFC: tag, card emulation y P2P. Un handicap es que el modo P2P sólo tiene escrito un programa para la operación PUT (recibir de Raspberry) pero no para GET (que la Raspberry obtenga del móvil). He escrito un programa Python/GTK como interfaz gráfica hacia este programa P2P ya existente, para probar la operación PUT. El resultado lo podéis ver en el vídeo que adjunto, donde también pruebo la demo del modo Card Emulation, que recoge el valor que asignemos al tag 14443 y lo escribe en el muro de Facebook de mi cuenta dummy.

Enlaces de interés

* Código de ejemplo EXPLORE-NFC:
http://www.element14.com/community/docs/DOC-65447/l/explore-nfc-software-and-project?ICID=knode-devkitnfc-quick

* Comprar EXPLORE-NFC (marcar Business en la ventana modal, aunque seas un particular):
http://es.farnell.com/jsp/displayProduct.jsp?sku=2366201&CMP=KNC-GES-FES-GEN-SKU-MDC

* Código de demo gráfica personal Python/GTK:
https://bitbucket.org/jialvarez/raspberry-mpos

A 1 persona le gusta esta entrada

Conectar programas C/C++ con aplicaciones Android

En esta entrada voy a describir la manera de comunicar aplicaciones escritas en Android con programas escritos en C/C++ vía JNI utilizando el NDK de Android.

El NDK es un conjunto de herramientas que permite incorporar los componentes que hacen uso de código nativo en las aplicaciones de Android. Permite implementar parte de tus aplicaciones usando código nativo con lenguajes como C y C ++. Esto puede proporcionar beneficios a ciertas clases de aplicaciones, en la medida que se puede reutilizar el código existente y en algunos casos obtener un aumento de la velocidad.

Java Native Interface (JNI) es un framework de programación que permite que un programa escrito en Java ejecutado en la máquina virtual java (JVM) pueda interactuar con programas escritos en otros lenguajes como C, C++ y ensamblador.

La estructura de un proyecto Android que utilice JNI y NDK para permitir la intercomunicación entre aplicaciones C/C++ y Android es la siguiente:
carpeta raíz del proyecto/

  • jni/
  • libs/
  • res/
  • src/
  • AndroidManifest.xml
  • default.properties
  • … otros ficheros …

Descripción de los ficheros:

  • La carpeta src contiene el código Java de la aplicación Android
  • La carpeta res contiene los recursos de la aplicación (imágenes, archivos XML que describen las capas de interfaz, etc)
  • La carpeta libs *contendrá* las librerías nativas *después* de una construcción exitosa
  • La carpeta jni *contiene* el código C/C++ de la aplicación con la que queremos comunicarnos, además de dos scripts importantes: Android.mk y Application.mk. Estos scripts son dos Makefiles típicos que controlan el proceso de construcción de la aplicación C++.

Veamos los pasos para ejecutar una sencilla aplicación Android que se comunique con un programa escrito en C++.

  • Descargar y descomprimir NDK
    Sé que hay versiones mucho más actuales, pero aún así, utilizo esta de Crystax que está bastante optimizada.
  1. wget http://www.crystax.net/en/download/android-ndk-r4-linux-x86-crystax-4.tar.bz2 -O /tmp/android-ndk-r4-linux-x86-crystax-4.tar.bz2
  2. cd ~ && tar xvjf /tmp/android-ndk-r4-linux-x86-crystax-4.tar.bz2

  • Crear la carpeta libs en el proyecto
    Pulsamos el botón derecho sobre el proyecto, y escogemos la opción New -> Folder. Escribimos libs como nombre de carpeta.
  • Crear la carpeta jni en el proyecto
    Pulsamos el botón derecho sobre el proyecto, y escogemos la opción New -> Folder. Escribimos jni como nombre de carpeta.
  • Crear el programa C++ con el que queremos comunicarnos
    Pulsamos el botón derecho sobre la carpeta JNI, y escogemos la opción New -> File. Escribimos code.cpp como nombre de fichero. Hacemos doble clic sobre el fichero y escribimos el siguiente código:
  1. #include <jni.h>
  2. #include <iostream>
  3. #include <cstdlib>
  4. #include <getopt.h>
  5. #include <string>
  6. #include <cassert>
  7. #include <stdexcept>
  8.  
  9. using namespace std;
  10.  
  11. extern "C"
  12. {
  13. JNIEXPORT jstring JNICALL Java_blog_neonigma_AndroidActivity_SayHello(JNIEnv *env, jobject thiz, jstring name)
  14. {
  15.   try
  16.   {
  17.     const char *myName = env->GetStringUTFChars(name, 0);
  18.     std::string nameCPP(myName);
  19.     nameCPP = "Hello: " + nameCPP;
  20.     return env->NewStringUTF(nameCPP.c_str());
  21.   }
  22.   catch (exception &ex)
  23.   {
  24.     const char *error = "Failed";
  25.     return env->NewStringUTF(error);
  26.   }
  27. }
  28. }

  • Consideraciones sobre el código:
    • El bloque extern “C” indica que el programa está escrito en C++. Sí, en C++. Si queremos escribirlo en C, eliminamos el bloque extern.
    • La declaración de la función nativa tiene que coincidir con el namespace + nombre de actividad Android + nombre de función en el código Java/Android. En este caso, como nuestra actividad es AndroidActivity y se encuentra en el namespace blog.neonigma, la función debe nombrarse como Java_blog_neonigma_AndroidActivity_SayHello, siendo SayHello el nombre que damos a la función y “Java_” un texto estático.
    • La función siempre recibe un puntero al entorno (JNIEnv *env) y un objeto manejador (jobject thiz)
    • Para convertir const char * en jstring, usamos la función NewStringUTF del entorno
    • Más información en la API oficial de JNI

  • Crear los Makefiles para NDK
    Pulsamos el botón derecho sobre el proyecto, y escogemos la opción New -> File. Escribimos Android.mk como nombre de fichero. El código para este fichero sería el siguiente:
  1. LOCAL_PATH := $(call my-dir)
  2.  
  3. include $(CLEAR_VARS)
  4.  
  5. LOCAL_MODULE    := mixed_sample
  6. LOCAL_SRC_FILES := code.cpp
  7. LOCAL_LDLIBS +=  -llog -ldl
  8.  
  9. include $(BUILD_SHARED_LIBRARY)

Los valores más importantes son code.cpp, que indica el fichero de código con el que queremos comunicar y mixed_sample, que es el nombre que damos a la librería que se va generar vía JNI.

Repetimos el proceso y creamos un fichero Application.mk.

  1. APP_STL := gnustl_static
  2. APP_CPPFLAGS := -frtti -fexceptions
  3. APP_ABI := armeabi
  4. APP_PROJECT_PATH := ~/workspace/blog-jni-c

En este caso, los valores más importantes son la arquitectura armeabi (puede cambiarse por la más moderna armeabi-v7a) y el path del proyecto, donde hay que indicar el path al workspace actual.

  • Crear un builder para la compilación
    Debe generarse un builder en Eclipse para la compilación del código C/C++ con NDK.

    1. Pulsamos en projects -> properties y escogemos la opción Builders. Pulsamos el botón New.
    2. En la ventana que aparece, escogemos la opción Program (sin escribir nada), y pulsamos OK.
    3. En la siguiente ventana configuramos el Builder en sí. En la pestaña Main, escribimos en el campo Location la ruta absoluta al programa ndk-build, en mi caso /home/neonigma/android-ndk-r4-crystax/ndk-build En el campo Working directory, pulsamos en el botón Browse workspace y escogemos el proyecto en el que estamos trabajando.
    4. Ahora vamos a la pestaña Refresh y marcamos Refresh upon completion, Specific resources y Recursively include sub-folders.

      Pulsamos en el botón Specify resources y en la ventana que aparece, escogemos el recurso libs.
    5. Por último, vamos a la pestaña Build Options, dejamos las casillas ya marcadas y marcamos During auto builds y Specify working set of relevant resources.

      Pulsamos en el botón Specify resources y escogemos el recurso jni de nuestro proyecto.
  • Escribir el código de la actividad Android
    Para enviar datos al programa en C++ y recogerlos, necesitamos escribir el código de la actividad principal de la siguiente manera:
  1. package blog.neonigma;
  2.  
  3. import src.blog.neonigma.R;
  4. import android.app.Activity;
  5. import android.os.Bundle;
  6. import android.widget.Toast;
  7.  
  8. public class AndroidActivity extends Activity {
  9.     @Override
  10.     public void onCreate(Bundle savedInstanceState) {
  11.         super.onCreate(savedInstanceState);
  12.         setContentView(R.layout.main);
  13.        
  14.         String greeting = SayHello("neonigma");
  15.         Toast.makeText(this, greeting, Toast.LENGTH_LONG).show();
  16.     }
  17.    
  18.     public native String SayHello(String name);
  19.    
  20.     static {
  21.         System.loadLibrary("mixed_sample");
  22.     }

  • Consideraciones sobre el código
    • La llamada a función nativa se define como public native.
    • String se equipara a jstring, e int a jint, a la hora de enviar y recibir parámetros.
    • Debe definirse como estática la carga del módulo de la librería generada y que especificamos en el código del Makefile Android.mk.

Referencias:
http://opencv.itseez.com/doc/tutorials/introduction/android_binary_package/android_binary_package_using_with_NDK.html#android-binary-package-with-ndk
http://zsoluciones.com/datos/?p=246

El código del ejemplo puede descargarse desde el repositorio creado en BitBucket.

A 1 persona le gusta esta entrada

Librerías QT portadas a S60

Esta noticia lleva ya un tiempo por la blogosfera, aún así la comento por mi especial interés por la miniaturización de la informática en general y de las comunicaciones.

Ni más ni menos que las famosas librerías QT de Trolltech han visto la luz en versión Symbian S60. Esto se debe en parte a que Qt Software (que así se llama ahora Trolltech) ha sido adquirida por el gigante finlandés Nokia. Las librerías salen con soporte extendido para Linux, aunque también han sido portadas a ¡Windows Mobile! justo antes de la mencionada adquisición de Nokia.

Sobran el resto de palabras al ver el video

A 1 persona le gusta esta entrada

Problema con Sun Wireless Toolkit bajo NetBeans: ventana en blanco

Hoy al seguir con el desarrollo de mi PFC me encuentro con esta curiosa imagen al ejecutar el mismo:

Tras un buen rato devanándome los sesos, recuerdo que algunas veces las actualizaciones automáticas de Ubuntu instalan nuevas versiones del JRE de Java, el cual tengo instalado por los repositorios. Pero no sólo eso, además, actualizan el JRE a utilizar, lo que podemos ver con el siguiente comando:

neonigma@neonigma-laptop:~/netbeans-6.1/mobility8/WTK2.5.2/bin$ sudo update-alternatives --config java
[sudo] password for neonigma:

Hay 3 alternativas que proveen `java'.

  Selección     Alternativa
-----------------------------------------------
          1    /usr/bin/gij-4.2
*+        2    /usr/lib/jvm/java-gcj/jre/bin/java
          3    /usr/lib/jvm/java-6-sun/jre/bin/java

Pulse  para mantener el valor por omisión [*] o pulse un número de selección: 3
Se utiliza `/usr/lib/jvm/java-6-sun/jre/bin/java' para proporcionar `java'.

Como se indica, se ha establecido por defecto de forma automática el JRE java-gcj, con lo cual no funciona WTK al necesitar Java 6. Pulsando la tecla 3, estaremos usando la versión correcta del JRE.

En mi caso, he necesitado reconfigurar Netbeans. Accediendo a las propiedades del proyecto Netbeans (en File -> “proyecto” Properties). En el menú de la izquierda pulsamos en Platform y en la zona de la derecha hacemos clic en el botón Manage emulators. En la imagen siguiente podemos ver que el JDK por defecto apunta ahora a una ruta de un Java 6 que no es el que tengo activado por defecto (que está en /usr/lib/jvm/java-6-sun y no en /usr/lib/jvm/java-6-sun-1.6.0.07).

La solución está en pulsar el botón Add platform… y añadir una nueva plataforma Java Standard Edition e indicar como ruta /usr/lib/jvm/java-6-sun. Se nos añade una nueva plataforma que es la correcta que Netbeans utilizará a partir de ahora.

A 1 persona le gusta esta entrada

Zeemote: un pequeño mando para jugar a videojuegos en el teléfono móvil

Telefónica ha presentado hoy en el mercado español el Joystick Zeemote, un dispositivo externo de última generación llegado de EE UU , con el que los clientes de Movistar podrán utilizar su teléfono móvil como una pequeña videoconsola para disfrutar de los últimos videojuegos del mercado.

Este dispositivo, de tamaño similar al de un mechero, se conecta al móvil a través de una conexión Bluetooth.

Con la comercialización del joystick, la compañía revalida su apoyo al sector de los videojuegos, una de las categorías más visitadas de su portal ‘emoción’, en el que hay un catálogo de más de 1.000 títulos de todas las categorías (acción, deportes, lógica, arcade…)

El joystick, que es compatible con los terminales que soporten Bluetooth 2.0, posee cuatro botones que permiten acceder al menú del videojuego y manejar todas sus funcionalidades sin necesidad de usar las teclas del terminal.

Para disfrutar del dispositivo, el cliente debe encender el joystick y posteriormente abrir el juego que de manera automática le preguntará por la asociación con el joystick. Una vez ambos dispositivos (móvil y joystick) están vinculados, el funcionamiento es como un mando de cualquier consola.

Zeemote ha recibido un gran impulso en el día de ayer gracias a Gameloft, la compañía francesa ha anunciado que dará soporte para el controlador Zeemote JS1 en sus próximos juegos.

Independientemente del acuerdo establecido con Gameloft, Zeemote ha puesto en marcha un proceso de certificación para garantizar la calidad de los títulos que soportarán al controlador, este proceso comprende un conjunto de normas y procedimientos a cumplir por los desarrolladores de software y así hacer que el dispositivo sea completamente compatible.

El apoyo de la industria a Zeemote está siendo bastante fuerte, de hecho los 15 principales desarrolladores de juegos para móviles (Eidos, Fishlabs, SEGA Mobile, Electronic Arts, Gameloft …) se han comprometido a crear juegos compatibles con el Zeemote JS1.

Fuente: 20 minutos
Fuente: Xakata Móvil

Sé el primero en valorar positivamente

Cómo depurar un MIDlet con NetBeans IDE Mobility

Para depurar nuestra aplicación móvil con el IDE NetBeans podemos fijarnos en la siguiente imagen, en la que señalo los pasos básicos para ejecutar paso a paso la aplicación.

  1. En primer lugar colocamos el punto de interrupción donde queremos que la aplicación quede detenida para comenzar la ejecución paso a paso. Para ello simplemente hacemos clic en la columna gris que hay a la izquierda de cada línea de código a la altura de una línea de código determinada. La línea de código tiene que hacer algo, es decir, no se permite colocar el punto de interrupción en la declaración de una variable
  2. Ahora abrimos la ventana de configuración del proyecto, haciendo clic con el botón derecho en nuestro proyecto en la ventana Projects y escogiendo la opción Properties. También podemos seleccionar el proyecto e ir a la opción de menú File – “proyecto” properties.
    Una vez abierta la ventana de configuración, hacemos clic en el ítem Running y lo configuramos todo de acuerdo a la imagen anterior. Es decir, se selecciona una Regular Execution puesto que la ejecución OTA Over The Air no permite la depuración y se marca un dominio de seguridad maximum para que no se nos pregunte si deseamos dar permiso a la aplicación cada vez que quiera escribir o leer de un fichero.
  3. El último paso es hacer clic en el icono que hay justo a la derecha del botón de ejecución normal, tal y como marca el número 3 en la imagen anterior.

Una vez hecho esto, podemos ver en la siguiente imagen que cuando se abre el emulador, debemos realizar las acciones necesarias que den lugar a la activación del punto de interrupción. Es decir, que debemos escoger aquellas acciones de nuestra aplicación que provoquen que la ejecución pase por el lugar donde hemos colocado el punto de interrupción. Cuando esto sucede, la ejecución en el emulador se detiene y pasa a NetBeans, colocando éste una flechita verde justo encima del punto de interrupción.

Entonces, con las teclas F7 y F8 iremos pasando línea a línea de forma agresiva (ejecutando línea a línea incluso las llamadas a funciones) o de forma menos agresiva (obteniendo sólo el resultado de la ejecución de funciones, sin entrar en ellas), respectivamente.

Sé el primero en valorar positivamente

Intel insiste en su empeño de hacerse hueco en el mercado de los dispositivos móviles

Al desplegar la arquitectura x86 en los dispositivos móviles, Intel persigue desarrollar la compatibilidad que estandarice el uso del software en PCs y dispositivos móviles, ha afirmado Pat Gelsinger, vicepresidente senior de Intel, en la rueda de prensa que la compañía ha organizado con motivo de su cuadragésimo aniversario.

Después de dejarse llevar por el éxito durante décadas, fruto de su decisión de incluir los procesadores x86 en los PCs, Intel dirige su mirada a los terminales móviles e incluye x86 en este tipo de dispositivos, operativos con procesador Atom. La compatibilidad de x86 en los teléfonos móviles impulsará la adopción de los chips en aquellos consumidores que busquen correr aplicaciones en múltiples dispositivos, explica Gelsinger.

A pesar de los deseos de Intel, la compañía tiene que competir contra Arm, un fabricante de procesadores que tiene una presencia dominante en el mercado de procesadores para dispositivo móvil y que, en la actualidad, busca retar a Intel al incorporar sus chips de baja potencia en los servidores. Arm podría ser un importante actor en este mercado aunque la falta de un ecosistema de hardware y software estándar podría ser un problema para la compañía, según ha explicado Gelsinger.

El coste aparejado al desarrollo de chips basado en diseños es además muy elevado, lo que podría ser un desafío para los nuevos fabricantes de procesadores que desean entrar en este mercado. Por su parte, la decisión de fabricar chips en obleas de 450 milímetros ayudará a Intel a reducir los costes de fabricación por procesador, lo que permitirá un uso más eficiente de los recursos, incluyendo el agua y la energía, que, en último caso, podría abaratar el precio de los procesadores. Aparte de su plataforma y las economías de escala, Intel introduce su oferta en el mercado de dispositivos móviles, donde tiene escasa presencia. La compañía ya sufrió un duro revés cuando Steve Jobs, CEO de Apple, afirmaba el pasado mes que utilizaría tecnología de PA Semi para el iPhone. Una decisión que defraudaba a Intel, pero que no ha minado las esperanzas de la compañía de que Apple vuelva a considerar su tecnología para su roadmap de dispositivos móviles.

Aparte de Atom, Intel ha desarrollado nuevos productos que reducen el tamaño del procesador y consumen menos energía. La compañía se encuentra en pleno proceso de desarrollo de una plataforma móvil con nombre de código Moorestown. Esta plataforma incluye un chip sobre el sistema con nombre de código Lincroft, basado en un núcleo de Silverthorne de 45 nanómetros e incorpora un controlador de memoria, vídeo y gráficos en un único chip.

Fuente: PC World

La madre que los parió… ¿qué va a ser lo próximo? ¿llevar un supercomputador en una pulsera?

Sé el primero en valorar positivamente

Instalación de librería kXML2 en NetBeans 6.1 IDE Mobility para Ubuntu

Cuando estamos programando en J2ME, a veces necesitamos de librerías externas. En mi caso, necesito un parser y un serializer de XML para el tratamiento de datos, función que cumple de maravilla la librería kXML2. Para instalarla, nos bajamos el .jar correspondiente de este enlace y lo guardamos en el directorio de nuestro proyecto. Por ejemplo, yo lo tengo en el directorio /home/neonigma/NetBeansProjects/miproyecto/.

Para poder utilizar la librería en NetBeans 6.1 es tan sencillo como ir al menú File => “miproyecto” Properties. De la ventana de configuración que nos aparece, buscamos el subítem Libraries & Resources dentro del ítem Build. A continuación, pulsamos en el botón Add Jar/Zip… que aparece a la derecha y escogemos el archivo kxml2-2.3.0.jar previamente guardado.

Aceptamos lo realizado y automáticamente, NetBeans nos reconoce el import org.kxml2.io.*;

A 1 persona le gusta esta entrada

NetBeans IDE 6.1 Mobility en Ubuntu: la solución definitiva para programación J2ME

Como ya sabéis, estoy programando en J2ME y había encontrado dos soluciones muy válidas para no tener que codificar el código Java a pelo. En este enlace os hablé del plugin EclipseME para Eclipse, solución que para empezar estaba bien, pero luego inexplicablemente aquello empezaba a decaer, mostrando errores ocasionales. Entonces, descubrí EasyEclipse Mobile Java, una versión de Eclipse ya preparada e integrada con el plugin EclipseME que funcionaba estupendamente.

Ahora os traigo la crème de la crème, un IDE al que no le falta de nada: NetBeans IDE 6.1 Mobility. Comenzamos con los pasos:

  • Ir a la página oficial de descarga y pinchar en el botón Download correspondiente a la columna Mobility.
  • Una vez descargado el archivo de instalación, lo ejecutamos de la siguiente forma:
    neonigma@neonigma-laptop:~/descargas$ sh netbeans-6.1-ml-mobility-linux.sh
  • Esto nos lanza el sencillísimo programa gráfico de instalación. Pulsando next y cuidando que el JDK seleccionado automáticamente por la instalación sea el correcto, habremos terminado al pulsar en Install. En mi caso se selecciona automáticamente el JDK que tengo instalado en /usr/lib/jvm/java-6-sun, lo que es correcto. Cuando finaliza la instalación, pregunta si se quiere registrar opcional y gratuitamente el programa.
  • Al pulsar en Finish, vemos que se nos ha instalado un icono tanto en Aplicaciones => Programación => NetBeans IDE 6.1 como en el escritorio.

Ahora ya podemos crear un proyecto nuevo. Veamos cómo hacerlo.

  • Cerramos la start page y nos vamos a File => New Project. Aquí escogemos la categoría (primera zona) Mobility y elegimos un proyecto MIDP Application.
  • Al pulsar en Next podemos configurar ciertas opciones, como el nombre del proyecto, su localización, la carpeta final (que cambia según se modifica el nombre del proyecto) y si queremos establecer el proyecto como principal. La opción de crear un Hello Midlet suelo descartarla, aunque podéis marcarla para hacer pruebas y ver dónde se colocan los sources.
  • En la siguiente ventana se nos dan a elegir los perfiles y configuraciones. En mi caso suelo elegir CLDC-1.1 (por defecto) y MIDP-2.0, por si hubiera problemas de compatibilidad con MIDP-2.1.El emulador y el device o dispositivo (arriba) suelen quedar bien escogidos por defecto.
  • Finalmente, se nos ofrece un resumen de la configuración y podemos salir pulsando en el botón Finish.

Ahora vamos a crear un archivo fuente para ver cómo funciona la cosa.

  • Lo que yo hago en primer lugar es crear un paquete. Selecciono el menú Source Packages de la ventana Projects, pulso el botón derecho y elijo la opción New => Java Package. Introduzco como nombre de paquete principal y pulso Finish.
  • Ahora hacemos clic en el recién creado paquete y volvemos a pulsar botón derecho escogiendo esta vez la opción New => Midlet. Escogemos un nombre para el Midlet en general y otro para la nueva clase que se va a crear y pulsamos en Finish.
  • Podéis ver el aspecto general del programa en la imagen que os adjunto a continuación

Finalizamos con los pasos de ejecución. No es tan simple como pulsar en el icono con forma de Play, pero casi.

  • Nos vamos a File => “miproyecto” properties. Hacemos clic en el ítem Application Descriptor. En la zona que se nos abre a la derecha, pulsamos en la pestaña MIDlets y luego en el botón Add. Escogemos un nombre para el MIDlet y le proporcionamos la clase principal. Lo más normal es que ya esté correctamente relleno, en mi caso la clase es principal.pruebaClase.
  • Aceptamos los datos introducidos y ahora ya podemos darle al icono con forma de Play. Si no aparece la ventana de depuración con todo lo que está sucediendo, la activamos en el menú Window => Output => Output.

En mi opinión, NetBeans tiene un autocompletado buenísimo y un chivato de errores de compilación bastante superior al de Eclipse. Por no hablar del interesante debugger (crearé una entrada para explicarlo) y de la posibilidad de diseñar tu midlet arrastrando botoncitos y programando eventos.

Una joya este IDE.

Sé el primero en valorar positivamente

Nokia abrirá el código fuente de Symbian

NOTICIÓN. Nokia quiere que Symbian sea código abierto. Para ello ha adquirido la parte de Symbian OS que estaba en manos de otras empresas como Sony y Ericsson, y ha creado la Fundación Symbian para ofrecer Symbian de forma totalmente abierta y gratuita. La nota de prensa puede descargarse aquí.

El martes pasado todavía no se había creado este nuevo sitio web, que ofrece poco más que una colección de logos y algún comunicado de prensa. Engadget comenta que los móviles que usen esta versión de Symbian no estarán disponibles hasta dentro de dos años, mientras que en XatakaMóvil se analizan las implicaciones de la creación de esta fundación. ¿Habrá una versión que se ejecute sobre el Neo FreeRunner?

Fuente: Barrapunto

Sé el primero en valorar positivamente