Y es que me da un escalofrío cada vez que lo veo… incluso mayor que cuando veo el original.

Como usuario, tenía “Administrador” y me fijé que NO tenía contraseña. Tonces entré y le puse guardar credenciales porque, se suponía, no necesitaba nada más.

Resulta que SI necesitaba una contraseña… aunque no se por qué… y cuando entraba

Sin acceso a la red

Leyendo por ahí, llegue a que las credenciales se pueden borrar.

Se ejecuta editarasd rundll32 keymgr.dll, KRShowKeyMgr y tenemos el listado de todos los que guardamos.

Ventanita

En mi caso, elimino el que quedo malo… y luego vuelvo a entrar

Peeeero, resulta que aquí la red es wi-fi con un dhcp malvado… vez que reinician el router queda la escoba con el listado…

Por eso me dio por hacer una pequeñita aplicación que tomara la IP y el nombre de la máquina de la persona y la guardara en una colección así de fácil.

Salto y a picar código

Asumo que ya saben cómo instalar mongo (si no, lo pueden buscar atrás en los post), así que me salto esa parte.

Primero, tengo un XML con las configuraciones del servidor. Algo así:

<?xml version="1.0" encoding="utf-8" ?>
<Preferencias>
  <Servidor>192.168.2.113</Servidor>
  <Puerto>27017</Puerto>
  <Base>proexsi</Base>
</Preferencias>

Se explica bastante claro creo

Lo segundo es leer las configuraciones. Esto lo metí dentro de una función en mi clase que devuelve el string de conexión:

Private Function Preferencias() As String
        Try
            Dim string_preferencias As New StringBuilder
            Dim lector As XmlTextReader = New XmlTextReader("preferencias.xml")
            lector.ReadToFollowing("Servidor")
            string_preferencias.Append(lector.ReadElementContentAsString).Append(":")
            lector.ReadToFollowing("Puerto")
            string_preferencias.Append(lector.ReadElementContentAsString).Append("/")
            lector.ReadToFollowing("Base")
            string_preferencias.Append(lector.ReadElementContentAsString)
            Return "mongodb://" & string_preferencias.ToString
        Catch ex As Exception
            Console.WriteLine(ex.Message)
            Return Nothing
        End Try
    End Function

En el constructor de mi clase funciones realizo la conexión y cosas, tomando el parámetro de la función anterior

Public Sub New()
        Try
            Dim conString As String = getPreferencias()
            obj_mongoserver = MongoServer.Create(conString)
            proexsiBD = obj_mongoserver.GetDatabase("proexsi")
            usuarios = proexsiBD.GetCollection("usuarios")
        Catch ex As Exception
            Console.WriteLine(ex.Message)
            Me.error_ = ex.Message
            Console.ReadLine()
            Return
        End Try
    End Sub

Como ven, tengo el servidor, la bd y la colección que vamos a usar. Estos atributos los instanc(s,z)io así:

 Private datos_ips As List(Of String)
    Private obj_mongoserver As MongoServer
    Private proexsiBD As MongoDatabase
    Private usuarios As MongoCollection
    Private error_ As String = "Error"

Sigamos. Ahora leemos las IPs con el siguiente código:

Private Function IPeses() As List(Of String)
        Dim valores As New List(Of String)
        For Each tmp As IPAddress In Dns.GetHostEntry(Dns.GetHostName).AddressList
            If (tmp.ToString.Length < 15) Then
                valores.Add(Dns.GetHostName)
                valores.Add(tmp.ToString)
                Return valores
            End If
        Next
        Return Nothing
    End Function

Como leen, el Dns.GetHostEntry(“nombre_de_maquina”).AddressList devuelve un array, que desmenuzamos con un for each. El array trae la ip, y direcciones MACs. No se me ocurrió otra forma de saber si era IP o MAC

La función anterior, a su vez, es parámetro de otra, que se encarga de ingresar los valores en la bd. El código es así:

