Un nuevo entrenador se acerca a Android

http://www.lexesolutions.com.ar

Deja que este experto te guie en tu recorrido..
¿Que mejor que escuchar la mejor musica y el mejor entrenamiento echo por vos mismo y además que un experto te guie?  

Ya no necesitas mas tener varios programas juntos..

Solo con Sport Trainer podes obtener el mejor resultado.

Realizar un seguimiento y analizar sus resultados, compartir datos de entrenamiento y fotos con sus amigos, y sobre todo – ponerse en forma y mantenerse saludable.

Tenes la posibilidad de enviarte la info de tus sesiones de ejercicio y fotos a tu correo.

Prepararte tus listas de música personalizadas, nuestro entrenador durante el entrenamiento automáticamente parara la música en curso para brindarte toda la info y  luego seguir escuchando tu lista de temas.

 

Todo esto y más muy pronto en el Market.

 

 

 

Primeros pasos con Sqlite en Android

El motor de bases de datos en Android es Lite. SqLite es una base de datos transaccional que ocupa una porción pequeña de datos en memoria, por esto mismo es perfecto para dispositivos mobiles.

En este articulo explicare las sentencias básicas para insertar y modificar datos así como también creación, conexión y des-conexión y veremos como podemos comprobar que todo funciona correctamente.

Al final del tutorial encontraremos el código fuente para descargar.

Creando nuesta base de datos

Lo primero que tenemos que hacer es crear una Clase que nos administre nuesta DB. Esta clase tendra tareas como crear, insertar y borrar registros etc..
El primer paso sera entonces crear una clase que herede de SQLiteOpenHelper .

Esta clase nos proveerá los métodos que luego sobrescribiremos para manejar nuestra DB:

onCreate(SQLiteDatabase db): Se invoca cuando creamos nuestra base de datos, crea las tablas y columnas, vistas y triggers.

onUpgrade(SQLiteDatabse db, int oldVersion, int newVersion): Se invoca cuando creamos una modificacion a la base de datos como alter o dropping, ademas de crear nuevas tablas.

Bien explicado esto pasamos a nuestro ejemplo.
Nosotros vamos a crear una base de datos muy sencilla llamada BDAgenda, con una sóla tabla llamada Agenda que contendrá sólo dos campos: nombre , apellido y telefono. Para ellos, vamos a crear una clase derivada de SQLiteOpenHelper que llamaremos AgendaSqlite, donde sobrescribiremos los métodos onCreate() y onUpgrade() para adaptarlos a la estructura de datos indicada.

——————————————————————————–

public class AgendaSqlite extends SQLiteOpenHelper {

//Sentencia SQL para crear la tabla de Usuarios
String sqlCreate = "CREATE TABLE Agenda (codigo INTEGER, nombre TEXT, apellido TEXT, telefono TEXT)";

public AgendaSqlite(Context context, String name, CursorFactory factory,int version) {
super(context, name, factory, version);
}

@Override
public void onCreate(SQLiteDatabase db) {
//Se ejecuta la sentencia SQL de creación de la tabla
db.execSQL(sqlCreate);
}


@Override
public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
// En la practica deberemos migrar datos de la tabla antigua
// a la nueva, por lo que este método debería ser más elaborado.
//Se elimina la versión anterior de la tabla
db.execSQL("DROP TABLE IF EXISTS Usuarios");
//Se crea la nueva versión de la tabla
db.execSQL(sqlCreate);
}

}

—————————————————————————–

Dentro de nuestra clase el método onCreate() se ejecutara únicamente cuando sea necesario, en nuestro caso cuando para la creación de la base de datos, osea cuando la misma no exista. Ademas deben ejecutarse las tareas de inicializacion como la inserción de datos iniciales, si es que son necesarios.

Vemos también que nuestra clase tiene un constructor con los siguientes argumentos
context, name, factory, version.

context: El contexto de trabajo.
name: El nombre de nuestra base de datos.
CursorFactory: En este caso es null.
Version: La versión de nuestra DB. Cuando la versión es diferente el motor genera una nueva DB en blanco.

