Leyendo javahispano.org me encontre con esta presentación de Romain Guy y Chet Haase sobre las diferencias entre crear codigo para interfaces de usuario en java y sus diferencias a la hora de crear interfaces para Android.
Buenas practicas en Java, malas para Android
octubre 1st, 2012 | Posted by in Android | Java - (1 Comments)Interesante noticia para los desarrolladores en C# y que este interesados en crear app nativas para Android y no quieran saber nada con Java.
Url: http://blog.xamarin.com/2012/05/01/android-in-c-sharp/
Cómó se hizo Pigeóns Attack con Cell SDK
marzo 15th, 2012 | Posted by in Android | Frameworks | iPhone - (0 Comments)José Daniel Sánchez Gómez de la empresa syderis.com me envia un interesante documento que explica como se realizado el juego para Móviles Pigeóns Attack utilizando el Cell SDK. Ademas del documento con el tutorial, podremos bajarnos codigo fuente tanto para Andorid, IOS y Windows Phone.
Tipos primitivos como byte arrays en java
marzo 8th, 2012 | Posted by in Android | Java - (0 Comments)Estos metodos java le pueden ser utiles a alguien que haya tenido el mismo problema que yo. En una app android necesitaba enviar algunos datos int, double, float y convertirlos a byte arrays, para enviarlos como paquetes usando el protocolo UDP.
Aca van los metodos para tratar tipos y byte arrays.
Enlace Original: http://www.daniweb.com/software-development/java/code/216874
/* ========================= */
/* "primitive type --> byte[] data" Methods */
/* ========================= */
public static byte[] toByta(byte data) {
return new byte[]{data};
}
public static byte[] toByta(byte[] data) {
return data;
}
/* ========================= */
public static byte[] toByta(short data) {
return new byte[] {
(byte)((data >> 8) & 0xff),
(byte)((data >> 0) & 0xff),
};
}
public static byte[] toByta(short[] data) {
if (data == null) return null;
// ----------
byte[] byts = new byte[data.length * 2];
for (int i = 0; i < data.length; i++) System.arraycopy(toByta(data[i]), 0, byts, i * 2, 2); return byts; } /* ========================= */ public static byte[] toByta(char data) { return new byte[] { (byte)((data >> 8) & 0xff),
(byte)((data >> 0) & 0xff),
};
}
public static byte[] toByta(char[] data) {
if (data == null) return null;
// ----------
byte[] byts = new byte[data.length * 2];
for (int i = 0; i < data.length; i++) System.arraycopy(toByta(data[i]), 0, byts, i * 2, 2); return byts; } /* ========================= */ public static byte[] toByta(int data) { return new byte[] { (byte)((data >> 24) & 0xff),
(byte)((data >> 16) & 0xff),
(byte)((data >> 8) & 0xff),
(byte)((data >> 0) & 0xff),
};
}
public static byte[] toByta(int[] data) {
if (data == null) return null;
// ----------
byte[] byts = new byte[data.length * 4];
for (int i = 0; i < data.length; i++) System.arraycopy(toByta(data[i]), 0, byts, i * 4, 4); return byts; } /* ========================= */ public static byte[] toByta(long data) { return new byte[] { (byte)((data >> 56) & 0xff),
(byte)((data >> 48) & 0xff),
(byte)((data >> 40) & 0xff),
(byte)((data >> 32) & 0xff),
(byte)((data >> 24) & 0xff),
(byte)((data >> 16) & 0xff),
(byte)((data >> 8) & 0xff),
(byte)((data >> 0) & 0xff),
};
}
public static byte[] toByta(long[] data) {
if (data == null) return null;
// ----------
byte[] byts = new byte[data.length * 8];
for (int i = 0; i < data.length; i++)
System.arraycopy(toByta(data[i]), 0, byts, i * 8, 8);
return byts;
}
/* ========================= */
public static byte[] toByta(float data) {
return toByta(Float.floatToRawIntBits(data));
}
public static byte[] toByta(float[] data) {
if (data == null) return null;
// ----------
byte[] byts = new byte[data.length * 4];
for (int i = 0; i < data.length; i++)
System.arraycopy(toByta(data[i]), 0, byts, i * 4, 4);
return byts;
}
/* ========================= */
public static byte[] toByta(double data) {
return toByta(Double.doubleToRawLongBits(data));
}
public static byte[] toByta(double[] data) {
if (data == null) return null;
// ----------
byte[] byts = new byte[data.length * 8];
for (int i = 0; i < data.length; i++) System.arraycopy(toByta(data[i]), 0, byts, i * 8, 8); return byts; } /* ========================= */ public static byte[] toByta(boolean data) { return new byte[]{(byte)(data ? 0x01 : 0x00)}; // bool -> {1 byte}
}
public static byte[] toByta(boolean[] data) {
// Advanced Technique: The byte array containts information
// about how many boolean values are involved, so the exact
// array is returned when later decoded.
// ----------
if (data == null) return null;
// ----------
int len = data.length;
byte[] lena = toByta(len); // int conversion; length array = lena
byte[] byts = new byte[lena.length + (len / 8) + (len % 8 != 0 ? 1 : 0)];
// (Above) length-array-length + sets-of-8-booleans +? byte-for-remainder
System.arraycopy(lena, 0, byts, 0, lena.length);
// ----------
// (Below) algorithm by Matthew Cudmore: boolean[] -> bits -> byte[]
for (int i = 0, j = lena.length, k = 7; i < data.length; i++) {
byts[j] |= (data[i] ? 1 : 0) << k--;
if (k < 0) { j++; k = 7; }
}
// ----------
return byts;
}
/* ========================= */
public static byte[] toByta(String data) {
return (data == null) ? null : data.getBytes();
}
public static byte[] toByta(String[] data) {
// Advanced Technique: Generates an indexed byte array
// which contains the array of Strings. The byte array
// contains information about the number of Strings and
// the length of each String.
// ----------
if (data == null) return null;
// ---------- flags:
int totalLength = 0; // Measure length of final byte array
int bytesPos = 0; // Used later
// ----- arrays:
byte[] dLen = toByta(data.length); // byte array of data length
totalLength += dLen.length;
int[] sLens = new int[data.length]; // String lengths = sLens
totalLength += (sLens.length * 4);
byte[][] strs = new byte[data.length][]; // array of String bytes
// ----- pack strs:
for (int i = 0; i < data.length; i++) { if (data[i] != null) { strs[i] = toByta(data[i]); sLens[i] = strs[i].length; totalLength += strs[i].length; } else { sLens[i] = 0; strs[i] = new byte[0]; // prevent null entries } } // ---------- byte[] bytes = new byte[totalLength]; // final array System.arraycopy(dLen, 0, bytes, 0, 4); byte[] bsLens = toByta(sLens); // byte version of String sLens System.arraycopy(bsLens, 0, bytes, 4, bsLens.length); // ----- bytesPos += 4 + bsLens.length; // mark position // ----- for (byte[] sba : strs) { System.arraycopy(sba, 0, bytes, bytesPos, sba.length); bytesPos += sba.length; } // ---------- return bytes; } /* ========================= */ /* "byte[] data --> primitive type" Methods */
/* ========================= */
public static byte toByte(byte[] data) {
return (data == null || data.length == 0) ? 0x0 : data[0];
}
public static byte[] toByteA(byte[] data) {
return data;
}
/* ========================= */
public static short toShort(byte[] data) {
if (data == null || data.length != 2) return 0x0;
// ----------
return (short)(
(0xff & data[0]) < < 8 |
(0xff & data[1]) << 0
);
}
public static short[] toShortA(byte[] data) {
if (data == null || data.length % 2 != 0) return null;
// ----------
short[] shts = new short[data.length / 2];
for (int i = 0; i < shts.length; i++) {
shts[i] = toShort( new byte[] {
data[(i*2)],
data[(i*2)+1]
} );
}
return shts;
}
/* ========================= */
public static char toChar(byte[] data) {
if (data == null || data.length != 2) return 0x0;
// ----------
return (char)(
(0xff & data[0]) << 8 |
(0xff & data[1]) << 0
);
}
public static char[] toCharA(byte[] data) {
if (data == null || data.length % 2 != 0) return null;
// ----------
char[] chrs = new char[data.length / 2];
for (int i = 0; i < chrs.length; i++) {
chrs[i] = toChar( new byte[] {
data[(i*2)],
data[(i*2)+1],
} );
}
return chrs;
}
/* ========================= */
public static int toInt(byte[] data) {
if (data == null || data.length != 4) return 0x0;
// ----------
return (int)( // NOTE: type cast not necessary for int
(0xff & data[0]) << 24 |
(0xff & data[1]) << 16 |
(0xff & data[2]) << 8 |
(0xff & data[3]) << 0
);
}
public static int[] toIntA(byte[] data) {
if (data == null || data.length % 4 != 0) return null;
// ----------
int[] ints = new int[data.length / 4];
for (int i = 0; i < ints.length; i++)
ints[i] = toInt( new byte[] {
data[(i*4)],
data[(i*4)+1],
data[(i*4)+2],
data[(i*4)+3],
} );
return ints;
}
/* ========================= */
public static long toLong(byte[] data) {
if (data == null || data.length != 8) return 0x0;
// ----------
return (long)(
// (Below) convert to longs before shift because digits
// are lost with ints beyond the 32-bit limit
(long)(0xff & data[0]) << 56 |
(long)(0xff & data[1]) << 48 |
(long)(0xff & data[2]) << 40 |
(long)(0xff & data[3]) << 32 |
(long)(0xff & data[4]) << 24 |
(long)(0xff & data[5]) << 16 |
(long)(0xff & data[6]) << 8 |
(long)(0xff & data[7]) << 0
);
}
public static long[] toLongA(byte[] data) {
if (data == null || data.length % 8 != 0) return null;
// ----------
long[] lngs = new long[data.length / 8];
for (int i = 0; i < lngs.length; i++) {
lngs[i] = toLong( new byte[] {
data[(i*8)],
data[(i*8)+1],
data[(i*8)+2],
data[(i*8)+3],
data[(i*8)+4],
data[(i*8)+5],
data[(i*8)+6],
data[(i*8)+7],
} );
}
return lngs;
}
/* ========================= */
public static float toFloat(byte[] data) {
if (data == null || data.length != 4) return 0x0;
// ---------- simple:
return Float.intBitsToFloat(toInt(data));
}
public static float[] toFloatA(byte[] data) {
if (data == null || data.length % 4 != 0) return null;
// ----------
float[] flts = new float[data.length / 4];
for (int i = 0; i < flts.length; i++) {
flts[i] = toFloat( new byte[] {
data[(i*4)],
data[(i*4)+1],
data[(i*4)+2],
data[(i*4)+3],
} );
}
return flts;
}
/* ========================= */
public static double toDouble(byte[] data) {
if (data == null || data.length != 8) return 0x0;
// ---------- simple:
return Double.longBitsToDouble(toLong(data));
}
public static double[] toDoubleA(byte[] data) {
if (data == null) return null;
// ----------
if (data.length % 8 != 0) return null;
double[] dbls = new double[data.length / 8];
for (int i = 0; i < dbls.length; i++) {
dbls[i] = toDouble( new byte[] {
data[(i*8)],
data[(i*8)+1],
data[(i*8)+2],
data[(i*8)+3],
data[(i*8)+4],
data[(i*8)+5],
data[(i*8)+6],
data[(i*8)+7],
} );
}
return dbls;
}
/* ========================= */
public static boolean toBoolean(byte[] data) {
return (data == null || data.length == 0) ? false : data[0] != 0x00;
}
public static boolean[] toBooleanA(byte[] data) {
// Advanced Technique: Extract the boolean array's length
// from the first four bytes in the char array, and then
// read the boolean array.
// ----------
if (data == null || data.length < 4) return null;
// ----------
int len = toInt(new byte[]{data[0], data[1], data[2], data[3]});
boolean[] bools = new boolean[len];
// ----- pack bools:
for (int i = 0, j = 4, k = 7; i < bools.length; i++) { bools[i] = ((data[j] >> k--) & 0x01) == 1;
if (k < 0) { j++; k = 7; }
}
// ----------
return bools;
}
/* ========================= */
public static String toString(byte[] data) {
return (data == null) ? null : new String(data);
}
public static String[] toStringA(byte[] data) {
// Advanced Technique: Extract the String array's length
// from the first four bytes in the char array, and then
// read the int array denoting the String lengths, and
// then read the Strings.
// ----------
if (data == null || data.length < 4) return null;
// ----------
byte[] bBuff = new byte[4]; // Buffer
// -----
System.arraycopy(data, 0, bBuff, 0, 4);
int saLen = toInt(bBuff);
if (data.length < (4 + (saLen * 4))) return null;
// -----
bBuff = new byte[saLen * 4];
System.arraycopy(data, 4, bBuff, 0, bBuff.length);
int[] sLens = toIntA(bBuff);
if (sLens == null) return null;
// ----------
String[] strs = new String[saLen];
for (int i = 0, dataPos = 4 + (saLen * 4); i < saLen; i++) { if (sLens[i] > 0) {
if (data.length >= (dataPos + sLens[i])) {
bBuff = new byte[sLens[i]];
System.arraycopy(data, dataPos, bBuff, 0, sLens[i]);
dataPos += sLens[i];
strs[i] = toString(bBuff);
} else return null;
}
}
// ----------
return strs;
}
RIM quiere atraer a los desarrolladores de Android
febrero 13th, 2012 | Posted by in Android | Blackberry - (1 Comments)Me entero un poco tarde en existe un concurso creado por RIM para convertir nuestras app android en su plataforma. Lamentablemente termina hoy…pero para presentarme creo que necesitaria varios meses, ya que no veo nada sencillo convertir una app android medianamente complicada en una app RIM, teniendo en cuenta por ejemplo, la diferencias al momento de armar las pantallas y los controles en cada plataforma.
Igualmente para lo que se tengan muuca fe y crean que en un dia puede lograr esta proeza, les dejo un link con informacion desde el sitio de Blackberry.
Después de una larga ausencia…debido a una mezcla de exceso de trabajo, vacaciones y decidia vuelvo a publicar en el blog. Es muy interesante esta Guia de Diseño par Android que han publicado en Google. Todos los que desarrollan para Android saben que el diseño para android se ha vuelto un poco caótico, debido a las diferentes pantallas y versiones que hay en el mercado, asi que esta guía nos puede ayudar adefinir el estilo de nuestras apps android.
XML vs JSON para mostrar información en dispositivos moviles
abril 14th, 2011 | Posted by in Android | Blackberry | iPhone | JSON | XML - (1 Comments)Desde hace unos meses estoy desarrollando dos aplicaciones Android, que hacen un uso intensivo de XML, generado en distintos servidores web. En principio, al ser un requerimiento del cliente, no pense en otras alternativas para parsear la informacion y ademas la app funcionaba muy bien (en mi punto de vista…).
Al testear la app con el cliente, me hizo notar que al momento de mostrar el XML más pesado, se tardaban unos segundos, lo cual no es nada bueno para una app movil.
Investigando un poco sobre el tema, di con este resumen escrito por Juan de Dios Maldonado Sánchez de una conferencia dada por Jeffrey Sharkey en Google I/O 2009 en donde explica los distintos usos de la batería que hace nuestro telefono, dependiendo de la tarea.
En esa misma conferencia, se muestra una comparación entre el uso de XML vs el uso de JSON, que se puede ver en este cuadro:
Evidentemente JSON es mas rapido, especialmente si los XML son muy grandes, cosa que he podido testear personalmente.
Con toda esta info, me encuentro ahora testeando las app con JSON y para hacer eso, encontré este articulo de david walsh que cuenta como utilizo Javascript para convertir los XML a JSON.
Ya se puede usar Perl para programar en Android
agosto 25th, 2009 | Posted by in Android | Perl - (1 Comments)El sistema operativo para móviles de Google, Android, ya soporta el viejo y querido Perl.
Aqui un hola mundo.
use Android;
my $a = Android->new();
$a->makeToast("Hello, Android!");
Noticia completa en inglés: http://www.h-online.com/open/Android-learns-Perl–/news/114069
Cuando estaba terminado de leer sobre la API actual, ya google lanza Android 2.0 (Donut).
Mas info en TechieSphere, en android-spa.com y en and.roid.es
Les quiero recomendar a todos los que tienen ganas de comenzar a programar para los telefonos móviles que corren sobre android o simplemente quieran saber de que se trata, una serie de articulos escritos por Javier Cancela, en su blog.
Estos articulos me han servido mucho ya que explican bien desde el principio
Copyright © 2010 All rights reserved.
Designed by 