Private Function Ingreso(valores As List(Of String)) As Boolean
        Try
            valores.ForEach(Sub(x As String) Console.WriteLine(x))
            Console.WriteLine("----------------------------------------------------------")
            Dim usuario As New BsonDocument
            If Not existe(valores(0)) Then
                usuario("Nombre") = "usuario"
            End If
            usuario("PC") = valores(0)
            usuario("IP") = valores(1)
            Console.WriteLine(usuario.Elements.ToJson.ToString)
            Console.WriteLine("----------------------------------------------------------")

            If usuario.ElementCount = 3 Then
                usuarios.Insert(usuario)
            Else
                Dim q = Query.EQ("PC", valores(0))
                Dim u = Update.Set("IP", valores(1))
                usuarios.FindAndModify(q, Nothing, u, True)
            End If
            Return True
        Catch ex As Exception
            Console.WriteLine(ex.Message)
            Return False
        End Try
    End Function

Aquí tenemos un insert y un update set. Básicamente revisamos si es primera vez que se registra el PC o es una actualización de IP.
La manera de crear documentos es bastante simple, y de hecho se parece al ingreso de json . Una vez que lo tenemos listo, simplemente no insertamos tal cual.
Si no, hacemos una actualización de UN ATRIBUTO del documento, no el documento entero ! q es el filtro (que la máquina sea = a “Mario-PC” por ejemplo) y el valor a actualizar es la IP en la variable u. Ingresamos y se acaba el problema

La última función, es para ver si el registro es nuevo o no. El código es el siguiente:

Private Function existe(pc As String) As Boolean
        Try
            Dim registros As MongoCollection(Of BsonDocument) =
                proexsiBD.GetCollection(Of BsonDocument)("usuarios")
            Dim array As New List(Of String)
            array.Add(pc)
            Dim q = Query.All("PC", BsonArray.Create(array))
            Console.WriteLine(registros.Find(q).Query)
            Console.WriteLine("----------------------------------------------------------")
            If registros.Find(q).Count = 0 Then
                Console.WriteLine("Nuevo")
                Return False
            Else
                Console.WriteLine("Existe")
                Return True
            End If
        Catch ex As Exception
            Console.WriteLine("* * * " & ex.Message & " * * *")
            Return Nothing
        End Try
    End Function

Aquí hacemos una búsqueda de todos los documentos, si el valor de PC existe en algún lado con el valor Mario-PC Si no encontramos ningún documento que contenga al PC Mario-PC, es uno nuevo. Si no, lo contrario

Por último, el ejecutable de consola:

Sub Main()
        Dim c As New Controlador
        Dim flag As Boolean = c.setIngreso(c.getDatos_ips)
        If flag Then
            Console.Write("IP Actualizada")
        Else
            Console.WriteLine("x_X")
        End If
        Console.ReadLine()
    End Sub

Se instanc(s,z)ia la clase y eso sería todo

Como leen, es una aplicación de consola (No necesito que el usuario interactue ni nada )

Aqui es un extracto

La sala de conciertos de la Ópera de Sydney contiene 2.700 personas. Este blog fue visto cerca de 17.000 veces en 2011. Si fuese un concierto en la Ópera, se necesitarían alrededor de 6 actuaciones agotadas para que toda esa gente lo viera.

Haz click para ver el reporte completo.

** Nota: Utilizando la versión de 32 bits de MongoDB, estamos limitados a 2 GB de datos aprox. Ver http://blog.mongodb.org/post/137788967/32-bit-limitations

Opciones Generales:

• -h [ --help ] Muestra ésta información.
• –version Muestra la versión.
• -f [ --config ] Agrega un archivo de configuración (como parámetro) especificando opciones adicionales.
• -v [ --verbose ] Ser más detallado (Mientras más “v”, nivel de detalle ej. -vvvvv)
• –quiet Salidas más silenciosas (en nivel de detalle)
• –port Agrega puerto especificado como parámetro
• –bind_ip arg Listado de direcciones IP, separadas por comas “,” de las cuales se escucharán peticiones. Por defecto, se escuchan TODAS las IPs.
• –maxConns Máximo de conexiones simultaneas como parámetro.
• –objcheck Inspecciona los datos del cliente para validar la recepción.
• –logpath Archivo log donde se escriben todas las salidas del servidor, en vez de hacerlo por pantalla. Debe ser un archivo, no una carpeta.
• –logappend Añadir entradas al logpath en vez de sobre escribirlas.
• –pidfilepath Ruta absoluta (como parámetro) al pidfile. (Si no se agrega, ningún pidfile es creado).
• –keyFile pass para la autentificación de clusters (solo para replicas).
• –auth Se ejecuta en modo seguro.
• –cpu Periódicamente muestra el uso de cpu e iowait.
• –dbpath Parámetro ruta del directorio donde almacena los datos.
• –diaglog arg 0=off 1=W 2=R 3=both 7=W+some reads
• –directoryperdb Cada bd se almacenará en un directodio personal.
• –journal enable journaling
• –journalOptions arg journal diagnostic options
• –journalCommitInterval arg how often to group/batch commit (ms)
• –ipv6 Habilita soporte para IPv6 (deshabilitado por defecto).
• –jsonp Permite acceso JSONP via http (implica valores de seguridad).
• –noauth No se ejecuta en modo seguro.
• –nohttpinterface Deshabilita interface http.
• –nojournal disable journaling (journaling is on by defaultfor 64 bit)
• –noprealloc Deshabilita el prealojamiento de archivos de datos (implica disminución en desempeño).
• –noscripting Deshabilita motor de scripting.
• –notablescan No permite búsquedas en tablas.
• –nssize arg (=16) .ns file size (in MB) for new databases
• –profile arg 0=off 1=slow, 2=all
• –quota Limita cada bd a cierta cantidad de archivos (8 por defecto).
• –quotaFiles Parámetro de cantidad de número de archivos permitidos por bd. Requiere del comando anterior.
• –rest turn on simple rest api
• –repair Ejecuta “reparar” en todas las bds.
• –repairpath arg root directory for repair files – defaults to dbpath
• –slowms arg (=100) value of slow for profile and console log
• –smallfiles use a smaller default file size
• –syncdelay arg (=60) seconds between disk syncs (0=never, but not recommended)
• –sysinfo print some diagnostic system information
• –upgrade upgrade db if needed

Windows Service Control Manager options:

• –install Instala el servidor como un servicio.
• –remove Lo remueve…
• –reinstall Reinstala el servicio (primero lo desinstala y luego lo vuelve a instalar)
• –serviceName Parámetro para determinar el nombre del servicio (para windows).
• –serviceDisplayName  Parámetro para determinar el nombre a mostrar del servicio (para windows).
• –serviceDescription  Parámetro para determinar la descripción del servicio (para windows).
• –serviceUser Parámetro para determinar el usuario que ejecutará el servicio.
• –servicePassword Parámetro para la contraseña del usuario usado anteriormente.

Replication options:

• –fastsync Indica que ésta instancia se inicia desde una ruta de instantánea dbpath del par de replicación.
• –oplogSize Parámetro que indica el límite del tamaño (en MB) para el log op.

Master/slave options:

• –master Modo master.
• –slave Modo slave.
• –source Parámetro si es slave: especifica al master como <server:port>
• –only Parámetro si es slave: especifica una única bd a replicars.
• –slavedelay Parámetro que especifica el retraso (en segundos) a usar cuando se apliquen opciones desde el master al slave.
• –autoresync Automáticamente resincronisa si los datos del slave son antiguos.

Replica set options:

• –replSet arg arg is <setname>[/<optionalseedhostlist>] //NI IDEA COMO SE TRADUCE ESTO…

Sharding options:

• –configsvr Define que esto es una db configuración de un cluster; puerto por defecto 27019; Directorio por defecto /data/configdb
• –shardsvr Define que esto es una bd fragmento de un cluster; puerto por defecto 27018
• –noMoveParanoia Desactiva el ahorro “paranóico” para moveChunk. Por defecto viene activado (por ahora).

En la entrada anterior, vimos como crear un login de usuario consultando un servidor, y dependiendo de la respuesta entramos o no al sistema. La respuesta era super simple y no escribí nada sobre JSON o cómo entenderlo… por lo que ahora vamos a verlo.

JSON es una forma de almacenar información de manera ligera. En JSON lo que se guardan son objetos, pero en texto plano. Se organiza de tal manera que es relativamente simple entender en todo momento qué es lo que tenemos

Todo objeto comienza con su nombre (dah ), seguido por : y luego sus atributos dentro de llaves {}. Al ser objetos, puedes tener objetos dentro de objetos, o arreglos de objetos. Los objetos deben ir entre comillas (” “) para identificar su nombre; de la misma forma sus valores, a menos que sean números.