Posteriormente en nuestra Activity llamaremos a AgendaSqlite para instanciar un objeto de dicha clase.
Con nuestro objeto creado usamos el metodo getReadableDatabase() o getWritableDatabase() para obtener una referencia a la base de datos, dependiendo si sólo necesitamos consultar los datos o también necesitamos realizar modificaciones, respectivamente.

—————————————————————————–

public class SqlitedemoActivity extends Activity {
/** Called when the activity is first created. */
@Override
public void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
setContentView(R.layout.main);

//Abrimos la base de datos 'Agenda' en modo escritura
AgendaSqlite usdbh = new AgendaSqlite(this, "Agenda", null, 1);
SQLiteDatabase db = usdbh.getWritableDatabase();
//Si hemos abierto correctamente la base de datos
if(db != null)
{
//Insertamos 5 usuarios de ejemplo
for(int i=1; i {
//Generamos los datos
int codigo = i;
String nombre = "Usuario" + i;
String apellido = "Apellido" + i;
String telefono = "0000" + i;
//Insertamos los datos en la tabla Usuarios
db.execSQL("INSERT INTO Agenda (codigo, nombre,apellido,telefono) " +
"VALUES (" + codigo + ", '" +
nombre +"','" +
apellido +"','" +
telefono +"'" +
")");
}

//Cerramos la base de datos
db.close();
}

}
}

—————————————————————————–

Si todo sale bien corremos nuestra aplicacion y se creara nuestra base de datos dentro de la siguiente ubicacion.

/data/data/exequielc.sqlitedemo/databases/Agenda

Para comprobar esto podemos hacer lo siguiente. Una vez ejecutada por primera vez desde Eclipse la aplicación de ejemplo sobre el emulador de Android (y por supuesto antes de cerrarlo) podemos ir a la perspectiva “DDMS” (Dalvik Debug Monitor Server) de Eclipse y en la solapa “File Explorer” podremos acceder al sistema de archivos del emulador, donde podremos buscar la ruta indicada de la base de datos. Podemos ver esto en la siguiente imagen (click para ampliar):

Para visualizar la base de datos podemos descargar el siguiente aplicativo gratuito desde la siguiente ubicacion.

http://sqliteadmin.orbmu2k.de/

Una ves descargado, la ejecutamos y procedemos a abrir nuestro archivo(“Agenda”) generado recientemente.

Bueno espero que les sea util este breve ejemplo,
lo pueden descargar desde aquí.

Saludos!!

Trabajando con fechas en java

Trabajar con fechas en java no es para nada complicado, pero puede llegar a confundirnos si tomamos en cuenta la cantidad de formas que java nos ofrece para hacerlo.

En este articulo explicare brevemente como utilizar las funciones mas comunes y un breve ejemplo/proyecto en Android aplicando lo antes explicado.

Las clases java.util.Date y java.sql.Date. Son las clases mas usadas para el trabajo con fechas.

java.util.Date: La clase java.util.Date representa un instante de tiempo específico, con precisión de milisegundos.

java.util.Date utilDate = new java.util.Date();
System.out.println(“java.util.Date: ” + utilDate);

• El año “y” está representado por un entero igual a (“y” – 1900). Por ejemplo el año 2004 se representa como 104 (2004 – 1900).
• Los meses son representados por números entre 0 y 11, donde enero es 0 y diciembre es 11.
• Los días y minutos se representan de forma corriente. Entre 1 – 31 y 0 – 59 respectivamente.
• Las horas van entre 0 y 23, donde la medianoche es 0 y el medio día 12.
• Los segundos van entre 0 y 61. (el 61 solo en casos excepcionales)Si necesitamos obtener el año el mes el dia la hora,minuto o segudo necesitaremos llamar a la clase java.util.Calendar para que nos provea de dicha informacion.

java.sql.Date: Esta clase hereda de java.util.Date y se instancia pasándole un tipo de dato long a su constructor.

java.sql.Date sqlDate = new java.sql.Date(utilDate.getTime());
System.out.println(“java.sql.Date.: ” + sqlDate);

Pero tambien podemos aplicar la forma inversa de la siguiente manera:
java.util.Date utilDate2 = new java.util.Date(sqlDate.getTime());

Creando nuestro proyecto en Android.

Es muy simple, nuestro codigo  consiste en  un TimePicker en donde seteamos una hora y un EditText donde adicionaremos un numero para agregar “tiempo al tiempo”

Primero definimos las variables que luego utilizaremos

private int mYear;
private int mMonth;
private int mDay;
private int mHour;
private int mMinute;
private TextView tv_resultado;
private EditText ed_duration;
private TimePicker tp_time;
private Button btn_calcular;
static final int TIME_DIALOG_ID = 0;
private java.util.Date utilDate;

y obtenemos todos los elementos de nuestro xml

tv_resultado = (TextView) findViewById(R.id.tv_resultado);
ed_duration = (EditText) findViewById(R.id.ed_duration);
tp_time = (TimePicker)findViewById(R.id.tm_time);
btn_calcular = (Button)findViewById(R.id.btn_calcular);

Instanciamos un objeto desde la clase Calendar y extraemos la fecha hora actual.
final Calendar c = Calendar.getInstance();
mYear = c.get(Calendar.YEAR);
mMonth = c.get(Calendar.MONTH);
mDay = c.get(Calendar.DAY_OF_MONTH);
mHour = c.get(Calendar.HOUR_OF_DAY);
mMinute = c.get(Calendar.MINUTE);

Luego en el evento click del botón aplicamos el proceso de calculo.

Creamos un objeto de tipo java.util.Date pasandole la fecha hora antes obtenida.

utilDate = new java.util.Date(mYear, mMonth, mDay, mHour, mMinute);

usamos utilDate.getTime() para calcular nuestro tiempo previamente definido.

long d = utilDate.getTime() + duration * 60 * 1000;

Convertimos a fecha nuestro resultado

Date resDate = new Date(d);

Y finalmente mostramos el objeto fecha formateado usando SimpleDateFormat
SimpleDateFormat formatter = new SimpleDateFormat(“dd/MM/yy HH:mm”);

tv_resultado.setText(formatter.format(resDate));

Dejo el fuente del codigo para descargar..desde aquí.

Espero que les sirva..Saludos!!

Java versus PHP versus Ruby

 

BlogPulse es un sitio que se dedica a la búsqueda automática de “tendencias”, se pueden ver diferentes listados de tendencias de citas en la blogosfera, frases, sitios, autores, etc.

Esta tendencia es generada a partir de simples palabras clave y no excluye las referencias no deseadas como la de la isla de Java o de rubí de la joya. Tratar los datos con cautela.

Evitar la Tecnica del paracaidista

Impulsar los resultados de una organización importando talento del exterior no suele ser una buena estrategia.

Pilar Jericó, en su libro La Gestión del Talento advierte: “¡Cuidado con la técnica del paracaidista!. Las empresas más admiradas promocionan internamente, y no les va nada mal. Cuando un profesional, considerado paracaidista, aterriza en una compañía, tenga por seguro que “golpea con su paracaídas” a la motivación de sus compañeros.”

Tratar en la medida de lo posible evitar la técnica del paracaidista. Esto desanima a la mayoría de los empleados que se han forzado por lograr un ascenso o promoción internos al intentar cambiar viejos paradigmas de la empresa de manera exitosa, decrementándose la tendencia a lograr más productividad. Debe tratarse por el contrario de incrementar la promoción interna, reconocer los talentos de los empleados y no de desconocidos, impuestos por políticas o amiguismos, lo cual es poco ético.

Lo mejor es incluir personal junior, capacitarlo y crecer en familia. El rendimiento y el entendimiento del grupo de trabajo se veran ampliamente favorecidos.

Implante herramientas para identificar las capacidades potenciales. Descubra los talentos dentro de la organización, a través de la puesta en práctica de herramientas de identificación; pero sobre todo, no olvide comunicárselos.