En el ejemplo anterior (del login) teníamos la siguiente estructura

{"mensaje": {"Estado": "OK", "Unidad": "Pintura", "CodUnidad": 5}}
{"mensaje": {"Estado": "ERROR", "Mensaje": "Pass incorrecta."}}

Leyendo a la rápida, para la primera tenemos el objeto mensaje, con 3 atributos (objetos):

1. Estado, con su valor OK.
2. Unidad, valor Pintura
3. CodUnidad, valor 5

Y el segundo se llama igual, con sus respectivos atributos.

Veamos un ejemplo más largo e incluyendo más datos (La identación no es necesaria, pero lo hice para visualizarlo más rápido ).

{
  "Ordenes": [
    {
      "Orden": {
	"id": 5,
	"Nombre": "5162310 Reparación cubierta Principal - Según Inspección",
	"Descripcion": "Reparación cubierta Principal - Según Inspección",
	"Proyecto": "BP FIORELLA"
      }
    },
    {
      "Orden": {
	"id": 4,
	"Nombre": "5162240 Cambiar plancha casco sector tunel + canaletas enfriamiento",
	"Descripcion": "Cambiar plancha casco sector tunel + canaletas enfriamiento",
	"Proyecto": "BP FIORELLA"
      }
    },
    {
      "Orden": {
	"id": 3,
	"Nombre": "5162210 Nuevo Doble fondo",
	"Descripcion": "Nuevo Doble fondo",
	"Proyecto": "BP FIORELLA"
      }
    },
    {
      "Orden": {
	"id": 2,
	"Nombre": "5162230 Nuevo Forro tunel",
	"Descripcion": "Nuevo Forro tunel",
	"Proyecto": "BP FIORELLA"
      }
    },
    {
      "Orden": {
	"id": 1,
	"Nombre": "5162220 Bases Descansos Linea de eje",
	"Descripcion": "Bases Descansos Linea de eje",
	"Proyecto": "BP FIORELLA"
      }
    }
  ],
  "Proyectos": [
    "BP FIORELLA"
  ]
}

Tenemos 2 objetos en este JSON: Ordenes y Proyectos. Los 2 son objetos de Arrays. Los JSONArray comienzan con [], y se separan por , . El primero es un arrays de objetos y el segundo un array de strings.

Para el primero (Ordenes) podemos notar que es un array de objetos porque cada valor del array comienza con { , a diferencia de Proyectos que solo contiene un atributo.

Árbol

Esa fue la salida… pero cómo se hizo?

Al ser esto un archivo de texto, puede crearse concatenando un String o usando la librería Json. Concatenar un String es lo más cómodo si tenemos una estructura corta (como la del login), teniendo cuidado de ubicar bien las llaves. Pero si es algo más elaborado, lo mejor es usar las herramientas que nos entrega Json con json.put

Imaginemos que estamos en un servlet, y nos ha llegado una petición para entregar la estructura de arriba. La forma de llenarlo, es de adentro hacia afuera: Comenzando por el objeto orden, dentro del array del objeto ordenes.

Entonces creamos el objeto json de la clase JSONObject (suponiendo que están siguiendo el link de arriba. Aquí vamos a contener todo.

Ahora creamos 2 objetos más, de la clase JSONArray: proyectos  y ordenes. Empezando por el más fácil (proyectos) insertamos un valor por cada String. En el ejemplo de arriba solo tengo un elemento, pero si fueran más, quedaría algo así:

//Array con todos los valores a agregar
ArrayList<String> Arrayproyectos = new ArrayList<String>();
Arrayproyectos.add("Proyecto 1"); Arrayproyectos.add("Proyecto 2"); Arrayproyectos.add("Proyecto 3");
//Iteramos e ingresamos cada elemento a el JsonArray
for(String s : Arrayproyectos){
   proyectos.put(s);
}

Y obtenemos algo así:
[Proyecto 1, Proyecto 2, Proyecto 3]

Teniendo nuestro JsonArray proyectos listo, lo agregamos al contenedor json de la misma manera, pero agregando un parámetro que determina el nombre del valor.

json.put("Proyectos", proyectos);

Y de esta forma ya tenemos el primer elemento en nuestro contenedor.

Para ingresar el array ordenes, se hace de la misma manera, pero combinando entre array y objeto. Algo así

/*Suponiendo que vamos a ingresar 5 objetos al array */
JSONArray ordenes = new JSONArray();
for(int i=0; i<5; i++){
//Primero llenamos el objeto orden
   JSONObject orden = new JSONObject();
   orden.put("id", VARIABLE_CON_ID);
   orden.put("Nombre", VARIABLE_CON_NOMBRE);
   orden.put("Descripcion", VARIABLE_CON_DESCRIPCION);
   orden.put("Proyecto", VARIABLE_CON_PROYECTO);
//Ahora que lo llenamos, lo metemos en el array
   ordenes.put(orden);
}
//Ya que salimos del for, tenemos 5 ordenes en el array.
//Metemos el array en el contenedor
json.put("Ordenes", ordenes); 

Y esa es toda la ciencia de esta manera generamos el json. Podemos hacer lo mismo cuantas veces queramos, logrando muchos más niveles de profundidad.

Con esto terminamos la generación del json en el servidor. Vamos ahora a Android para leerlo, aunque se hace de la misma manera, pero a la inversa

//Creamos el objeto JSONObject y lo instanciamos con el string entregado por el servidor.
//Lo mismo que la entrada pasada.
JSONObject job = new JSONObject(stream.toString());
//Creamos los JSONArrays
JSONArray ordenes = new JSONArray(job.getJSONArray("Ordenes").toString());
JSONArray proyectos = new JSONArray(job.getJSONArray("Proyectos").toString());
//Recorremos el primer JSONArray
for(int i = 0; i < ordenes.length(); i++){
   //Creamos el objeto para leer lo que viene en la posición i
   JSONObject orden = ordenes.getJSONObject(i);
   //Creamos el objeto orden propiamente tal
   JSONObject o = orden.getJSONObject("Orden");
   //Accedemos a los valores
   int id = o.getInt("id");
   String nombre = o.getString("Nombre");
   //....
}

//Para leer el Array proyectos, lo mismo
for(int i = 0; i < proyectos.length(); i++){
   String proyecto = proyectos.getString(
}

Login Activity

Lo primero entonces es crear el esqueleto del login. Lo hice en una tabla, con 2 textview, 2 edittexts y 1 botón. El código es así:

<?xml version="1.0" encoding="utf-8"?>
    <TableLayout xmlns:android="http://schemas.android.com/apk/res/android"
        android:layout_width="fill_parent"
        android:layout_height="fill_parent"
        android:stretchColumns="1">
        <TableRow>
            <TextView android:text="Usuario: "
                android:id="@+id/TextView01"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content">
            </TextView>
            <EditText android:text=""
                android:id="@+id/txtUsername"
                android:layout_width="fill_parent"
                android:layout_height="wrap_content">
            </EditText>
        </TableRow>
        <TableRow>
            <TextView android:text="Contraseña: "
                android:id="@+id/TextView02"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content">
            </TextView>
            <EditText android:text=""
                android:id="@+id/txtPass"
                android:layout_width="fill_parent"
                android:layout_height="wrap_content"
                android:password="true">
            </EditText>
        </TableRow>
        <TableRow>
            <Button android:text="Conectar"
                android:id="@+id/btnLogin"
                android:layout_width="fill_parent"
                android:layout_height="wrap_content">
            </Button>
        </TableRow>
    </TableLayout> 

Ahora que tenemos el esqueleto, vamos a nuestra clase Activity principal. Primero los imports que se usarán (son bastantes…):

package marcoTablet.Android;

import android.app.Activity;
import android.os.Bundle;
import android.view.View;
import android.view.View.OnClickListener;
import android.widget.Button;
import android.widget.EditText;
import android.widget.Toast;
import android.util.Log;

import org.apache.http.client.HttpClient;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.client.ClientProtocolException;
import org.apache.http.NameValuePair;
import org.apache.http.message.BasicNameValuePair;
import org.apache.http.client.entity.UrlEncodedFormEntity;
import org.apache.http.HttpResponse;

import org.json.JSONArray;
import org.json.JSONObject;
import org.json.JSONException;

import java.util.List;
import java.util.ArrayList;

import java.io.UnsupportedEncodingException;
import java.io.IOException;
import java.io.InputStream;
import java.io.BufferedReader;
import java.io.InputStreamReader;

import java.lang.IllegalStateException;
import java.lang.StringBuilder;

import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

En el onCreate solamente creo objetos para retener los controles, y al botón le asigno el evento click para empezar el logueo.

     public void onCreate(Bundle savedInstanceState)
    {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main);

        txtUsername = (EditText)this.findViewById(R.id.txtUsername);
        txtPass = (EditText)this.findViewById(R.id.txtPass);
        btnLogin = (Button)this.findViewById(R.id.btnLogin);
        btnLogin.setOnClickListener(new OnClickListener(){
            @Override
            public void onClick(View v){
                validar(txtUsername.getText().toString(), txtPass.getText().toString());
            }
        });
    }

Ahora, vamos a la función validar que recibe el nombre de usuario y su contraseña, y devuelve un boolean para ver si estamos bien o no.

private boolean validar(String username, String pass){
        /* Comprobamos que no venga alguno en blanco. */
        if (!username.equals("") && !pass.equals("")){
            /* Creamos el objeto cliente que realiza la petición al servidor */
            HttpClient cliente = new DefaultHttpClient();
            /* Definimos la ruta al servidor. En mi caso, es un servlet. */
            HttpPost post = new HttpPost("http://192.168.0.142:8080/marcoWeb/Login");

            try{
                /* Defino los parámetros que enviaré. Primero el nombre del parámetro, seguido por el valor. Es lo mismo que hacer un
                 http://192.168.0.142:8080/marcoWeb/Login?username=mario&pass=maritoPass&convertir=no */
                List<NameValuePair> nvp = new ArrayList<NameValuePair>(2);
                nvp.add(new BasicNameValuePair("username", username));
                /* Encripto la contraseña en MD5. Definición más abajo */
                nvp.add(new BasicNameValuePair("pass", toMd5(pass)));
                nvp.add(new BasicNameValuePair("convertir", "no"));
                /* Agrego los parámetros a la petición */
                post.setEntity(new UrlEncodedFormEntity(nvp));
                /* Ejecuto la petición, y guardo la respuesta */
                HttpResponse respuesta = cliente.execute(post);

                try{
                    /* Traspaso la respuesta del servidor (que viene como JSON) a la instancia de JSONObject en job.
                     /* Definición de inputStreamToString() más abajo. */
                    JSONObject job = new JSONObject(this.inputStreamToString(respuesta.getEntity().getContent()).toString());
                    /* Nuevo objeto, que contiene el valor para mensaje (definido en el JSON que crea el servidor */
                    JSONObject mensaje = job.getJSONObject("mensaje");
                    /* Muestro la respuesta */
                    Toast.makeText(Login.this, mensaje.getString("Estado"), Toast.LENGTH_LONG).show();
                    /* Abajo todas los exceptions que pueden ocurrir. Se imprimen en el log */
                    return true;
                }catch(JSONException ex){
                    Log.w("Aviso", ex.toString());
                    return false;
                }
            }catch(ClientProtocolException ex){
                Log.w("ClientProtocolException", ex.toString());
                return false;
            }catch(UnsupportedEncodingException ex){
                Log.w("UnsupportedEncodingException", ex.toString());
                return false;
            }catch(IOException ex){
                Log.w("IOException", ex.toString());
                return false;
            }
            catch(IllegalStateException ex){
                Log.w("IOException", ex.toString());
                return false;
            }
        }else{
            Toast.makeText(Login.this, "Campo vac'io !",
                            Toast.LENGTH_LONG).show();
            return false;
        }
    }

La respuesta del servidor es así:
Login OK:

{"mensaje": {"Estado": "OK", "Unidad": "Pintura", "CodUnidad": 5}}

Login MAL

{"mensaje": {"Estado": "ERROR", "Mensaje": "Pass incorrecta."}}

La forma de leer los datos de la BD y el traspaso a JSON no lo escribiré, ya que no viene al caso. Solo decir que la cabecera debe ser (en caso de un servidor java) de esta manera

response.setContentType("application/json");
response.setCharacterEncoding("UTF-8");

Ahora, para traspasar la respuesta del servidor(que viene como dirección de memoria)hasta el objeto JSON primero la leemos, la pasamos a string, y luego la devolvemos. Con la función inputStreamToString

private StringBuilder inputStreamToString(InputStream is) {
        String line = "";
        StringBuilder total = new StringBuilder();
        //Guardamos la dirección en un buffer de lectura
        BufferedReader rd = new BufferedReader(new InputStreamReader(is));

        //Y la leemos toda hasta el final
        try{
            while ((line = rd.readLine()) != null) {
                total.append(line);
            }
        }catch(IOException ex){
            Log.w("Aviso", ex.toString());
        }

        // Devolvemos todo lo leido
        return total;
    }

Por último, la función para convertir la contraseña a MD5.

private String toMd5(String pass){
        try{
            //Creando Hash MD5
            MessageDigest digest = MessageDigest.getInstance("MD5");
            digest.update(pass.getBytes());
            byte messageDigest[] = digest.digest();

            //Creando Hex String
            StringBuffer hexString = new StringBuffer();
            for(int i=0; i<messageDigest.length; i++)
                hexString.append(Integer.toHexString(0xFF & messageDigest[i]));
            Log.w("Pass en MD5: ", hexString.toString());
            return hexString.toString();
        }catch(NoSuchAlgorithmException ex){
            Log.w("NoSuchAlgorithmException", ex.toString());
            return null;
        }
    }

Agregar que esto no funcionará a menos que le demos permiso a la aplicación para que puede conectarse a internet. Para eso vamos al archivo androidmanifest.xml y agregamos la siguiente línea antes de la etiqueta de application.

<uses-permission android:name="android.permission.INTERNET" /> 

• http://www.sgoliver.net
• http://catchmayuri.blogspot.com/2010/12/sample-android-login-application.html
• http://www.androidsnippets.com/executing-a-http-post-request-with-httpclient
• http://www.wikihow.com/Execute-HTTP-POST-Requests-in-Android
• http://developer.android.com/index.html
• http://blog.donnfelker.com/2010/04/29/android-odd-error-in-defaulthttpclient/
• http://www.androidsnippets.com/get-the-content-from-a-httpresponse-or-any-inputstream-as-a-string
• http://www.androidsnippets.com/create-a-md5-hash-and-dump-as-a-hex-string
• http://www.javacodegeeks.com/2011/01/android-json-parsing-gson-tutorial.html

Demás esta decir que la actualizaré a medida que encuentre algún link útil 8)

Estoy desarrollando un sistema en una empresa, uno de los módulos debe correr en tablets (que vienen con Android) y ps… nunca he hecho nada D:

Ayer fuimos a comprar una tablet para las pruebas y ahora la tengo aquí al lado mio gastando la batería

Empezamos entonces Lo primero es descargar el SDK de Android desde la misma web. Como ya saben, soy usuario Linux así que no se si el funcionamiento es el mismo en otras plataformas 8O 

Link Descarga SDK. Ahora que lo descargan, lo descomprimen y lo mueven a donde quieran. Yo lo hice a /home/luk0s/Documentos/.android-sdk-linux/pero depende de dónde lo quieran dejar ustedes. Lo segundo, es agregar la carpeta tools al path del sistema, apuntando obviamente a la carpeta que acabamos de descomprimir.

export PATH=${PATH}:/home/luk0s/Documentos/.android-sdk-linux/tools

Ahora entramos a la carpeta tools y ejecutamos el archivo android (previo cambio de permisos).

Se abre una ventana como ésta

Android SDK Manager

donde pueden instalar las APIs de las distintas versiones que hasta el momento tiene el sistema. En mi caso, instalé solamente las de Android 2.2 y 2.1 ya que las tablet solo tienen eso instalado… y como la tablet es del trabajo no le puedo meter mano D:

Y esa es toda la “instalación” del cuento… pueden ir a la documentación oficial para mayor info.

Ahora, agregamos un plugin a Netbeans (tengo la versión 7) para hacer más simple la creación de apps (que si no sería todo por consola D: )

Entramos al administrador de plugins en Netbeans, creamos una entrada nueva y le agregamos estos datos: NBAndroid (o el que quieran) y la URL para obtener la info: http://deadlock.netbeans.org/hudson/job/nbandroid/lastStableBuild/artifact/build/updates/updates.xml  Lo siguiente es buscar los plugins e instalarlos  Listo! Ahora agregamos un nuevo proyecto e ingresamos la info necesaria  Es importante apuntar a la carpeta donde tenemos el sdk (/home/luk0s/Documentos/.android-sdk-linux/) en el botón Manage Android SDK. Luego apuntamos la versión que vamos a usar. Y eso sería todo  Para correr las apps que desarrollemos, tenemos que agregar un dispositivo virtual usando el emulador. Para eso abrimos el SDK Manager y en el menú, bajo Tools tenemos Manage ADV. Creamos uno con las mismas características que nuestro tablet. El mio por ejemplo es así:  Ahora la tenemos para jugar con ella En netBeans, le hacemos un Build a nuestro proyecto, y luego un Run. Automágicamente toma el dispositivo que acabamos de crear. Esperamos que arranque y tadaaaa  (Aunque ahora que lo pienso… no es igual al del tablet… creo que era un Android 2.2 pero bue, funciona

Eso

Referencia: tarjuccino.com

En la BD tengo guardados los datos como date, obvio, el tenía que hacer el traspaso del mes en número a palabra… obviamente una lata. Hacerlo en la aplicación no era un opción tampoco (se imaginan leer la fecha desde la BD, traspasarla, y recién mostrarla? ). Me dio por hacerlo directamente en la BD, como una función. Peeero nunca había hecho nada de nada. Leí varios lenguajes y formas de hacerlo… la cosa más fea que he visto en mi vida DECLARE, BEGIN, END. Nah… simplemente no era lo mio.

Hasta que descubrí cómo re diantres programar las funciones en python ! Y de eso trata el tuto  

Lo primero es revisar que tengas la librería para hacerlo. En mi caso (Pardus Linux) lo hice con estos comandos:

whereis postgresql
postgresql: /usr/lib/postgresql /usr/include/postgresql /usr/share/postgresql
cd /ust/lib/postgresql/
ls 

Y entre los archivos, tenía la librería plpython.so necesaria para hacer todo el cuento.

Ahora necesitamos crear algo que maneje la comunicación entre la librería y pgsql. Para eso, creamos una función. Vamos a pgadmin (o por shell) y escribimos lo siguiente:

CREATE FUNCTION plpython_call_handler()
RETURNS OPAQUE AS '/usr/lib/postgresql/plpython.so' LANGUAGE 'C';

Dependiendo de la ruta que tengan para la librería.

Lo siguiente es “crear” el lenguaje dentro de la BD

CREATE LANGUAGE 'plpython' HANDLER plpython_call_handler LANCOMPILER 'PL/pgSQL';

Y listo! Ahora puedo crear la función para el traspaso de mes en números a palabras.

CREATE OR REPLACE FUNCTION mes_palabra(num integer) RETURNS character varying AS $$

 arraymeses = ['Ene', 'Feb', 'Mar', 'Abr', 'May', 'Jun', 'Jul', 'Ago', 'Sep', 'Oct', 'Nov', 'Dic']
 return arraymeses[num]
$$
LANGUAGE plpython VOLATILE CALLED ON NULL INPUT SECURITY INVOKER;

y para usarla (en mi caso) simplemente hago esto:

SELECT
  proyectos.proyectos_codigo_real,
  (proyectos.proyectos_codigo_comun
  || ' - ' || proyectos.proyectos_desc
  || ' - ' || mes_palabra(EXTRACT
  (MONTH from proyectos.proyectos_inicio)::integer)
  || ' '|| EXTRACT(year from proyectos.proyectos_inicio))
  AS Nombre_Completo
FROM
  public.proyectos
WHERE
  proyectos.proyectos_tipo_proyecto = 3
AND proyectos.proyectos_terminado = FALSE;

teniendo como resultado

Tabla con datos crudos y consulta

Y eso

Links que fueron útiles

• http://johansoft.blogspot.com/2007/09/solucion-error-language-plpgsql-does.html
• http://www.arpug.com.ar/trac/wiki/PlPython
• http://www.postgresql.org/docs/9.0/static/sql-createfunction.html