Nosinmiubuntu | Ubuntu en concreto, GNU/Linux en general

Cómo sincronizar Facebook Login entre Android y nuestro servidor

2013-04-17T10:02:00.002+02:00

Hace unas semanas hicimos una introducción a la nueva API de Facebook para Android. Vimos los pasos necesarios para empezar a trabajar con ella y esta semana aprovecharemos lo ya visto para realizar algún ejemplo un poco más complicado.

Lo que vamos a implementar es un login con Facebook y vamos a sincronizarlo con nuestro propio servidor, comprobando si nuestro usuario está en nuestro sistema y si no lo está lo damos de alta con los datos que nos dé Facebook. Antes de continuar, si no visteis el anterior artículo de Facebook, es necesario que lo completéis para poder añadir esta librería a vuestro proyecto. La única parte que no es necesaria es la del código de la Activity.

En una pantalla de login como la que ya hemos hecho en el artículo Creando nuestro sistema de registro y login, vamos a añadir un botón que nos permita hacer login con nuestra cuenta de Facebook. Si nuestro email no está registrado en nuestra plataforma, entonces le pediremos a Facebook que nos dé los datos necesarios para poder hacer el registro.

En el artículo Creando nuestro sistema de registro y login(III) aún no habíamos utilizado librerías para crear conexiones HTTP como la que utilizamos en Peticiones HTTP ahora más fáciles, así que os aconsejo que si vais a utilizar el código del login que enlacé antes, hagáis un ejercicio de sustitución por esta librería.

En nuestra App Android

Empezamos incluyendo en la pantalla de login el siguiente código. Simplemente es un fragment que enlaza a la clase ButtonLoginFragment. Debéis sustituir en android:name por el package donde ubiquéis esta clase.

<fragment android:name="aqui.va.el.nombre.de.vuestro.package.ButtonLoginFragment"
          android:id="@+id/LoginFragment"
          android:layout_width="match_parent"
          android:layout_height="match_parent" />

El siguiente paso es crear la clase ButtonLoginFragment que aparece en el fragment anterior. La clase ButtonLoginFragment es muy simple. Hereda de Fragment y nos devuelve la vista de el siguiente layout que explicaremos, facebook_button.xml. Además instanciamos el botón de login específico de Facebook y le indicamos que pida permiso al usuario para acceder a su email.

Si necesitáis añadir más permisos a vuestra app podéis encontrar aquí más información, https://developers.facebook.com/docs/reference/login/#permissions. Pero tened en cuenta que cuantos más permisos pidáis más reacio será el usuario a dar permisos, así que estad seguros de que necesitáis cada uno de los permisos que incluyáis.

public class ButtonLoginFragment extends Fragment {

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle       savedInstanceState) {
     View view = inflater.inflate(R.layout.facebook_button, container, false);
     LoginButton authButton = (LoginButton) view.findViewById(R.id.login_button);
     authButton.setReadPermissions(Arrays.asList("email"));
      
     return view;
   }
}

Después de esto vamos a crear el layout con el botón de login de Facebook, facebook_button.xml.

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
              android:layout_width="wrap_content"
              android:layout_height="wrap_content"
              android:orientation="vertical"
              android:gravity="center" android:layout_gravity="center">
    <com.facebook.widget.LoginButton
            android:id="@+id/login_button"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:layout_gravity="center_horizontal|center_vertical"
            android:layout_marginTop="0dp"
            android:layout_marginBottom="0dp" />

</LinearLayout>

Como veis no tiene mayor complicación. Un LinearLayout para meter dentro el widget del LoginButton que nos proporciona el SDK de Facebook. Ahora veamos como queda la activity que gestiona la pantalla de login. Veremos únicamente la parte que gestiona el login de Facebook para no complicarlo demasiado. Debéis cambiar además la herencia de vuestra Activity a FragmentActivity quedando extends FragmentActivity.

private boolean try_login_facebook = true;
private UiLifecycleHelper uiHelper;

@Override
public void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.login);
       
    uiHelper = new UiLifecycleHelper(this, callback);
    uiHelper.onCreate(savedInstanceState);

}

Empezamos definiendo un booleano y una interface que nos ayudará en el ciclo de vida del login de Facebook. Y en el onCreate a parte de llamar al layout login, inicializamos la interface.

private Session.StatusCallback callback =  new Session.StatusCallback() {
    @Override
    public void call(Session session, SessionState state, Exception exception) {
        if (state.isOpened()) {                    
        } else if (state.isClosed()) {
       
        }
   }
};
@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
     super.onActivityResult(requestCode, resultCode, data);
     uiHelper.onActivityResult(requestCode, resultCode, data);
 }

El siguiente paso es definir callback que si os fijáis se le pasó a uiHelper en el onCreate. Esto nos permitirá actuar cuando el estado de la sesión de Facebook cambie. Y además en el onActivityResult lanzamos el método del mismo nombre de uiHelper para que realice las operaciones necesarias.

La parte importante viene ahora, en el onResumeFragments. Aquí se obtiene el objeto Session de Facebook y se comprueba si no es nula y está activa. Además utilizo una bandera, try_login_facebook, porque se puede estar ejecutando múltiples veces este método y así evitamos que haga peticiones innecesarias.

El método facebookLogin simplemente va a obtener el token que nos da Facebook y lo vamos a enviar a nuestro servidor web para hacer su parte del proceso de autenticación. Fijaros que si da un fallo la conexión con el servidor ejecuto el método closeAndClearTokenInformation. Además se está utilizando la librería que ya se explicó en Peticiones HTTP ahora más fáciles para hacer la conexión.

@Override
protected void onResumeFragments() {
   super.onResumeFragments();  
 
   final Session session = Session.getActiveSession();
   if (session != null && session.isOpened()) {
       if(try_login_facebook){    
           try_login_facebook = false;
           facebookLogin(session);
       }    
   } 
}

public void facebookLogin(final Session session){
  
  
  AsyncHttpClient client = new AsyncHttpClient();
  RequestParams rp = new RequestParams();
  
  rp.put("token", session.getAccessToken());
  rp.put("tag", "login.facebook");                
  
  client.post("url de nuestro servicio web", rp, new AsyncHttpResponseHandler(){
   @Override
   public void onSuccess(String response){             
    //Aquí ha vuelto del proceso de login, hay que verificar en la respuesta si tuvo éxito o no
     
         
   }
   @Override
   public void onFailure(Throwable throwable){ 
    session.closeAndClearTokenInformation();
   }
  });
}

Si quisierais obtener información del usuario debéis hacer una petición de este estilo en el lugar donde estamos llamando al método facebookLogin. Simplemente se hace una petición a Facebook para que nos dé los datos requeridos. Acordaros que este es un proceso asíncrono y debemos tratar estos datos en el onCompleted. Algo muy parecido lo vimos cuando integramos el SDK de Facebook en Android.

Request request = Request.newMeRequest(session, new Request.GraphUserCallback() {

    @Override
    public void onCompleted(GraphUser user, Response response) {
          
        if (session == Session.getActiveSession()) {
            if (user != null) {
             //Aquí con el objeto user podemos obtener datos del usuario logado
            }
        }
        if (response.getError() != null) { session.closeAndClearTokenInformation(    ); }}});
request.executeAsync();

EN NUESTRO SERVIDOR WEB

La última parte la debemos hacer en un servidor web y como siempre la hago en PHP. Ya hemos visto otras veces como realizar estos procesos y no es muy complejo. Simplemente le hemos enviado desde la aplicación Android un tag para decirle que vamos a hacer un login con Facebook y le pasamos también el token.

public function facebookLogin($token){
    $url = "https://graph.facebook.com/me?access_token=". $token;
    $json = @file_get_contents($url);

    if($json != false){
        $e = json_decode($json, true);

        $email = $e["email"];
        $name = $e["name"];
        $username = $e["username"];
        if($this->isUserExisted($email) == false){
            $this->registerUser($username, $name, $email );
        }
        $response = array("success" => "1");
    } else {
        $response = array("success" => "0");
    }
    return json_encode($response);
}

El método que finalmente se debe llamar en nuestro servicio web será facebookLogin y simplemente va a hacer una petición a Facebook con el token para que le devuelva la info del usuario. Esto nos tiene que devolver un json si se ha encontrado al usuario. Podéis probar a llamarlo desde un navegador para que veáis que aspecto tiene y que datos trae. Después obtenemos los datos que nos ha dado Facebook, en nuestro caso necesitamos el email, nombre y nombre de usuario.

Buscamos en nuestro servidor el usuario por email con isUserExisted y si no existe lo registramos con registerUser. Podéis revisar el artículo Creando nuestro sistema de registro y login en Android (II), encontrareis el método isUserExisted y la parte que registra un usuario la podéis meter en el método registerUser para que os sea más fácil utilizar en ambos sitios.

Por último, se envía una respuesta indicando si el proceso ha tenido éxito o no. Esta la debemos evaluar en nuestra app Android. En este punto según queráis enfocar vuestra aplicación podéis navegar a otra pantalla, guardar en el terminal una determinada información o lo que vosotros necesitéis. Lo importante es que hemos conseguido hacer login en nuestro terminal con las credenciales de Facebook y además hemos sincronizado estos datos con nuestro servidor.

Google Maps V2 en Android

2013-04-04T11:38:00.000+02:00

Hace ya un tiempo que ha aparecido la nueva API para Google Maps así que ya iba siendo hora de que le echáramos un vistazo para ver que es capaz de hacer esta nueva versión.

Hay unas cuantas cosas nuevas en esta versión, lo que más llama la atención es que ahora no necesitamos utilizar un MapActivity sino que se utilizan Fragments lo que facilita la tarea de integrar un mapa (o varios) en cualquier tipo de pantalla. Además los mapas se representan mediante vectores lo que según Google va a consumir menos ancho de banda y además los mapas se cachean con lo que no tendremos tantas zonas sin cargar. Por último, esta versión incluye mapas en 3D y se podrá cambiar la perspectiva del mapa lo que les dará mucho más juego a estos.

Los mapas de Google ahora vienen integrados en la librería de Google Play Services por lo que si no la tenemos instalada debemos hacerlo ahora. Para ello en Eclipse vamos a Window -> Android SD Manager, en la sección Extras buscamos Google Play Services y si no está instalado lo marcamos para su instalación.

Una vez hecho esto vamos a crear un nuevo proyecto en Eclipse a partir de esto que hemos instalado, para ello en File -> New... -> Project -> Android Project From Existing Code pinchamos sobre Browse y desde el directorio donde tengáis el SDK de Android seguís la siguiente ruta <PATH_SDK_ANDROID>/extras/google/google_play_services/libproject/google-play-services_lib/ , aceptáis y listo. En la ruta <PATH_SDK_ANDROID>/extras/google/google_play_services/samples/ tenéis una serie de ejemplos que podéis hacerle este proceso para tener a mano y ver que se puede hacer con esta librería.

Por último, en el proyecto que vais a incluir los mapas debéis hacer referencia a este proyecto, hacéis botón derecho sobre vuestro proyecto y seleccionáis Properties ->Android y en la parte derecha abajo de todo añadís una nueva librería. Seleccionáis la de Google Play Services y listo.

Ahora toca crear una key para que se puedan ver los mapas en nuestra aplicación, para ello tenemos que ir a la consola de las Google Apis en https://code.google.com/apis/console/. Ya vimos algo sobre ella cuando hablamos de como enviar notificaciones push. Simplemente os creáis un proyecto y vamos a activar el servicio de Google Maps en la sección Services buscando Google Maps API V2 y poniendo el switch en ON.

Una vez activado debemos ir a la sección API Access a crear nuestra key. Vamos a hacer un paréntesis aquí para abrir un terminal y ejecutar lo siguiente:

keytool -list -v -keystore ~/.android/debug.keystore -alias androiddebugkey -storepass android -keypass android

Esto nos va a genera una salida con un montón de texto, nos centramos en buscar la linea que empieza por SHA1:, y copiamos el código que hay a continuación. La anterior instrucción es para cuando utilizamos el certificado de debug, para cuando estamos realizando pruebas en el emulador o en nuestro dispositivo de desarrollo. Para obtener el código para el certificado con el que firmáis las aplicaciones para producción debéis ejecutar lo siguiente (he marcado en rojo donde debéis incluir vuestros datos):

keytool -list -v -keystore /path/a/vuestra/keystore/my_keystore.keystore -alias nombre_de_vuestro_alias_name

Una vez que ya tenemos el código SHA1 de nuestro almacén de claves volvemos a la consola de Google Apis donde lo dejamos. Pulsamos el botón Create new Android key... y pegamos el código SHA1. Además debemos escribir un punto y coma seguido del package de nuestra aplicación, si tenéis por ejemplo com.trespies.mapdemo quedaría algo así:

45:B5:E4:6F:36:AD:0A:98:94:B4:02:66:2B:12:17:F2:56:26:A0:E0;com.trespies.mapdemo

Esto nos va a dar nuestra api key que debemos utilizar en nuestra aplicación. Y una vez listo esto podemos ir por fin a Eclipse para crear el primer ejemplo. Empezaremos por el archivo AndroidManifest.xml.

Empezamos por meter la siguiente meta-data dentro de la etiqueta <application>:

<meta-data
      android:name="com.google.android.maps.v2.API_KEY"
      android:value="AQUI_VUESTA_API_KEY_DE_GOOGLE"/>

Lo siguiente es incluir los siguientes permisos, dentro de la etiqueta <manifest>, sustituyendo el package que está en rojo por el vuestro:

<permission
        android:name="com.trespies.mapdemo.permission.MAPS_RECEIVE"
        android:protectionLevel="signature"/>
<uses-permission android:name="com.trespies.mapdemo.permission.MAPS_RECEIVE"/>

La versión 2 de la API de Google Maps requiere Open GL ES versión 2 por lo que debemos añadir la siguiente etiqueta:

<uses-feature
        android:glEsVersion="0x00020000"
        android:required="true"/>

Y por último añadimos los siguientes permisos:

<uses-permission android:name="android.permission.INTERNET"/>
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE"/>
<uses-permission android:name="com.google.android.providers.gsf.permission.READ_GSERVICES"/>

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

Los dos últimos no son estrictamente necesarios pero son recomendables instalarlos. Nos queda por último el layout y la activity. Vamos primero con el layout, yo le llamo map_view_v2.xml:

<?xml version="1.0" encoding="utf-8"?>
<fragment xmlns:android="http://schemas.android.com/apk/res/android"
  android:id="@+id/map"
  android:layout_width="match_parent"
  android:layout_height="match_parent"
  class="com.google.android.gms.maps.SupportMapFragment"/>

Este layout es muy sencillo, como único objeto tenemos un fragment que llama a una clase de nuestra librería Google Play Services y que se encargará de presentarnos el mapa. Veamos la activity:

public class MapInfo extends FragmentActivity {

    private GoogleMap mMap; 

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
           
        setContentView(R.layout.map_view_v2);
        setUpMapIfNeeded();
    }
  
    @Override
    protected void onResume() {
        super.onResume();
        setUpMapIfNeeded();
    }
    private void setUpMapIfNeeded() {
        if (mMap == null) {            
            mMap = ((SupportMapFragment) getSupportFragmentManager().findFragmentById(R.id.map)).getMap();
            
            if (mMap != null) {
                setUpMap();
            }
        }
    }
    
private void setUpMap() {
  mMap.addMarker(new MarkerOptions().position(new LatLng(0, 0)).title("Marker"));
    }
}

Nuestra Activity no es una Activity sino un FragmentActivity, debéis importar la librería para el FragmentActivity de la android.support.v4. En el onCreate se llama a nuestro layout y al método que inicializa el mapa, setUpMapIfNeeded.

En este método se intenta obtener el mapa del fragment donde lo tenemos en la variable mMap de tipo GoogleMap, si no es nulo se va añadir un marcador con el método setUpMap.

Como veis es muy sencillo. Una vez que tenemos los pasos previos, añadir mapas es un juego de niños. Como os comenté antes hay bastantes ejemplos en la carpeta samples, así que si queréis, podéis ir viendo más ejemplos por vuestra cuenta.

Integrar SDK Facebook en Android

2013-03-28T11:34:00.003+01:00

Muchas de las aplicaciones que manejamos en nuestro día a día utilizan una o varias redes sociales como complemento para que nos podamos identificar en ellas, compartir información u otros fines. Estas redes sociales hacen las tareas del programador más fáciles con sus SDK. En el caso que hoy tratamos, Facebook, su SDK ya está por la tercera versión y en esta al igual que su app ya realiza su operaciones de forma nativa.

Lo primero que debemos hacer es descargar el SDK para Android de Facebook, lo podemos encontrar en la web de desarrolladores https://developers.facebook.com/android/ Descargamos el zip y lo descomprimimos. Como siempre, yo suelo recomendar hacerlo en una carpeta donde tengamos el resto de librerías para llevar siempre el control de las librerías que tenemos.

El siguiente paso es crear un proyecto con Eclipse, para ello vamos a File -> New -> Project... -> Android Project From Existing Code. Ahora seleccionamos la carpeta donde está el proyecto, en nuestro caso donde descomprimimos el anterior zip, seleccionamos la carpeta "facebook" y aceptamos. Como veis detectará el proyecto del SDK de Facebook. Finalizamos y ahora tenemos listo un proyecto que habrá que implementar en la aplicación que queremos que tenga características de Facebook.

Por un momento nos olvidamos de Eclipse y nos vamos a la web de Facebook, https://developers.facebook.com/apps, aquí necesitamos crear una app para poder realizar todas las operaciones de logueo y demás. Para ello pulsamos sobre el botón de Crear una nueva aplicación, le damos un nombre y un namespace. Podéis asignarle un icono y más características, pero ahora no viene al caso y lo dejo para que lo investiguéis vosotros una vez acabemos el tutorial.

Lo importante ahora es en la página de nuestra app Facebook está en la sección Native Android App, activamos esta sección y otra vez tenemos campos para cubrir. Aquí el campo más importante es el de Key Hashes. Este sirve para identificar vuestra app con Facebook mediante la keystore con la que se firma la app. En el campo clase fijaros como lo he cubierto en la imagen de abajo, el namespace de mi aplicación más el nombre de la activity donde ejecutaremos al final nuestro ejemplo.

Vamos a ver como generar este código. Para ello abrimos un terminal y escribimos:

keytool -exportcert -alias androiddebugkey -keystore ~/.android/debug.keystore | openssl sha1 -binary | openssl base64

Nos pide una contraseña, es android, y nos devuelve una clave que introducimos en el formulario de Facebook. En este caso estamos utilizando el keystore de pruebas con las que se firman las apps mientras se va ejecutando en el emulador o en nuestro móvil de desarrollo. Para crear también la key hash de la keystore que utilizamos en producción, simplemente sustituimos "~/.android/debug.keystore" por la ruta de la keystore de producción. Y la clave será la que tengais vosotros para esa keystore. Por último, añadimos esa nueva key en el formulario de Facebook. Yo siempre tengo el de desarrollo y el de producción.

Y por fin pasamos a nuestra app en Eclipse. Lo primero es crear un nuevo proyecto para Android. Yo le he llamado com.trespies.demo y el sdk mínimo de Android indico que es el 2.2(Froyo) y su sdk target 4.2(Jelly Bean). El resto lo dejo todo por defecto.

Sobre nuestro proyecto hacemos botón derecho, vamos a Properties -> Android, y en la parte derecha vamos a la parte de abajo de todo y añadimos una librería, en este caso debe aparecer el FacebookSDK. Aceptamos y aplicamos.

En este punto, me ha dado un error porque ahora en mi proyecto hay dos versiones diferentes de la librería android-support-v4. Para solucionarlo simplemente quitamos la librería o bien de este proyecto o bien del proyecto del FacebookSDK y copiamos el del proyecto que no eliminamos. Yo prefiero eliminar la del proyecto de Facebook, así cada vez que creéis un nuevo proyecto no tenéis que repetir esta operación.

Ahora debéis volver a la app de Facebook y copiar el app ID de la misma. De vuelta al proyecto, abrimos en la carpeta values -> res -> strings.xml. Aquí creamos una nueva entrada, le llamamos facebook_app_id y su value es el app ID que hemos copiado.

Para poder conectarse a Facebook debemos dar permisos de internet a nuestra app en el archivo AndroidManifest.xml:

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

Dentro del mismo archivo, dentro de la etiqueta application, añadimos el siguiente meta-data:

<meta-data android:value="@string/facebook_app_id" android:name="com.facebook.sdk.ApplicationId"/>

Con esto le decimos al sdk de Facebook cual es el app ID asociado con nuestra aplicación.

Por último, añadimos una activity así:

<activity android:name="com.facebook.LoginActivity" />

Vamos ahora con la parte final. Nos vamos al layout de la activity principal de nuestra aplicación y añadimos un TextView, yo le llamaré lblWellcome. Y por fin abrimos la activity e incluimos el siguiente código:

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);


// start Facebook Login
    Session.openActiveSession(this, true, new Session.StatusCallback() {

      // callback when session changes state
      @Override
      public void call(Session session, SessionState state, Exception exception) {
        if (session.isOpened()) {

          // make request to the /me API
          Request.executeMeRequestAsync(session, new Request.GraphUserCallback() {

            // callback after Graph API response with user object
            @Override
            public void onCompleted(GraphUser user, Response response) {
              if (user != null) {
                TextView welcome = (TextView) findViewById(R.id.lblWellcome);
                welcome.setText("Hello " + user.getName() + "!");
              }
           &nbsp

            }


          });
        }
      }
    });
}


@Override
public void onActivityResult(int requestCode, int resultCode, Intent data) {
  super.onActivityResult(requestCode, resultCode, data);
  Session.getActiveSession().onActivityResult(this, requestCode, resultCode, data);
}

¿Que es lo que hace esto exactamente? En el método onActivityResult se utiliza el objeto Session de Facebook para realizar parte de los procesos de autenticación y autorización necesarios para el correcto funcionamiento de nuestra app.

De momento nos centraremos en el onCreate que es lo que nosotros debemos saber controlar. En el ejemplo aparecen algunos comentarios ya que este ejemplo está recogido directamente de la web de desarrolladores de Facebook.

Primero con el objeto Session se abre una sesión activa y si no lo estuviera se pedirían las credenciales. Todo esto lo hace el SDK de Facebook sin que nosotros tengamos que hacer nada a mayores. Una vez que el usuario se ha autenticado y nos ha dado permiso para acceder desde nuestra app, se hace una petición a Facebook para que nos dé información sobre el usuario actual.

Para ello en el método call de StatusCallBack verificamos si la sesión está abierta y disponible. Para después realizar una petición asíncrona que nos devolverá los datos del usuario los cuales vamos a tener almacenados en el objeto GraphUser y por último volcamos en nuestro TextView. No os preocupéis si tarda un rato en poner el nombre de vuestro usuario, a mi me tardo algo más de un minuto pero acabo poniéndolo.

El ejemplo en cuestión es la forma más simple de hacer un login con Facebook, pero existen muchas otras cosas que se pueden hacer. Por el momento tenemos la base para poder empezar a crear aplicaciones que utilicen una de las redes sociales más conocidas en internet.

Cómo añadir publicidad en Android

2013-03-13T09:05:00.000+01:00

Una vez que hemos lanzado al mercado nuestra aplicación nos quedan un par de pasos muy importantes, promocionar la aplicación para conseguir el mayor número de descargas posibles y monetizarla. Para este punto se pueden utilizar varias técnicas, pero si no estamos seguros de que se vayan a comercializar por si sola podemos hacer que sea gratuita e incluir publicidad.

Para incluir publicidad en nuestra aplicación Google nos ayuda con la librería de Admob con la cual empezar a ganar un dinero extra será coser y cantar.

Lo primero que debemos hacer es registrarnos en Admob a través de la siguiente url: http://www.google.com/ads/admob/ Una vez registrados, accedemos a la web de Admob, primero en la pestaña Cuenta seleccionamos Detalles de pago y cubrimos el formulario con nuestros datos para poder recibir el dinero.

Ahora vamos a Sitios y aplicaciones y pulsamos sobre el botón agregar sitio/aplicación y en nuestro caso seleccionamos Android. Ahora en Sitios y aplicaciones aparecerán las aplicaciones que tenemos configuradas. Pinchando con el ratón sobre la que acabamos de crear en gestionar configuración nos dirá el ID de editor que necesitamos para incluir en nuestra aplicación Android.

El siguiente paso será descargar la librería para Android desde aquí https://developers.google.com/mobile-ads-sdk/download En nuestro caso seleccionamos la descarga para Android, pero podéis incluir esta publicidad en vuestras aplicaciones para iOS o Windows Phone.

Después de descargar el zip de la versión Android lo descomprimimos y dentro de él encontraremos un archivo .jar, en mi caso GoogleAdMobAdsSdk-6.3.1.jar. Lo copiamos en la carpeta libs de nuestro proyecto. Actualizamos nuestro proyecto, y dentro de la carpeta libs aparecerá nuestra librería. Ahora hacemos click derecho sobre ella y seleccionamos Build Path -> add to Build Path.

Vamos ahora a nuestro archivo AndroidManifest.xml y declaramos una Activity de este modo:

<activity android:name="com.google.ads.AdActivity"             
android:configChanges="keyboard|keyboardHidden|orientation|screenLayout|uiMode|screenSize|smallestScreenSize" />

También añadimos permisos de internet y de acceso al estado de la red así:

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

Lo siguiente que tenemos que hacer es abrir una de nuestras Activities donde queremos incluir la publicidad, y añadimos el siguiente código:

private AdView adView;
private LinearLayout lytMain;


@Override
public void onCreate(Bundle savedInstanceState) {
      super.onCreate(savedInstanceState);
      setContentView(R.layout.mylayout);

      lytMain = (LinearLayout) findViewById(R.id.lytMain);
      adView = new AdView(this, AdSize.BANNER, MI_ID_ADMOB);
      lytMain.addView(adView);
      adView.bringToFront();
      adView.loadAd(new AdRequest());
}

@Override
public void onDestroy(){
      if(adView != null)
         adView.destroy();
      super.onDestroy();
}

Nuestro layout va a ser muy simple, veamos como queda.

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:id="@+id/lytMain"
    xmlns:tools="http://schemas.android.com/tools"  android:layout_width="fill_parent" android:layout_height="fill_parent">
  
</LinearLayout>

Como veis no tiene absolutamente nada. Simplemente se instancia nuestro contenedor principal, en este caso un LinearLayout. Luego el objeto AdView al que se le pasa nuestro ID en el constructor, importante si queremos ser los beneficiarios de los ingresos por la publicidad y se añade al LinearLayout. En el onDestroy de la Activity liberamos recursos destruyendo la vista con la publicidad.

En mi caso la publicidad no apareció hasta pasados unos minutos, así que debeis tener paciencia.

Otra forma de hacerlo es incluir en nuestro layout el control AdView de esta forma:

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android" android:id="@+id/lytMain"
    xmlns:tools="http://schemas.android.com/tools"
    xmlns:ads="http://schemas.android.com/apk/lib/com.google.ads" android:layout_width="fill_parent" android:layout_height="fill_parent">
    <com.google.ads.AdView android:id="@+id/adView"
                         android:layout_width="wrap_content"
                         android:layout_height="wrap_content"
                         ads:adUnitId="MI_ID_ADMOB"
                         ads:adSize="BANNER"
                         ads:loadAdOnCreate="true"/>  
</LinearLayout>

Fijaros como en el LinearLayout se ha declarado la librería de admob para que reconozca el widget AdView. En el onCreate el código se simplifica de esta forma:

@Override
public void onCreate(Bundle savedInstanceState) {
     super.onCreate(savedInstanceState);
     setContentView(R.layout.list);

     adView = ( AdView) findViewById(R.id.adView);
     adView.loadAd(new AdRequest());
}

Como veis es muy simple incluir publicidad en una aplicación. Lo difícil comienza ahora conseguir que la aplicación sea conocida y obtener ingresos a través de la publicidad con ella. Una buena estrategia adoptada por muchos desarrolladores es crear dos versiones de la misma aplicación, una gratuita con publicidad y otra de pago en la que se elimina la publicidad.

Android SQLite: insertar y actualizar sin consultas

2013-02-28T08:47:00.000+01:00

Muchas veces cuando estamos insertando datos en nuestra base de datos lo hacemos de forma masiva y no nos preocupa obtener el identificador de cada fila. Pero otras veces es necesario acceder, por ejemplo porque estamos registrando un determinado item y necesitamos su id para asociarlo a otro. Hacer esto se puede hacer de una forma muy sencilla, veámoslo.

Antes de nada vamos a hacer memoria y recordaremos la clase que creamos para manejar la base de datos en este artículo http://www.nosinmiubuntu.com/2011/11/como-guardar-datos-en-android-bases-de.html. Aquí teníamos un método llamado insertarUsuario que hoy haremos de una forma un poco diferente.

Empezamos cambiando un poco la consulta para crear la tabla de los usuarios. la diferencia con la anterior es que ahora id_usuario es de tipo INTEGER no INT, es PRIMARY KEY, es decir es clave primaria y por lo tanto debe ser un dato único, y por último es AUTOINCREMENT, con esto no hará falta que al insertar indiquemos el id_usuario, se irá generando uno automáticamente, primero insertará 1, luego 2, y así sucesivamente.


private String SQLCreateUsuarios = "CREATE TABLE " + TableUsuarios +  " (id_usuario INTEGER PRIMARY KEY AUTOINCREMENT, nombre VARCHAR(1000), email VARCHAR(1000) ) ";

Ahora que ya tenemos modificada nuestra tabla vamos a ver el nuevo método insertarUsuario.

public int insertarUsuario(String nombre, String email){
 int idUsuario = 0;
 SQLiteDatabase db = getWritableDatabase();
 if(db!=null){
  ContentValues values = new ContentValues();
  values.put("nombre", nombre);
  values.put("email", email);
  idUsuario = (int) db.insert(TableUsuarios, null, values);  
 }
db.close();   
return idUsuario;
}

Como veis dejamos de crear nosotros la consulta con el insert y simplemente en un objeto ContentValues añadimos los parámetros que queremos insertar para luego llamar al método insert de db diciéndole en que tabla insertamos y los values que insertamos, el método se encarga de obtener y devolver el identificador de usuario obtenido. Este está devolviendo un long, pero nosotros le hacemos un cast a int.

Para completar el artículo vamos a ver como actualizar este usuario. Vamos a seguir con nuestro objeto ContentValues, pero ahora utilizamos el método update. A este debemos pasarle el nombre de la tabla y los values como en el anterior método. Además le pasamos la clausula where en nuestro caso los que tengan un determinado id_usuario, y con el siguiente parámetro que es un array de String le decimos que id_usuario debe poner donde esta el interrogante (?).

public int actualizarUsuario(int idUsuario, String nombre, String email){
 int filasAfectadas = 0;
 SQLiteDatabase db = getWritableDatabase();
 if(db!=null){
  ContentValues values = new ContentValues();
  values.put("nombre", nombre);
  values.put("email", email);
  filasAfectadas = (int) db.update(TableUsuarios, values, "id_usuario = ?", new String[]{String.valueOf(idUsuario)});  
 }
db.close();   
return filasAfectadas;
}

Al final obtendremos el número de filas afectadas por la actualización.

Corre Linux Corre: tu guía para empezar con Ubuntu

2013-02-25T12:24:00.000+01:00

Como todos sabéis, existe una gran Comunidad detrás del mundo GNU/Linux, en el que los usuarios comparten sus conocimientos y trabajo, para que cualquiera pueda beneficiarse de ello. Como nos gusta dar a conocer toda la información que puede ayudar a los usuarios, en la entrada de hoy vamos a hablar del libro "Corre Linux Corre".

Este libro ha sido creado por Fernando Monroy, quien contactó con nosotros para avisarnos de su liberación oficial, algo que agradecemos de antemano.

Esta obra acerca Ubuntu a todos aquellos que se inician en el mundo de Gnu/Linux, y que eligen la distribución de Canonical como punto de partida. En él encontraremos instrucciones para realizar tareas típicas del día a día, como son configurar el sistema, administrar archivos o instalar programas entre otras.

En esta publicación no se explica el proceso de instalación, sino que comienza directamente a explicar el funcionamiento del Sistema Operativo, por lo que se entiende que el usuario ya ha conseguido instalar Ubuntu en su equipo.

El contenido que los lectores encontrarán tras descargar el documento es:

Capítulo 1: Bienvenido a GNU/Linux
Capítulo 2: Gestión de archivos
Capítulo 3: Configuración del sistema
Capítulo 4: Internet, Redes Sociales y más
Capítulo 5: Instalación de dispositivos comunes
Capítulo 6: ¿Cómo lo hago en GNU/Linux?

En realidad, aunque el autor no explica cosas como qué es GNU/Linux, su estructura del sistema de archivos o los comandos básicos, que entendemos que todo usuario que se inicie en este mundo debería saber (aunque se pueden adquirir por otras vías), es una buena opción para que los que empiezan, puedan a dar sus primeros pasos, por lo que recomendamos su lectura como guía.

Descarga "Linux Corre Linux"

Saludos.

Ubuntu Phone y Tablet ya disponibles

2013-02-21T20:46:00.000+01:00

Por fin está entre el nosotros la versión de Ubuntu para dispositivos móviles. Ya llevábamos tiempo esperando desde que Ubuntu había dado los primeros signos de vida por el campo de los dispositivos móviles para disfrutar del sistema en cualquier lugar.

Por ahora solo los que tengan un modelo de la gama Nexus podrán disfrutar del sistema operativo, pero estamos seguros que no se tardará mucho en adaptar y tenerlo listo para otros muchos dispositivos. Los que os atreváis a instalarlo lo podéis hacer desde este dirección https://wiki.ubuntu.com/Touch/Install

Canonical nos detalla aquí unas sencillas instrucciones con las que podremos poner en marcha Ubuntu en nuestro móvil/tablet y por supuesto las instrucciones para poder revertir la instalación en caso de no querer continuar utilizando este sistema operativo.

Los afortunados que lo instaléis podéis enviarnos vuestras primeras impresiones a través de los comentarios de la web.

Ubuntu se lanza a la conquista de las tablets

2013-02-19T19:58:00.000+01:00

Seguramente el stand de Canonical en el MWC de Barcelona será bastante visitado, sobre todo después de ponernos los dientes largos con el reciente anuncio del lanzamiento de Ubuntu Phone en los dispositivos Nexus, y ahora con el recién presentado Ubuntu for Tablet.

Parece que el ordenador de sobremesa está empezando a ser un elemento prescindible gracias a la llegada a nuestras vidas de los smartphones y las tablets. Estas últimas con un amplio abanico de configuraciones en cuanto a tamaño de pantalla, rendimiento, etc...

Canonical ha visto el mercado que se le estaba escapando de las manos, y ha decidido ponerse manos a la obra para presentar hoy su sistema operativo adaptado para tablet. La idea que pretenden dar viendo el video presentación, es que sea lo más sencillo posible realizar cualquier tarea y sobre todo envolvente, desde cualquier aplicación poder realizar multitud de tareas.

Me llama la atención, cómo han integrado las videoconferencias para que sea muy sencillo mantener una conversación mientras se está editando uno de nuestros documentos o realizamos cualquier otra acción.

Otro de los puntos a tener en cuenta es la gestión de cuentas, quizá es lo que más echo en falta en las tablets en general hasta día de hoy.

El uso de cada una de las esquinas de nuestro dispositivo va a seguir la misma forma de comportarse que en la versión para teléfonos. Cada una de estas servirá para una función determinada, por ejemplo, tirando de la esquina izquierda podremos ver nuestras aplicaciones preferidas, o tirando de la superior podremos acceder a las notificaciones.

Veremos como evoluciona la adaptación de Ubuntu a los dispositivos móviles y que nuevas sorpresas nos esperan a la vuelta de la esquina en el MWC de Barcelona.

Ubuntu Phone muy pronto para descarga en Nexus 4

2013-02-18T07:47:00.003+01:00

Hace poco Canonical mostraba al mundo por fin su tan esperado sistema operativo para dispositivos móviles Ubuntu Phone. Para los que vamos a trastear con este sistema operativo deciros que estará disponible dentro de muy poco, exactamente el día 21 de febrero.

La mala noticia de momento es que solamente los afortunados poseedores de un Nexus 4 y los de un Galaxy Nexus tendrán disponibles las roms para su instalación en sus dispositivos. Esta será una preview del sistema final quedando también a la espera de tener confirmados los dispositivos móviles de Canonical.

Junto con las roms se podrán descargar también las herramientas necesarias para hacer lo más sencilla posible la instalación en nuestros dispositivos Nexus.

Unos días después, del 25 al 28 de febrero, Canonical estará presente en el MWC que se celebrará en Barcelona. Allí atenderá dudas y atenderá a aquellos que lo deseen ayudandoles a instalar Ubuntu for Phone en sus dispositivos. Los que tengáis la suerte de acercaros por allí los podréis encontrar en la cabina número 81D30, App Planet Hall 8.1

Para los que somos desarrolladores Ubuntu la idea es que las aplicaciones que se desarrollen para la plataforma móvil sean compatibles con el sistema operativo de escritorio ahorrando así al desarrollador muchísimo tiempo. Los que queráis desarrollar podéis hacerlo utilizando HTML5 lo cual es una ventaja ya que podéis aprovechar estos desarrollos para otras plataformas.

También podéis hacerlo mediante el SDK que pone a nuestra disposición Canonical en http://developer.ubuntu.com/get-started/gomobile/. Utiliza Qt + QML y en esta misma página encontrareis más información sobre como instalar las herramientas necesarias y dar los primeros pasos.

Para los que ya vais a poneros manos a la obra no dejéis de echar un vistazo a las líneas de diseño que nos proponen en http://design.ubuntu.com/apps

Scroll tipo Twitter en un ListView

2013-01-31T07:29:00.000+01:00

Hace poco me he visto en el caso de un ListView con una gran cantidad de datos, muchos de ellos antiguos y que puede que el usuario no vea por no hacer scroll pero si que va a tener que sufrir el tiempo de espera para descargar todos esos datos. Para solucionarlo vamos a ver como hacer un listview que cargue items a medida que hacemos scroll.

La idea la he cogido de este blog http://benjii.me/2010/08/endless-scrolling-listview-in-android/ y la he modificado un poco para que sea más fácil de utilizar en todas partes. Al final debe hacer como la app de Twitter si hacemos scroll en nuestra lista debe cargar más elementos al llegar al final de ella.

Simplemente debemos crear una clase que implemente OnScrollListener. Este sobreescribirá el método onScroll, donde se va a comprobar con los items que se están mostrando actualmente si estamos llegando al final de la lista. En caso afirmativo se lanzará un listener que hemos creado.

El listener que se lanza lo creamos en la propia clase y nos servirá para avisar a quien corresponda cada vez que se tenga que leer una página más. Además nos devolverá la página que debemos cargar.

public class EndlessScrollListener implements OnScrollListener{
    private int visibleThreshold = 5;
    private int currentPage = 0;
    private int previousTotal = 0;
    private boolean loading = true;
    private onScrollEndListener onScrollEnd;
    
    public interface onScrollEndListener {void onEnd(int page);}
    
    public EndlessScrollListener(onScrollEndListener onScrollEnd) {
     super();
     this.onScrollEnd = onScrollEnd;
    }
    public EndlessScrollListener(int visibleThreshold, onScrollEndListener onScrollEnd) {
     super();
        this.visibleThreshold = visibleThreshold;
        this.onScrollEnd = onScrollEnd;
    }

    
 @Override
    public void onScroll(AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) {
        if (loading) {
            if (totalItemCount > previousTotal) {
                loading = false;
                previousTotal = totalItemCount;
                currentPage++;
            }
        }
        if (!loading && (totalItemCount - visibleItemCount) <= (firstVisibleItem + visibleThreshold)) {
            loading = true;    
            if(totalItemCount > visibleThreshold)
             onScrollEnd.onEnd(currentPage);
        }
    }

    @Override
    public void onScrollStateChanged(AbsListView view, int scrollState) {     
    }
    
  
}

Ahora utilizarlo en cualquiera de nuestros ListView o cualquier otro elemento que se pueda implementar el onScrollListener es un juego de niños. Simplemente debemos hacer algo así:

ListView List = (ListView) findViewById(R.id.list);
List.setOnScrollListener(new EndlessScrollListener(new onScrollEndListener() {  @Override
 public void onEnd(int page) {    
  //Hacemos una llamada a nuestro servicio web para traer más datos 
 }
}));

Ya hemos visto otras veces como traer datos de un servidor, y también como enlazar datos a un Listview, así que solo es cuestión de que juntéis todas las piezas para tener esta funcionalidad en vuestras listas.

Rellenar un ListView con SQLite

2013-01-23T19:43:00.000+01:00

Ya son varias la veces que me pedis que os explique como rellenar un ListView, un Spinner o otra estructura desde una base de datos así que hoy voy a explicar como hacerlo.

Vamos a aprovechar el artículo que ya escribí hace tiempo de como acceder a base de datos para hacer el artículo lo más liviano posible, para ello leeros antes el artículo sobre como tratar datos en bases de datos. Una vez creada vuestra clase para tratar datos echarle un vistazo a este artículo para ver como leer los datos de la base de datos.

Nuestros datos los debemos traer en un objeto Cursor. Hacemos una consulta como la siguiente. Esto lo podéis ver en los artículos que os indique antes. Fijaros que para el identificador le creamos un alias con un guión delante, esto es importante porque si no le damos este nombre el SimpleCursorAdapter no sabrá cual es el id.

public Cursor leerLibros(){
 SQLiteDatabase db = getReadableDatabase();
  
 return db.rawQuery("SELECT id AS _id, libro AS name FROM libros;", null);  
}

Ahora vamos a crear un layout llamado row.xml que será donde mostraremos el texto. En Android existen layouts ya preparadas para esto, pero esta vez utilizaré esta plantilla por si quereis cambiar su aspecto que os sea sencillo.

<?xml version="1.0" encoding="utf-8"?>
<TextView xmlns:android="http://schemas.android.com/apk/res/android"
android:id="@+id/text"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:padding="10dip"/>

Ahora en nuestra Activity vamos a rellenar un ListView. En nuestra Activity simplemente tendremos un ListView llamado listview. Y en el onCreate ejecutamos lo siguiente:

ListView listView = (ListView) findViewById(R.id.listView);

bbdd bbdd = new bbdd(this);

Cursor cursor = bbdd.leerLibros();
startManagingCursor(cursor);

String[] from = new String[]{"name"};
int[] to = new int[]{R.id.text};

SimpleCursorAdapter cursorAdapter = new SimpleCursorAdapter(this, R.layout.row, cursor, from, to);

listView.setAdapter(cursorAdapter);

Con esto último ya está listo nuestro código. Instanciamos nuestro ListView, también nuestra clase de base de datos y llamamos al método leerLibros.

Por otro lado preparamos un array, from, con los nombres de las columnas en este caso solo será name. También otro, to, con los ids de los elementos donde se ubicarán los datos de nuestra base de datos. De este modo le decimos que los datos de la columna name se ubican en el TextView con el id text.

Por último enlazamos el SimpleCursorAdapter al ListView con el método setAdapter.

Enviar y recibir acciones con BroadcastReceiver en Android

2013-01-16T07:58:00.000+01:00

Hace unas semanas hablábamos sobre las notificaciones tipo push con la nueva versión del servicio de Google. Vimos como activar el servicio en Google, la parte servidor para enviar los mensajes a los usuarios y como recibirlos y notificarlos en el dispositivo. ¿Pero que pasa una vez recibidos? ¿Como transmitimos ese evento al resto de nuestra app?

La respuesta es muy sencilla con los broadcastreceiver. Estos no son más que capturadores de acciones. Existen ya algunos definidos en el sistema como pueden ser una llamada entrante o un mensaje de texto. En nuestra aplicación podríamos capturar esas acciones y tratarlas de la forma que a nosotros mejor nos conviniera.

Voy a explicarlo basándome en el artículo de las notificaciones push. Después de recibir y notificar un mensaje push, no hicimos nada más. Simplemente le mostramos al usuario el aviso pero en la aplicación no hacemos nada más. ¿Que pasaría si el usuario está mirando una lista con todas las notificaciones que ya teníamos y en ese momento llega un nuevo aviso?

Para estos casos tenemos los bradcastreceiver, este estará escuchando hasta que llegue una determinada acción y cuando eso ocurra le dirá a la lista o a quien sea, que ha llegado un nuevo aviso y debe actualizarse.

Enviar la acción que luego recogeremos es muy sencillo. Simplemente debemos ejecutar lo siguiente:

private void sendBroadCast(Context context) {   
        Intent broadcastIntent = new Intent();
        broadcastIntent.setAction("NOMBRE_DE_NUESTRA_ACTION");         
        broadcastIntent.putExtra("parameter", "value");         
        context.sendBroadcast(broadcastIntent);         
}

Este método tan sencillo lo podéis llamar desde el método notificarMensaje del artículo dedicado al envío de notificaciones push. Simplemente creamos un Intent, seteamos el nombre de su action, si queréis podéis incluir algún parámetro con putExtra y por último lo enviamos con el método sendBroadcast de Context.

Y ahora vamos a definir el broadcastreceiver que será el encargado de estar escuchando cuando esta acción se envíe y ejecutar lo que le digamos. Para ello vais a una de las Activitys de vuestra aplicación, donde tengáis una lista con las notificaciones o el número de ellas y definimos el broadcastreceiver así:

private IntentFilter myFilter;
 
private BroadcastReceiver myReceiver = new BroadcastReceiver() {   
        @Override
        public void onReceive(Context context, Intent intent) {         
           String myParam = intent.getExtras().getString("parameter"); 
            if (myParam != null) {                
                //Aquí ejecutais el método que necesiteis, por ejemplo actualizar //el número de notificaciones recibidas

            }
        }
    };

El BroadcasReceiver estará a la espera de nuestra action y de ejecutar lo que le digamos. Si queréis, también podéis capturar los parámetros enviados y utilizarlos como vosotros necesitéis.

@Override
protected void onPause() {         
        unregisterReceiver(myReceiver);
        super.onPause();
}
     

@Override
protected void onResume() {
        super.onResume();
        registerReceiver(myReceiver, myFilter);
}

En el onResume debemos registrar nuestro receiver para que realmente esté a la espera del action y en el onPause debemos eliminar este registro.

@Override
public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);  
 
        myFilter = new IntentFilter();
        myFilter.addAction("NOMBRE_DE_NUESTRA_ACTION");
}

Por último, al crearse nuestra Activity también instanciamos un IntentFilter que le dirá a nuestro broadcastreceiver cual es el nombre de la acción que debemos recoger, fijaros como se pasó como parámetro en el onResume al método registerReceiver.

Y con este poquito código ya hemos creado nuestro broadcastreceiver. Si habéis implementado un método para contar las notificaciones y enviáis notificaciones push a vuestra app, empezará a actualizarse el número de ellas. Como veis es una forma muy rápida y sencilla de tener actualizada todas las partes de vuestra aplicación.

Cómo firmar y generar aplicaciones Android

2013-01-09T19:11:00.000+01:00

Uno de los procesos que debemos llevar a cabo cuando ya tenemos nuestra aplicación finalizada y la queremos subir a la tienda Play de Google es firmarla con un certificado y generar un archivo ejecutable que tiene una extensión apk. Vamos a ver como hacer este proceso.

Para crear un certificado debemos utilizar keytool que se encuentra en /usr/bin

Abrimos un terminal y ejecutamos:

$ keytool -genkey -v -keystore nombredenuestrakeystore.keystore
-alias aliasdenuestrakeystore -keyalg RSA -keysize 2048 -validity 10000

Si quereis que la keystore se guarde en una carpeta en concreto podéis indicar la ruta junto con el nombre. Al ejecutar esto nos pedirá una contraseña tanto para nuestra key como para el alias de la misma. Y ya tenemos creada nuestra keystore.

Si vais a firmar aplicaciones para luego distribuirlas no perdáis esta keystore, haced algún duplicado y subidla a algún servicio tipo dropbox. Si ya habéis subido apps firmadas con esta key y la perdéis no podréis subir actualizaciones ya que Google entenderá que no es la misma app.

Ahora ya podemos utilizar nuestra keystore en cualquier app. Vamos a ver como se hace. En Eclipse nos ponemos en el explorador de proyectos sobre cualquier proyecto y hacemos botón derecho sobre uno. Seleccionamos Android tools > Export Signed Application Package, aparecerá una pantalla como la siguiente:

Si hemos seleccionado bien el proyecto no debemos hacer nada. Simplemente clickamos en siguiente.

Ahora debemos seleccionar la keystore que hicimos antes e indicar su password. Como os dije antes es muy importante que no perdáis ni la keystore ni sus passwords. Asi que haced una copia o las que queráis para que no tengáis problemas en el futuro cuando queráis firmar actualizaciones de vuestras apps.

Después de la password de la keystore el wizard pide la clave del alias, rellenais el dato y seguimos adelante.

Por último, nos piden una ubicación para guardar nuestra app firmada, seleccionáis una y listo. Aquí os recomiendo que vayáis organizando las diferentes versiones con un criterio con el cual os sea fácil encontrar cada una de ellas posteriormente.

El proceso ha generado un archivo .apk que es lo que debéis subir a Play de Google.

Además cada vez que subáis una nueva actualización de una aplicación además de realizar el proceso anterior también debéis modificar en el archivo androidManifest.xml el número de versión en versionCode, aquí debéis poner un valor numérico, si no lo cambiáis al subir un nuevo archivo apk os avisará Google que el número de versión no es correcto. Además podéis ponerle un nombre a cada versión con versionName, aquí el texto no tiene porque ser numérico y podéis poner lo que queráis, es meramente informativo.

<manifest 
    android:versionCode="1"
    android:versionName="1.0" >

Sliding Menu en Android

2012-12-26T20:16:00.000+01:00

Hace tiempo que tenía ganas de ver como funcionaban los menús laterales estilo Facebook o Google+. Por suerte hace poco he podido utilizarlos en un proyecto y está dando un buen resultado. Gracias a las librerías existentes implementarlo en un proyecto se vuelve un juego de niños.

Lo primero de todo será buscar una librería, yo encontré varias y me decanté por esta la de jfeistein10 en GitHub.com https://github.com/jfeinstein10/SlidingMenu podéis seguirlo a través de Twitter @SlidingMenu además de otras redes sociales y dispone de una aplicación en el market de Google por si quereis ver todos los ejemplos de su librería. Aquí tenéis una captura de pantalla.

Empezamos descargando su librería en el anterior enlace y la descomprimimos. Yo suelo hacerlo en una carpeta donde guardo todas las librerías de Android que voy utilizando. Ahora vamos a Eclipse y crearemos un proyecto nuevo. Indicamos que es un proyecto sobre código existente. Buscamos la carpeta que descomprimimos, y dentro de esta seleccionamos library y aceptamos.

En el nuevo proyecto hacemos botón derecho sobre él y seleccionamos Properties > Android. En mi caso se construye sobre la versión 2.1 de Android. Debemos cambiarlo a la versión 4.0.3 con las librerías de Google Maps. Después de esto veremos que hay unos layouts que dan error, concretamente en el layout_width y layout_height por la propiedad match_parent, la cambiamos por fill_parent, guardamos y volvemos a poner match_parent y volvemos a guardar. No se porque pasa esto, puede ser que no le de tiempo a evaluar correctamente el proyecto con la nueva versión, pero es algo que ya me ha pasado en 3 ordenadores diferentes.

Si estáis en el caso que utilizáis la librería ActionBarSherlock como es mi caso, debéis hacer un cambio más. Otra vez haceis botón derecho sobre el proyecto del SlidingMenu, Properties > Android. En la sección Library añadis una librería y seleccionáis donde tengais la ActionBarSherlock.

Ahora debeis abrir todas las clases que hacen referencia a una Activity en este proyecto, terminan todas por Activity, y el cambio es muy fácil, simplemente hay que cambiar la herencia por la correspondiente clase de la ActionBarSherlock. Por ejemplo, extends Activity quedaría extends SherlockActivity. Por supuesto, si no utilizais la ActionBarSherlock, estos dos pasos no son necesarios.

Además si teneis la librería ActionBarSherlock debeis quitar de la SlidingMenu la librería android-support-v4 porque de lo contrario os dará un error diciendo que está repetida.

Ya tenemos lista la librería para utilizar en nuestro proyecto. Seguimos los mismos pasos que seguimos para añadir la librería ActionBarSherlock antes pero ahora en nuestro proyecto y añadiendo la librería del SlidingMenu.

Antes de llamar al SlidingMenu en nuestra activity vamos a crear una serie de archivos necesarios. El primero se llama shadow.xml y se ubica en drawable. Es una sombra que se utilizará en el menú.

<?xml version="1.0" encoding="utf-8"?>
<shape xmlns:android="http://schemas.android.com/apk/res/android" >
    <gradient
        android:endColor="#33000000"
        android:centerColor="#11000000"
        android:startColor="#00000000" />
</shape>

El siguiente es dimens.xml y se ubica en values. Sirve para guardar tamaños o dimensiones de objetos y se pueden utilizar de una forma muy similar a como lo hacemos en styles o strings.xml.

<resources>
    <dimen name="slidingmenu_offset">60dp</dimen>
    <dimen name="list_padding">10dp</dimen>
    <dimen name="shadow_width">15dp</dimen>
    <integer name="num_cols">1</integer>
</resources>

Ahora vamos a la carpeta layout y creamos menu_list.xml, este archivo mostrará la lista de opciones de nuestro menú en un ListView. Es un layout normal que se utiliza de la misma forma que en cualquier activity.

<?xml version="1.0" encoding="utf-8"?>
<ListView xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@android:id/list"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:paddingLeft="5dip"
    android:paddingRight="5dip" />

Seguimos en la carpeta layout y creamos menu_row.xml, será la plantilla utilizada para cada uno de los items de nuestro ListView anterior.

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="50dp"
    android:orientation="horizontal" >

    <ImageView
        android:id="@+id/row_icon"
        android:layout_width="50dp"
        android:layout_height="50dp"
        android:padding="10dp"
        android:src="@drawable/ic_launcher" />

    <TextView
        android:id="@+id/row_title"
        android:layout_width="0dp"
        android:layout_height="match_parent"
        android:layout_weight="1"
        android:gravity="center_vertical"
        android:padding="10dp"
        android:text="Medium Text"
        android:textAppearance="@android:style/TextAppearance.Medium" />
</LinearLayout>

El último de los archivos de la carpeta layout será menu.xml, este es el layout que deberá llamar nuestro SlidingMenu. En el atributo android:name estamos poniendo el espacio de nombres de nuestra aplicación seguido de la clase MenuFragment que explicaremos ahora. A este fragment le estamos diciendo que cuando se empiece a utiliza esta vista debe llamar a la clase MenuFragment.

<?xml version="1.0" encoding="utf-8"?>
<fragment xmlns:android="http://schemas.android.com/apk/res/android"
    android:name="aqui.vuestro.espacio.de.nombres.MenuFragment"
    android:layout_width="match_parent"
    android:layout_height="match_parent">
</fragment>

La siguiente clase se llama MenuFragment y hereda de ListFragment. Lo que hará esta clase es al crear la vista en el onCreateView decirle que debe utilizar el layout menu_list.xml. Cuando la Activity se crea inicializamos la clase SampleAdapter que no es más que una clase auxiliar que hereda de ArrayAdapter y que nos ayudará a añadir cada uno de los items al ListView.

Podríamos en vez de tener un ListView utilizar cualquier otro elemento como un ScrollView con diferentes elementos anidados o lo que se os ocurra o necesiteis. Se accede de la misma forma a los elementos como si lo hicieramos en una Activity normal.

public class MenuFragment extends ListFragment {

 public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
  return inflater.inflate(R.layout.menu_list, null);
 }

 public void onActivityCreated(Bundle savedInstanceState) {
  super.onActivityCreated(savedInstanceState);
  SampleAdapter adapter = new SampleAdapter(getActivity());
  for (int i = 0; i < 20; i++) {
   adapter.add(new SampleItem("Sample List", android.R.drawable.ic_menu_search));
  }
  setListAdapter(adapter);
 }

 private class SampleItem {
  public String tag;
  public int iconRes;
  public SampleItem(String tag, int iconRes) {
   this.tag = tag; 
   this.iconRes = iconRes;
  }
 }

 public class SampleAdapter extends ArrayAdapter<SampleItem> {

  public SampleAdapter(Context context) {
   super(context, 0);
  }

  public View getView(int position, View convertView, ViewGroup parent) {
   if (convertView == null) {
    convertView = LayoutInflater.from(getContext()).inflate(R.layout.menu_row, null);
   }
   ImageView icon = (ImageView) convertView.findViewById(R.id.row_icon);
   icon.setImageResource(getItem(position).iconRes);
   TextView title = (TextView) convertView.findViewById(R.id.row_title);
   title.setText(getItem(position).tag);

   return convertView;
  }

 }
 
}

Por último vamos a ver como añadir el SlidingMenu a nuestra Activity. Para ello abrimos la Activity donde lo utilizaremos. Lo primero de todo es cambiar la herencia por una de las Activitys que modificamos antes en la librería SlidingMenu. En este caso por SlidingFragmentActivity, esto nos proporcionará los métodos necesarios para añadir el menú lateral.

Lo siguiente es indicar cual es el layout de nuestro menú de una forma a como lo haríamos con setContentView pero con setBehindContentView. Y ahora inicializamos y seteamos nuestro SlidingMenu. Le indicamos el modo en como debemos tocar la pantalla para deslizar, el ancho de la sombra del menú, el drawable... Hay bastantes opciones de configuración y os recomiendo que le echeis un vistazo a la aplicación que hay disponible con los ejemplos y al código disponible en github.

Después de configurar todo habilitamos la action bar y el botón de home para poder tocar en este y abrir y cerrar el menú. Por último, capturamos el evento correspondiente a cuando pulsamos un item del menú (en este caso el menú de siempre de Android) y evaluamos si es el botón de home de la action bar, en caso de serlo hacemos un toggle que será el método encargado de abrir o cerrar el SlidingMenu según corresponda.

public class MiActivity extends SlidingFragmentActivity{ 
 
 private SlidingMenu menu;
 
 
  @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.main_layout);

        setBehindContentView(R.layout.menu);
        
        setSlidingActionBarEnabled(false);        

        menu = new SlidingMenu(this);
        menu.setTouchModeAbove(SlidingMenu.TOUCHMODE_FULLSCREEN);
        menu.setShadowWidthRes(R.dimen.shadow_width);
        menu.setShadowDrawable(R.drawable.shadow);
        menu.setBehindOffsetRes(R.dimen.slidingmenu_offset);
        menu.setFadeDegree(0.35f);
        menu.attachToActivity(this, SlidingMenu.SLIDING_CONTENT);
        
        getSupportActionBar().setDisplayShowCustomEnabled(true);
        getSupportActionBar().setDisplayHomeAsUpEnabled(true);        
        
  }

@Override
    public boolean onOptionsItemSelected(MenuItem item) {
   switch (item.getItemId()) {
        case android.R.id.home:     
         toggle();           
            return true;               
        default:
            return super.onOptionsItemSelected(item);
        }  
    }
}

Notificaciones Push en Android II

2012-12-19T18:42:00.000+01:00

La semana pasada le echamos un vistazo a las notificaciones push en Android de la mano del servicio Google Cloud Messaging y preparamos la parte servidor. Esta semana vamos a completar lo anterior preparando la parte cliente. Daremos de alta y baja a un usuario y prepararemos nuestra aplicación para recibir mensajes.

Como la semana pasada, antes de meternos en harina, debemos comprobar si tenemos instalado en nuestro SDK de Android la librería gcm.jar que nos facilitará casi todo el trabajo. Para ello, en Eclipse vamos a Window > Android SDK Manager. Aquí nos aparecerán todas las APIs y librerías que tenemos instaladas. Vamos a la sección Extras y si no está instalada la opción Google Cloud Messaging for Android Library la chequeamos e instalamos.

Una vez terminada la instalación, vamos a la carpeta donde tengamos instalado el SDK de Android y desde ahí hasta la carpeta \extras\google\gcm\gcm-client\dist y copiamos el archivo gcm.jar.

Ahora vamos a nuestro proyecto y en la carpeta libs pegamos este archivo. Hacemos click con el botón derecho del ratón sobre él y seleccionamos Build Path > Add to Build Path. Ahora ya podemos empezar a crear nuestro servicio para recibir notificaciones push.

Empezaremos primero por el archivo AndroidManifext.xml que hoy tiene más código del habitual.

<permission android:name="nombre.del.package.de.vuestra.app.permission.C2D_MESSAGE" android:protectionLevel="signature" />
<uses-permission android:name="nombre.del.package.de.vuestra.app.permission.C2D_MESSAGE" />
<uses-permission android:name="com.google.android.c2dm.permission.RECEIVE" />
<uses-permission android:name="android.permission.GET_ACCOUNTS" />
<uses-permission android:name="android.permission.INTERNET" />
<uses-permission android:name="android.permission.ACCESS_NETWORK_STATE" />
<uses-permission android:name="android.permission.WAKE_LOCK" />
<uses-permission android:name="android.permission.VIBRATE"/>

<application>

<receiver android:name="com.google.android.gcm.GCMBroadcastReceiver"
         android:permission="com.google.android.c2dm.permission.SEND" >
         <intent-filter>
             <action android:name="com.google.android.c2dm.intent.RECEIVE" />
             <action android:name="com.google.android.c2dm.intent.REGISTRATION" />
             <category android:name="nombre.del.package.de.vuestra.app" />
         </intent-filter>
     </receiver>
  
     <service android:name=".GCMIntentService" />

</application>

Como veis es un poco más completo de lo habitual. Las primeras líneas son para indicarle al dispositivo que podrá recibir notificaciones del servicio de Google Cloud Messaging, además indica que solo nuestra aplicación (la que tiene vuestro package) podrá hacerlo. El siguiente permiso, GET_ACCOUNTS lo necesita Google para su servicio de mensajería. Después vienen permisos para internet y verificar el estado de la red, imprescindibles para un servicio de estas características. WAKE_LOCK permitirá "despertar" nuestro dispositivo si está "durmiendo". Y el último VIBRATE, es opcional, simplemente lo usareis si queréis que al notificar algo vuestro dispositivo vibre.

Después, dentro de la etiqueta application (fijaros que a esta etiqueta no le he puesto ningún atributo, vosotros dejad los que tengáis, simplemente es para que sepáis donde poner lo siguiente) definimos un BroadcastReceiver el cual ya viene definido en la librería gcm.jar y hará todo el trabajo sucio, registrar nuestro usuario, recibir notificaciones. Únicamente debéis respetar el nombre del broadcast.

Por último, se define un Service que crearemos luego y que nos ayudará cuando registremos un usuario, cuando recibamos un mensaje o tengamos algún error.

Ahora que ya tenemos el AndroidManifest.xml aclarado vamos a ver como se registran y desregistran los usuarios en nuestra app. El método registerUser antes de nada verifica si existe en el dispositivo el registrarion id que nos da el servicio de Google Cloud Messaging para cada usuario. Si no existe ese código lo registramos con la ayuda de la librería gcm.jar, y si existe no hacemos nada, evitando el proceso de llamar al servicio de Google.

El proceso de desregistro es muy similar, verificamos si existe el código de registro de usuario y llamamos al método unregister de la librería gmc.jar.

private void registerUser(Context context){
  
        final String regId = GCMRegistrar.getRegistrationId(context);
        if (regId.equals("")) {
         GCMRegistrar.register(context, "SENDER_ID QUE VIMOS EN LA ENTRADA ANTERIOR"); 
         Log.v("GCM", "Registrado");
        } else {
            Log.v("GCM", "Ya registrado");
        } 
 }

private void unregisterUser(Context context){
 final String regId = GCMRegistrar.getRegistrationId(context);
        if (!regId.equals("")) {
            GCMRegistrar.unregister(context);
        } else {
            Log.v("GCM", "Ya des-registrado");
        }
 }

Los dos métodos los pongo solos y no los ubico en ninguna activity porque debéis ser vosotros los que decidáis donde van. Por ejemplo, si vuestra app no tiene login podríais poner el método de registro en el onCreate de la primera activity y así todos los usuarios recibirían notificaciones. Si tiene login se puede poner una vez el usuario se haya logado. O a lo mejor solo queréis activarlo y desactivarlo en un formulario donde el usuario lo indique expresamente.

El último paso que nos queda por realizar es crear el Service que comentamos antes en el archivo AndroidManifest.xml, para ello creamos una nueva clase llamada GCMIntentService y que heredará de GCMBaseIntentService.

public class GCMIntentService extends GCMBaseIntentService {

 public GCMIntentService(){
  super("SENDER ID QUE NOS DIO LA API DE GOOGLE");
 }
 
 @Override
 protected void onError(Context context, String errorId) {
  Log.d("GCM", "Error: " + errorId);
 }

 @Override
 protected void onMessage(Context context, Intent intent) {
     String msg = intent.getExtras().getString("msg");
     Log.d("GCM", "Mensaje: " + msg);
     notificarMensaje(context, msg);
 }

 @Override
 protected void onRegistered(Context context, String regId) {
  Log.d("GCM", "onRegistered: Registrado OK.");
   //En este punto debeis obtener el usuario donde lo tengais guardado.
   //Si no teneis un sistema de login y los usuarios son anónimos podeis simplemente almacenar el regId
  String usuario = "";
  
    registrarUsuario(usuario, regId);

 }

 @Override
 protected void onUnregistered(Context context, String regId) {
  Log.d("GCM", "onUnregistered: Desregistrado OK.");
 }
 
 private void registrarUsuario(String username, String regId){
  Log.w("GCM", "registrarUsuario");
  Log.w("GCM", "username: " + username);
  Log.w("GCM", "regID: " + regId);
  try{
   
   ArrayList<namevaluepair> nameValuePairs = new ArrayList<namevaluepair>();
   nameValuePairs.add(new BasicNameValuePair("tag","usersave"));
   nameValuePairs.add(new BasicNameValuePair("username",username));
   nameValuePairs.add(new BasicNameValuePair("gcmcode",regId));
   
   HttpClient httpclient = new DefaultHttpClient();
   HttpPost httppost = new HttpPost("http://ip donde está alojado el servicio web/index.php");
   if(nameValuePairs != null)
    httppost.setEntity(new UrlEncodedFormEntity(nameValuePairs));
   
   ResponseHandler<string> responseHandler = new BasicResponseHandler();
   String res = httpclient.execute(httppost, responseHandler);
   
   Log.w("GCM", "RES: " + res);
   

  } catch(Exception e){
   Log.w("GCM", "ex: " + e.getMessage().toString());
  }
 }
 
 private void notificarMensaje(Context context, String msg)
 {
     String notificationService = Context.NOTIFICATION_SERVICE;
     NotificationManager notificationManager =(NotificationManager) context.getSystemService(notificationService);
  
     //Configuramos la notificación
     int icono = android.R.drawable.ic_launcher;
     CharSequence estado = "Has recibido un nuevo mensaje";
     long hora = System.currentTimeMillis();
  
     Notification notification = new Notification(icono, estado, hora);
     long[] vibrate = {100,100,200,300};
     notification.vibrate = vibrate;
  
     //Configuramos el Intent
     Context contexto = context.getApplicationContext();
     CharSequence titulo = "Nombre app - nuevo Mensaje";
     CharSequence descripcion = msg;
  
     Intent intent = new Intent(contexto, activitydestino.class);
     Bundle b = new Bundle();
     b.putInt("update", 1);
     intent.putExtra("android.intent.extra.INTENT", b);

     PendingIntent contIntent = PendingIntent.getActivity(contexto, 0, intent, android.content.Intent.FLAG_ACTIVITY_NEW_TASK);
  
    notifification.setLatestEventInfo(contexto, titulo, descripcion, contIntent);
  
    notification.flags |= Notification.FLAG_AUTO_CANCEL;
  
    notificationManager.notify(1, notification); }

}

Esta última parte es un poco más compleja, pero no mucho. Lo primero fijaros en el constructor, debe llamar al contructor padre pasándole el sender id que nos da Google, lo que en la web es el ID Project.

Despues tendremos cuatro eventos básicos que sobreescribimos para hacer lo que más se adapte a nuestra aplicación. Tenemos onError, que nos informa de algún error en el proceso. onRegistered y onUnregistered que se producen cuando un usuario se da de alta o baja del servicio de Google Cloud Messaging, en estos dos casos debemos dar de alta o baja al usuario en nuestro servidor. Y por último, onMessage, que se produce cada vez que llega un mensaje push.

Lo que hace el método registrarUsuario ya lo hemos visto más veces, simplemente es una llamada al servicio web que hicimos la semana pasada y que envía el nombre de usuario, el código de Google Cloud Messaging y un tag para indicar la acción a realizar. A la hora de recoger el resultado de la acción no hacemos nada con el resultado, pero se podría o bien guardar en caso de error el usuario para volver a intentar registrar más tarde o bien des-registrar del servicio de Google al usuario y que al volver a entrar se repitiera el proceso de registro. El como, cuando y donde hacer esta parte ya os corresponde a vosotros y como hayáis planteado el alta del usuario en vuestro sistema.

El último método notificarMensaje simplemente recibe un mensaje y lo notifica al usuario. Si recordáis, en el servicio web se mandaban parámetros con data.msg, data.fecha, data.autor... para recogerlos, en onMessage se utiliza: intent.getExtras().getString("msg"); Esto será para el caso de data.msg, y haceis lo mismo para el resto sustituyendo msg por lo que corresponda.

A la hora de notificar hacemos uso de notificationManager, podemos configurar el icono, el texto de cabecera, le pasamos la descripción que será el mensaje que hemos recibido. Si queremos podemos hacer que vibre el teléfono. También podemos definir un Intent para que al pulsar en el mensaje abra la aplicación en un determinado punto y además en nuestro caso le pasamos un parámetro que en mi caso se llama update y su valor es 1, de esta forma puedo ahorrarle mucha batería y tráfico de datos al usuario si solo actualizo datos cuando yo se lo notifico.

Se podría enviar en los parámetros datos como un identificador y abrir la ficha de una noticia por ejemplo, o lo que a vosotros se os ocurra. Incluso desde el notificarMensaje podéis hacer de forma totalmente silenciosa alguna actualización de datos y el usuario al entrar no tendría que esperar y siempre tendría los datos actualizados.

Por último, para empezar a enviar notificaciones para recibirlas en el dispositivo móvil, debéis utilizar el servicio web de la semana pasada haciendo llamadas al método sendMessageToPhone de la clase gcm. Este lo podríais integrar en una web, por ejemplo cada vez que se publique una noticia que se llame. También en un chat, o incluso podéis hacer llamadas a este servicio desde la misma aplicación móvil para tener vuestra app de mensajería.

Si queréis podéis aprender más sobre como trabajar en vuestra aplicación con acciones en el artículo: enviar y recibir acciones con BroadcastReceiver en Android.

Notificaciones Push en Android I

2012-12-12T18:32:00.000+01:00

Quien no conoce aplicaciones como WhatsApp, Google Talk, Facebook Messenger o el tan mencionado últimamente Line? Y que tienen en común todos ellos? A parte de servir para comunicarse, que el sistema de comunicaciones se hace a través de notificaciones Push. Vamos a echarle un ojo y ver como funcionan.

Ya hace bastante tiempo que estas aplicaciones se han instalado en nuestras vidas y que han conseguido desbancar casi por completo a los obsoletos SMS. Ahora gracias al nuevo servicio de Google Cloud Messaging, podemos crear nuestro propio sistema de notificaciones Push en nuestras aplicaciones. Imaginad como puede llegar a mejorar nuestra aplicación con un sencillo servicio de notificaciones.

Voy a tratar de explicar brevemente como sería el proceso de envío. En el primer paso nuestro dispositivo se registra de forma totalmente transparente al usuario en el sevidor de Google para decirle que puede recibir notificaciones para nuestra aplicación. En este registro el servidor de Google nos devuelve un Identificador a nuestra aplicación Android que deberemos almacenar en un servidor de nuestra propiedad. Una vez ya están todos presentados, desde nuestro servidor ya se pueden empezar a enviar mensajes. Para ello se envían peticiones al servidor de Google y este se encarga de enviarlo si el dispositivo está online o de esperar a que el dispositivo se reconecte para enviarlo.

Lo primero que debemos hacer es activar el servicio de Google Cloud Messaging en la siguiente dirección https://code.google.com/apis/console. Debeis disponer de una cuenta de Google para poder realizar este proceso.

Creamos un proyecto el cual nos dará un senderId que deberemos utilizar en la app Android. Lo podéis encontrar en la pestaña Overview, sección Project Number.

Lo siguiente es activar el servicio de mensajería. Para ello en la pestaña Services buscáis Google Cloud Messaging for Android y lo poneis a ON. Ya por último, vais a API Access y pulsais el botón "Create new Server key" (en la pantalla que aparece no hace falta rellenar nada). Esto nos creará una apiKey, ojo, la de la sección Key for server apps. La cual utilizaremos después.

Esta es toda la configuración que necesitamos en el servidor de Google.

Vamos ahora a crear la parte servidor. Para ello lo haremos como es habitual en PHP y MySQL, pero vosotros lo podeis adaptar de una forma muy simple al lenguaje que necesiteis.

Lo primero que vamos a hacer es crear una tabla en nuestra base de datos para almacenar los usuarios que se registren en nuestra app para saber los registration id que nos proporcionó Google Cloud Messaging.

CREATE TABLE IF NOT EXISTS `usuarios` (
  `username` varchar(100) NOT NULL,
  `gcmcode` varchar(500) NOT NULL,
  PRIMARY KEY (`username`)
) ENGINE=InnoDB;

Como podéis ver, es una tabla de usuarios muy simple. El nombre de usuario es clave pero el gcmcode no, porque de vez en cuando el servicio de Google puede cambiarlo y nosotros debemos actualizarlo.

Vamos a crear 3 archivos php, uno para gestionar las llamadas a las funciones de nuestra aplicación servidor, otro para los usuarios y otro para los mensajes. Vamos a empezar por los usuarios. Para ello creamos una archivo llamado users.php, veamos que tiene.

<?php
class users {
 
 function __construct() {
  $con = mysql_connect("NOMBRE_HOST", "NOMBRE_DB_USER", "DB_PASSWORD");  
  mysql_select_db("NOMBRE_DB_DATABASE");
 }
 
 public function saveUser($username, $gcmcode){
  $response = array("success" => "0");
  $sql  ="INSERT INTO usuarios (username, gcmcode) VALUES ('" . stripslashes($username) . "', '" . stripslashes($gcmcode) . "') 
    ON DUPLICATE KEY UPDATE gcmcode = '" . stripslashes($gcmcode)."' ; ";
  
  $result = mysql_query($sql);
  if(mysql_affected_rows() > 0)
   $response["success"] = "1";  
  
  return json_encode($response);
 }
 
 public function getUser($username){
  $response = array("success" => 0);
  
  $sql = "SELECT username, gcmcode
    FROM usuarios 
    WHERE username='".stripslashes($username)."';";
  $result = mysql_query($sql);
  if(mysql_num_rows($result) > 0){
   $data = mysql_fetch_array($result);
   
   return $data;
  } else 
   return false;  
 }
}
?>

Para empezar, en el contructor de la clase users configuramos la base de datos. Se debería tener los parámetros en un archivo de configuración a parte, pero para simplificar lo dejamos así. El método saveUser recibe el nombre de nuestro usuario en la aplicación y el código que nos dió Google. Como veis se intenta hacer un insert en la tabla de usuarios y en caso de que el usuario ya exista se renueva el código de Google. Esto es por lo que os comentaba antes, Google de vez en cuando puede cambiar nuestro código usuario y debemos actualizarlo. El método getUser lo utilizaremos en el siguiente archivo y nos devolverá información sobre un determinado usuario.

Lo siguiente es el archivo destinado a gestionar los mensajes, el cual llamaremos gcm.php

<?php 
class gcm {
 
 function __construct() {
  $con = mysql_connect("NOMBRE_HOST", "NOMBRE_DB_USER", "DB_PASSWORD");
  mysql_select_db("NOMBRE_DB_DATABASE");
 }
 
 function sendMessageToPhone($collapseKey, $messageText, $username)
 {
  include_once 'users.php';
  $user = new users();
  $data = $user->getUser($username); 
  if($data != false){
  
   $apiKey = 'AQUI LA API KEY PARA SERVER QUE OS PROPORCIONÓ GOOGLE';
   
   $userIdentificador = $data["gcmcode"];
   
   $headers = array('Authorization:key=' . $apiKey);
   $data = array(
     'registration_id' => $userIdentificador,
     'collapse_key' => $collapseKey,
     'data.message' => $messageText);
  
   $ch = curl_init();
  
   curl_setopt($ch, CURLOPT_URL, "https://android.googleapis.com/gcm/send");
   if ($headers)
    curl_setopt($ch, CURLOPT_HTTPHEADER, $headers);
   curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, false);
   curl_setopt($ch, CURLOPT_POST, true);
   curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
   curl_setopt($ch, CURLOPT_POSTFIELDS, $data);
  
   $response = curl_exec($ch);
   $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
   if (curl_errno($ch)) {
    return 'fail';
   }
   if ($httpCode != 200) {
    return 'status code 200';
   }
   curl_close($ch);
   return $response;
  } else {
   return 'no user';
  }
 } 
}

?>

Otra vez en el constructor estamos inicializando la conexión a la base de datos. Y el método sendMessagetoPhone recibe tres parámetros. El primero es un identificador para indicarle a Google si debe colapsar o no los mensajes en caso de que hablen de un mismo tema. Si lanzais notificaciones sobre una misma noticia por ejemplo, colapsará los mensajes. Podeis utilizar por ejemplo el id de la noticia, su permalink que actuará como identificador, en fin, algo único que os sirva para identificar notificaciones del mismo tipo. El segundo es el mensaje que vamos a mandar y el tercero el nombre del usuario al que le enviamos el mensaje.

Este método lo que va a hacer es enviar al servidor de Google una petición para enviar un mensaje. En el apartado de registration_id, si queremos enviar a más de un dispositivo simplemente creamos un array con los ids de los usuarios de destino. Y el atributo data.message nos sirve para enviar el texto del mensaje. Si quisieramos enviar más datos como por ejemplo la fecha, añadiriamos el parámetro data.fecha, y si queremos, también el nombre del autor sería data.autor. Todo lo que querramos añadir a mayores debe ir precedido de "data.".

Finalmente este método nos devolverá el resultado de la petición, la cual puede fallar por diversos motivos. El como gestionemos los errores ya dependerá de cada uno.

El último archivo que nos queda por ver es el index.php, este servirá como entrada para llamar a todas los métodos que creamos antes.

<?php
include_once 'users.php';
include_once 'gcm.php';
$tag = $_POST['tag'];

switch ($tag){
 case 'usersave':
  $username = "";
  $gcmcode = "";
  if(isset($_POST['username']))
   $username = $_POST['username'];
  if(isset($_POST['gcmcode']))
   $gcmcode = $_POST['gcmcode'];
  
  $user = new users();
  echo $user->saveUser($username, $gcmcode);
  break;
 case 'sendmessage':
  $username = "";
  $message = "";
  $collapseKey = "";
  if(isset($_POST['message']))
   $message = $_POST['message'];
  if(isset($_POST['username']))
   $username = $_POST['username'];
  if(isset($_POST['collapsekey']))
   $collapseKey = $_POST['collapsekey'];
  $message = new gcm();
  echo $message->sendMessageToPhone($collapseKey, $message, $username);
  break;
 default:
  $response = array("success" => "0", "err" => "no tag");
  echo json_encode($response);
  break;
}
?>

El archivo es muy simple, simplemente recibe por post un parámetro tag que será el que nos diga que acción realizar. Si insertamos o actualizamos un nuevo usuario además debemos enviar el nombre de usuario y el código de registro para ese usuario en el servicio de Google.

Si lo que hacemos es enviar un mensaje le indicamos el nombre de usuario, el mensaje y el collapseKey que será por así decirlo como un identificador para mensajes que se agrupen por un mismo tema. Por ejemplo para una noticia en concreto. En este caso estamos asumiendo que solo vamos a enviar a un único usuario, pero si fueramos a enviar a más usuarios, deberiamos modificar el método para poder recibir todos los usuarios que quisieramos.

Bueno, y hasta aquí por esta semana. La siguiente veremos la parte cliente en Android. Como registrar un usuario en el servicio de Google Cloud Messaging y como recibir mensajes y notificarlo.

Cómo utilizar fragments en Android

2012-12-06T19:16:00.001+01:00

Con las primeras versiones para tablet de Android se incluyó una nueva funcionalidad en la API de Google, los fragments. Trozos de la interfaz de usuario con su propio comportamiento y que pueden ser re-utilizados en las pantallas que deseemos. Por ejemplo para hacer un panel multiple al estilo de la app de Gmail o la app de nosinmiubuntu blog.

La siguiente imagen está sacada de la web de android.com, en ella se nos muestra que con la utilización de fragments podemos llegar a conseguir que en una tablet tengamos dos pantallas de listado-detalle y en un móvil se vea en dos pantallas diferentes. Con esto se consigue aprovechar al máximo el espacio disponible según el dispositivo.

Como dije al principio, esta funcionalidad está disponible a partir de la versión 3.0 de Android, lo cual nos dejaría a las versiones 2.x sin ella, salvo que utilicemos la librería ActionBarSherlock . Hoy vamos a explicar el ejemplo que nos proporciona esta en: https://github.com/JakeWharton/ActionBarSherlock/tree/master/samples/fragments

Vamos a empezar por los layouts, necesitaremos dos, se llaman ambos fragment_layout_support.xml, uno va en la carpeta layout y otro en layout-land. Esto es así porque tendremos dos vistas diferentes dependiendo de la orientación de la pantalla, portrait o landscape.

Esta es la versión de la carpeta layout:

<?xml version="1.0" encoding="utf-8"?>
<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent" android:layout_height="match_parent">
    <fragment class="aqui.vuestro.espacio.de.nombres.FragmentLayoutSupport$TitlesFragment"
            android:id="@+id/titles"
            android:layout_width="match_parent" android:layout_height="match_parent" />
</FrameLayout>

Y esta la de la carpeta layout-land:

<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:orientation="horizontal"
    android:layout_width="match_parent" android:layout_height="match_parent">

    <fragment class="aqui.vuestro.espacio.de.nombres.FragmentLayoutSupport$TitlesFragment"
            android:id="@+id/titles" android:layout_weight="1"
            android:layout_width="0px" android:layout_height="match_parent" />

    <FrameLayout android:id="@+id/details" android:layout_weight="1"
            android:layout_width="0px" android:layout_height="match_parent" />

</LinearLayout>

La diferencia entre ambos es el FrameLayout de la versión landscape. También indico en rojo que debeis poner vuestro espacio de nombres en vez del que traía el ejemplo. Justo despues de eso viene el nombre de la Activity que crearemos a continuación.

Ahora vamos a ver como sería la Activity que gestiona nuestros fragments. Tiene alguna diferencia con el original ya que he quitado comentarios y el método setTheme que lo utilizan para cambiar el aspecto general de la app, y que a nosotros aquí no nos hace falta y puede llegar a confundirnos.

Como dije antes se llamará FragmentLayoutSupport y hereda de SherlockFragmentActivity para que podamos tener toda la funcionalidad de los fragments. El método onCreate no tiene ningún problema, hacemos la llamada como siempre a nuestro layout.

Lo que más nos importa en un primer momento son las dos clases que tenemos dentro de la Activity, DetailsActivity y TitlesFragment. La primera verifica en su onCreate la orientación de la pantalla. Si estamos en posición LandScape no se va a utilizar ya que se mostrará al lado del detalle. En caso de utilizarse instanciamos la clase DetailsFragment que veremos más adelante para mostrar el contenido de cualquiera de los items.

public class FragmentLayoutSupport extends SherlockFragmentActivity {


    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.fragment_layout_support);
    }


    /**
     * This is a secondary activity, to show what the user has selected
     * when the screen is not large enough to show it all in one activity.
     */

    public static class DetailsActivity extends SherlockFragmentActivity {

        @Override
        protected void onCreate(Bundle savedInstanceState) {
            super.onCreate(savedInstanceState);

            if (getResources().getConfiguration().orientation
                    == Configuration.ORIENTATION_LANDSCAPE) {
                // If the screen is now in landscape mode, we can show the
                // dialog in-line with the list so we don't need this activity.
                finish();
                return;
            }

            if (savedInstanceState == null) {
                // During initial setup, plug in the details fragment.
                DetailsFragment details = new DetailsFragment();
                details.setArguments(getIntent().getExtras());
                getSupportFragmentManager().beginTransaction().add(
                        android.R.id.content, details).commit();
            }
        }
    }


    /**
     * This is the "top-level" fragment, showing a list of items that the
     * user can pick.  Upon picking an item, it takes care of displaying the
     * data to the user as appropriate based on the currrent UI layout.
     */

    public static class TitlesFragment extends SherlockListFragment {
        boolean mDualPane;
        int mCurCheckPosition = 0;

        @Override
        public void onActivityCreated(Bundle savedInstanceState) {
            super.onActivityCreated(savedInstanceState);

            // Populate list with our static array of titles.
            setListAdapter(new ArrayAdapter<String>(getActivity(),
                    R.layout.simple_list_item_checkable_1,
                    android.R.id.text1, Shakespeare.TITLES));

            // Check to see if we have a frame in which to embed the details
            // fragment directly in the containing UI.
            View detailsFrame = getActivity().findViewById(R.id.details);
            mDualPane = detailsFrame != null && detailsFrame.getVisibility() == View.VISIBLE;

            if (savedInstanceState != null) {
                // Restore last state for checked position.
                mCurCheckPosition = savedInstanceState.getInt("curChoice", 0);
            }

            if (mDualPane) {
                // In dual-pane mode, the list view highlights the selected item.
                getListView().setChoiceMode(ListView.CHOICE_MODE_SINGLE);
                // Make sure our UI is in the correct state.
                showDetails(mCurCheckPosition);
            }
        }

        @Override
        public void onSaveInstanceState(Bundle outState) {
            super.onSaveInstanceState(outState);
            outState.putInt("curChoice", mCurCheckPosition);
        }

        @Override
        public void onListItemClick(ListView l, View v, int position, long id) {
            showDetails(position);
        }

        /**
         * Helper function to show the details of a selected item, either by
         * displaying a fragment in-place in the current UI, or starting a
         * whole new activity in which it is displayed.
         */
        void showDetails(int index) {
            mCurCheckPosition = index;

            if (mDualPane) {
                // We can display everything in-place with fragments, so update
                // the list to highlight the selected item and show the data.
                getListView().setItemChecked(index, true);

                // Check what fragment is currently shown, replace if needed.
                DetailsFragment details = (DetailsFragment)
                        getFragmentManager().findFragmentById(R.id.details);
                if (details == null || details.getShownIndex() != index) {
                    // Make new fragment to show this selection.
                    details = DetailsFragment.newInstance(index);

                    // Execute a transaction, replacing any existing fragment
                    // with this one inside the frame.
                    FragmentTransaction ft = getFragmentManager().beginTransaction();
                    ft.replace(R.id.details, details);
                    ft.setTransition(FragmentTransaction.TRANSIT_FRAGMENT_FADE);
                    ft.commit();
                }

            } else {
                // Otherwise we need to launch a new activity to display
                // the dialog fragment with selected text.
                Intent intent = new Intent();
                intent.setClass(getActivity(), DetailsActivity.class);
                intent.putExtra("index", index);
                startActivity(intent);
            }
        }
    }


    /**
     * This is the secondary fragment, displaying the details of a particular
     * item.
     */

    public static class DetailsFragment extends SherlockFragment {
        /**
         * Create a new instance of DetailsFragment, initialized to
         * show the text at 'index'.
         */
        public static DetailsFragment newInstance(int index) {
            DetailsFragment f = new DetailsFragment();

            // Supply index input as an argument.
            Bundle args = new Bundle();
            args.putInt("index", index);
            f.setArguments(args);

            return f;
        }

        public int getShownIndex() {
            return getArguments().getInt("index", 0);
        }

        @Override
        public View onCreateView(LayoutInflater inflater, ViewGroup container,
                Bundle savedInstanceState) {
            if (container == null) {
                // We have different layouts, and in one of them this
                // fragment's containing frame doesn't exist.  The fragment
                // may still be created from its saved state, but there is
                // no reason to try to create its view hierarchy because it
                // won't be displayed.  Note this is not needed -- we could
                // just run the code below, where we would create and return
                // the view hierarchy; it would just never be used.
                return null;
            }

            ScrollView scroller = new ScrollView(getActivity());
            TextView text = new TextView(getActivity());
            int padding = (int)TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP,
                    4, getActivity().getResources().getDisplayMetrics());
            text.setPadding(padding, padding, padding, padding);
            scroller.addView(text);
            text.setText(Shakespeare.DIALOGUE[getShownIndex()]);
            return scroller;
        }
    }

}

La clase TitlesFragment hereda de SherlockListFragment y nos servirá para mostrar una lista de elementos. Para que empiece a funcionar, si vais a los layouts veréis en el atributo class del fragment que después de hacer referencia a nuestra Activity se añade el simbolo $ y el nombre de la clase TitlesFragment. Y con esto el fragment ya sabe a que clase debe llamar para mostrar su contenido.

Lo siguiente de esta clase será rellenar su ListView mediante los valores que hay en la clase Shakespeare. También se intenta instanciar el elemento details, que como vimos antes va a estar solo en un layout. Si no es nulo el valor donde almacenamos su referencia vamos a tener dos paneles para mostrar.

En esta misma clase un poco más adelante encontramos el método showDetails que nos servirá para mostrar el contenido de cada uno de los items cada vez que pulsemos en un elemento de la lista. En este método se evalúa si estamos en modo mDualPane, es decir, si tenemos dos paneles. En caso de ser un solo panel simplemente se llama a la activity DetailsActivity para mostrar el contenido, y en caso de ser dos se instancia DetailsFragment que pasará a mostrarse en el FrameLayout details de nuestro layout. En ambos casos se les pasa como argumento index para saber de nuestra lista de elementos cual debemos mostrar.

Por último, nos queda explicar la clase DetailsFragment que ya comentamos antes. Simplemente se va encargar de recoger el parámetro index que nos dirá el item que debemos mostrar de la clase Shakespeare.

Su método onCreateView será el encargado de crear y devolver la vista que se verá finalmente. En este caso se crea y devuelve un ScrollView al que se le añade un TextView con el texto de nuestro item.

Durante todo el artículo hemos hablado de la clase Shakespeare. Simplemente es una clase con dos String Arrays, uno para los títulos y otro para los textos. Se podría complicar mucho más el ejemplo descargando datos de un servicio web o leyendo de la base de datos, pero los fragments ya son suficientemente complejos como para en un primer vistazo hacerlo más difícil.

public final class Shakespeare {
    /**
     * Our data, part 1.
     */
    public static final String[] TITLES =
    {
            "Henry IV (1)",
            "Henry V",
            "Henry VIII",
            "Richard II",
            "Richard III",
            "Merchant of Venice",
            "Othello",
            "King Lear"
    };

    /**
     * Our data, part 2.
     */
    public static final String[] DIALOGUE =
    {
            "So shaken as we are, so wan with care," +
            "Find we a time for frighted peace to pant," +
            "And breathe short-winded accents of new broils" +
            "To be commenced in strands afar remote." +
            "No more the thirsty entrance of this soil" +
            "Shall daub her lips with her own children's blood;" +
            "Nor more shall trenching war channel her fields," +
            "Nor bruise her flowerets with the armed hoofs" +
            "Of hostile paces: those opposed eyes," +
            "Which, like the meteors of a troubled heaven," +
            "All of one nature, of one substance bred," +
            "Did lately meet in the intestine shock" +
            "And furious close of civil butchery" +
            "Shall now, in mutual well-beseeming ranks," +
            "March all one way and be no more opposed" +
            "Against acquaintance, kindred and allies:" +
            "The edge of war, like an ill-sheathed knife," +
            "No more shall cut his master. Therefore, friends," +
            "As far as to the sepulchre of Christ," +
            "Whose soldier now, under whose blessed cross" +
            "We are impressed and engaged to fight," +
            "Forthwith a power of English shall we levy;" +
            "Whose arms were moulded in their mothers' womb" +
            "To chase these pagans in those holy fields" +
            "Over whose acres walk'd those blessed feet" +
            "Which fourteen hundred years ago were nail'd" +
            "For our advantage on the bitter cross." +
            "But this our purpose now is twelve month old," +
            "And bootless 'tis to tell you we will go:" +
            "Therefore we meet not now. Then let me hear" +
            "Of you, my gentle cousin Westmoreland," +
            "What yesternight our council did decree" +
            "In forwarding this dear expedience.",

            "Hear him but reason in divinity," +
            "And all-admiring with an inward wish" +
            "You would desire the king were made a prelate:" +
            "Hear him debate of commonwealth affairs," +
            "You would say it hath been all in all his study:" +
            "List his discourse of war, and you shall hear" +
            "A fearful battle render'd you in music:" +
            "Turn him to any cause of policy," +
            "The Gordian knot of it he will unloose," +
            "Familiar as his garter: that, when he speaks," +
            "The air, a charter'd libertine, is still," +
            "And the mute wonder lurketh in men's ears," +
            "To steal his sweet and honey'd sentences;" +
            "So that the art and practic part of life" +
            "Must be the mistress to this theoric:" +
            "Which is a wonder how his grace should glean it," +
            "Since his addiction was to courses vain," +
            "His companies unletter'd, rude and shallow," +
            "His hours fill'd up with riots, banquets, sports," +
            "And never noted in him any study," +
            "Any retirement, any sequestration" +
            "From open haunts and popularity.",

            "I come no more to make you laugh: things now," +
            "That bear a weighty and a serious brow," +
            "Sad, high, and working, full of state and woe," +
            "Such noble scenes as draw the eye to flow," +
            "We now present. Those that can pity, here" +
            "May, if they think it well, let fall a tear;" +
            "The subject will deserve it. Such as give" +
            "Their money out of hope they may believe," +
            "May here find truth too. Those that come to see" +
            "Only a show or two, and so agree" +
            "The play may pass, if they be still and willing," +
            "I'll undertake may see away their shilling" +
            "Richly in two short hours. Only they" +
            "That come to hear a merry bawdy play," +
            "A noise of targets, or to see a fellow" +
            "In a long motley coat guarded with yellow," +
            "Will be deceived; for, gentle hearers, know," +
            "To rank our chosen truth with such a show" +
            "As fool and fight is, beside forfeiting" +
            "Our own brains, and the opinion that we bring," +
            "To make that only true we now intend," +
            "Will leave us never an understanding friend." +
            "Therefore, for goodness' sake, and as you are known" +
            "The first and happiest hearers of the town," +
            "Be sad, as we would make ye: think ye see" +
            "The very persons of our noble story" +
            "As they were living; think you see them great," +
            "And follow'd with the general throng and sweat" +
            "Of thousand friends; then in a moment, see" +
            "How soon this mightiness meets misery:" +
            "And, if you can be merry then, I'll say" +
            "A man may weep upon his wedding-day.",

            "First, heaven be the record to my speech!" +
            "In the devotion of a subject's love," +
            "Tendering the precious safety of my prince," +
            "And free from other misbegotten hate," +
            "Come I appellant to this princely presence." +
            "Now, Thomas Mowbray, do I turn to thee," +
            "And mark my greeting well; for what I speak" +
            "My body shall make good upon this earth," +
            "Or my divine soul answer it in heaven." +
            "Thou art a traitor and a miscreant," +
            "Too good to be so and too bad to live," +
            "Since the more fair and crystal is the sky," +
            "The uglier seem the clouds that in it fly." +
            "Once more, the more to aggravate the note," +
            "With a foul traitor's name stuff I thy throat;" +
            "And wish, so please my sovereign, ere I move," +
            "What my tongue speaks my right drawn sword may prove.",

            "Now is the winter of our discontent" +
            "Made glorious summer by this sun of York;" +
            "And all the clouds that lour'd upon our house" +
            "In the deep bosom of the ocean buried." +
            "Now are our brows bound with victorious wreaths;" +
            "Our bruised arms hung up for monuments;" +
            "Our stern alarums changed to merry meetings," +
            "Our dreadful marches to delightful measures." +
            "Grim-visaged war hath smooth'd his wrinkled front;" +
            "And now, instead of mounting barded steeds" +
            "To fright the souls of fearful adversaries," +
            "He capers nimbly in a lady's chamber" +
            "To the lascivious pleasing of a lute." +
            "But I, that am not shaped for sportive tricks," +
            "Nor made to court an amorous looking-glass;" +
            "I, that am rudely stamp'd, and want love's majesty" +
            "To strut before a wanton ambling nymph;" +
            "I, that am curtail'd of this fair proportion," +
            "Cheated of feature by dissembling nature," +
            "Deformed, unfinish'd, sent before my time" +
            "Into this breathing world, scarce half made up," +
            "And that so lamely and unfashionable" +
            "That dogs bark at me as I halt by them;" +
            "Why, I, in this weak piping time of peace," +
            "Have no delight to pass away the time," +
            "Unless to spy my shadow in the sun" +
            "And descant on mine own deformity:" +
            "And therefore, since I cannot prove a lover," +
            "To entertain these fair well-spoken days," +
            "I am determined to prove a villain" +
            "And hate the idle pleasures of these days." +
            "Plots have I laid, inductions dangerous," +
            "By drunken prophecies, libels and dreams," +
            "To set my brother Clarence and the king" +
            "In deadly hate the one against the other:" +
            "And if King Edward be as true and just" +
            "As I am subtle, false and treacherous," +
            "This day should Clarence closely be mew'd up," +
            "About a prophecy, which says that 'G'" +
            "Of Edward's heirs the murderer shall be." +
            "Dive, thoughts, down to my soul: here" +
            "Clarence comes.",

            "To bait fish withal: if it will feed nothing else," +
            "it will feed my revenge. He hath disgraced me, and" +
            "hindered me half a million; laughed at my losses," +
            "mocked at my gains, scorned my nation, thwarted my" +
            "bargains, cooled my friends, heated mine" +
            "enemies; and what's his reason? I am a Jew. Hath" +
            "not a Jew eyes? hath not a Jew hands, organs," +
            "dimensions, senses, affections, passions? fed with" +
            "the same food, hurt with the same weapons, subject" +
            "to the same diseases, healed by the same means," +
            "warmed and cooled by the same winter and summer, as" +
            "a Christian is? If you prick us, do we not bleed?" +
            "if you tickle us, do we not laugh? if you poison" +
            "us, do we not die? and if you wrong us, shall we not" +
            "revenge? If we are like you in the rest, we will" +
            "resemble you in that. If a Jew wrong a Christian," +
            "what is his humility? Revenge. If a Christian" +
            "wrong a Jew, what should his sufferance be by" +
            "Christian example? Why, revenge. The villany you" +
            "teach me, I will execute, and it shall go hard but I" +
            "will better the instruction.",

            "Virtue! a fig! 'tis in ourselves that we are thus" +
            "or thus. Our bodies are our gardens, to the which" +
            "our wills are gardeners: so that if we will plant" +
            "nettles, or sow lettuce, set hyssop and weed up" +
            "thyme, supply it with one gender of herbs, or" +
            "distract it with many, either to have it sterile" +
            "with idleness, or manured with industry, why, the" +
            "power and corrigible authority of this lies in our" +
            "wills. If the balance of our lives had not one" +
            "scale of reason to poise another of sensuality, the" +
            "blood and baseness of our natures would conduct us" +
            "to most preposterous conclusions: but we have" +
            "reason to cool our raging motions, our carnal" +
            "stings, our unbitted lusts, whereof I take this that" +
            "you call love to be a sect or scion.",

            "Blow, winds, and crack your cheeks! rage! blow!" +
            "You cataracts and hurricanoes, spout" +
            "Till you have drench'd our steeples, drown'd the cocks!" +
            "You sulphurous and thought-executing fires," +
            "Vaunt-couriers to oak-cleaving thunderbolts," +
            "Singe my white head! And thou, all-shaking thunder," +
            "Smite flat the thick rotundity o' the world!" +
            "Crack nature's moulds, an germens spill at once," +
            "That make ingrateful man!"
    };
}

Por último nos falta definir nuestra activity en el AndroidManifest.xml, en este caso de una forma un poco diferente al resto de ocasiones:

 <activity android:label="@string/fragment_layout_support" android:name=".FragmentLayoutSupport" />
 <activity android:name=".FragmentLayoutSupport$DetailsActivity"/>

Guía de instalación de FreeBSD (Parte III)

2012-12-04T00:00:00.000+01:00

Tal y como habíamos anticipado en la segunda parte de la guía de instalación de FreeBSD, en esta tercera entrega vamos a instalar el sistema de ventanas X y el entorno de escritorio GNOME. El procedimiento es el mismo que el utilizado hasta ahora, es decir, mediante pkg_add. La diferencia está en que el número de paquetes requeridos por X (y sobre todo por GNOME) es considerablemente mayor, así que toca armarse de paciencia y esperar a que todas las descargas se completen.

Vamos allá. Instalamos las X:

Para que en la configuración de las X se reconozca el teclado y el ratón es necesario arrancar dos servicios al inicio: D-Bus (Desktop Bus) y HAL (Hardware Abstraction Layer). Para ello, editamos /etc/rc.conf y añadimos las dos líneas marcadas en verde; luego reiniciamos el equipo:

Ejecutamos el configurador:

Se nos confirma que ha sido generado un fichero de configuración /root/xorg.conf.new :

Comprobamos que dicho fichero existe y lo movemos a /etc/X11/xorg.conf , pues es en esa ruta donde las X buscarán su fichero de configuración. A continuación ejecutamos startx para iniciar el entorno gráfico básico:

La configuración automática ha funcionado. Para salir utilizamos exit :

Es el turno de GNOME :

Instalación finalizada:

Ya no necesitamos ser root, así que cerramos sesión y entramos con nuestro usuario estándar:

Para que al arrancar startx no nos salga el entorno gráfico anterior, si no que se inicie GNOME, tenemos que crear el fichero oculto de configuración .xinitrc y guardar en él la ruta del ejecutable gnome-session. Buscamos la ruta de dicho ejecutable (con which) y la escribimos en .xinitrc. Ahora ya podemos arrancar startx :

Bienvenidos a GNOME :

Aunque veamos los menús en español, el teclado por defecto está en inglés americano, así que vamos a cambiarlo:

Pestaña Distribuciones, botón Añadir :

País España, botón Añadir :

Marcamos EE.UU. para eliminarlo y pulsamos el botón Quitar :

Finalmente, si deseamos salir de GNOME y volver al modo texto:

Con esta tercera entrega finalizamos la instalación y la configuración básica de FreeBSD. Esperamos que esta guía sirva como base para promover el interés por este sistema operativo.

Premios PortalProgarmas al mejor Software Libre 2012

2012-12-02T12:00:00.000+01:00

Desde hace 4 años la web PortalProgramas viene celebrando sus "Premios al mejor Software Libre", y en esta cuarta edición nos han pedido que lo demos a conocer. Estos premios son un certamen creado para promocionar el conocimiento y el uso de los programas libres, además de que los usuarios valoren el trabajo de los desarrolladores.

La mayoría de nosotros utilizamos Software Libre en nuestro día a día con aplicaciones tan conocidas como Firefox, bases de datos MySQL o el mismo servidor Apache, aunque siempre salen a la luz nuevos proyectos, que quizá merezcan reconocimiento pero carezcan de la posibilidad de publicitarse al público, y ahí es donde estos premios entran con nuestra colaboración.

Entre las categorías disponibles, podemos destacar la de "Programa con mayor potencial de crecimiento", que recibirá un premio exclusivo en forma de donación de 300 euros, o las de "Software Libre más popular" y "Mejor blog de software libre", aunque existe un total de diez, las cuales podéis consultar en su web.

Desde el 26 de Noviembre hasta el 6 de Diciembre, cualquier usuario que lo desee puede nominar la aplicación o web que considere digna de ello en la sección de nominaciones.

Una vez cerrado el plazo de nominaciones, se procederá a votar en cada categoría hasta el 28 de diciembre, conociéndose los premiados a partir del 15 de enero.

Desde el blog consideramos que es una buena iniciativa, ya que con ésta se ayuda a seguir adelante a proyectos muy interesantes, como es el caso de aplicaciones como LibreOffice, Openshot o Blender entre otros.

Disponéis de más información en la web de PortalProgramas.

Saludos.

Instala JDownloader en Ubuntu mediante repositorio PPA

2012-11-30T11:00:00.000+01:00

La mayoría de vosotros prefiere la descarga directa de archivos desde servicios como Mediafire, Rapidgator o Uploaded entre otros, en lugar de hacerlo por Bittorrent. Para este tipo de servicios disponemos de una herramienta como es JDownloader.

JDownloader es una plataforma de código abierto que está escrita en Java, y que nos da la posibilidad de gestionar las descarga de archivos de servidores como los que hemos indicado anteriormente, pudiendo realizar descargas múltiples pararelas, reconocimiento de captcha o incluso extracción automática de archivos que pueden estar divididos en partes.

Esta grandiosa aplicación nos permite automatizar la descarga de una gran cantidad de archivos, pudiendo pararlas y reiniciarlas cuando lo necesitemos.

Si quieres instalarla en Ubuntu existe la opción de hacerlo a través de respositorio PPA, por lo que bastará con:

sudo add-apt-repository  ppa:jd-team/jdownloader 

sudo apt-get update

sudo apt-get install jdownloader

Al abrir la aplicación por primera vez nos encontraremos con que comienza a comprobar los paquetes que hay instalados, para así disponer de la última versión de estos.

Una vez iniciada nos pedirá que elijamos el idioma:

Además nos pregunta si deseamos hacer uso de la extensión de gestión de descargas FlashGot, y que habrá instalar por separado, descargándolo desde la página de Addons de Mozilla.

Una vez instalada nos encontraremos que tiene un aspecto bastante intuitivo, y que nos permite añadir los enlaces con el simple hecho de copiarlos en el navegador, y que podremos localizar en la pestaña 'Capturador de Enlaces'.

Además, nos permite el uso de complementos para controlarla remotamente, programar el apagado del equipo una vez finalice la descarga, o descomprimir automáticamente los archivos descragados que componen uno mayor.

Aunque tras la desaparición de un servicio como Megaupload ha perdido adeptos, no deja de ser una aplicación muy útil para servicios de ese tipo. Es, en definitiva, una herramienta muy fácil de usar, que nos facilita la descarga de archivos que están divididos en una gran cantidad de partes, además de una alternativa muy válida para usar como gestor de descargas.

Saludos.

Actualizar bases de datos SQLite en Android

2012-11-28T21:17:00.001+01:00

Ya vimos hace un tiempo como manejar una base de datos desde nuestro dispositivo móvil con el motor de base de datos SQLite que viene con Android. Una de las cosas que nos puede llegar a suceder con el tiempo es que a nuestra base de datos le tengamos que añadir más campos o hacer algún update en alguna tabla.

Normalmente intentamos dejar el modelo de la base de datos bien definido para no tener que hacer cambios en la base de datos. Pero en el caso de que tengamos que hacer modificaciones en nuestra aplicación una vez está publicada esto puede llegar a complicarse, pero no mucho.

Vamos a retomar el código que escribimos en su día sobre como guardar datos en una base de datos. En ese código definimos una variable llamada versión. Esta versión va a ser la versión de la base de datos. Al introducir nuevos cambios debemos cambiar su valor de 1 a 2, y si más adelante quisieramos hacer más cambios debemos cambiar a 3 y así todas las veces que hagamos un update.

El siguiente paso que tenemos que hacer es definir en una variable que llamaremos SQLUpdateV2 todas las consultas que necesitamos. En este caso como tenemos una tabla de libros vamos a añadirles una columna tipo int que llamaremos precio.

private String SQLUpdateV2 = "ALTER TABLE libros ADD COLUMN precio INT;

Una vez hemos definido esta consulta vamos a utilizar, para ello necesitamos sobreescribir el método onUpdate de la clase SQLiteOpenHelper de la que hereda la clase que estamos utilizando. Este método nos va dar dos parámetros esenciales, la versión anterior y la versión actual. Comparando estos dos parámetros debemos saber cuando ejecutar nuestra consulta de actualización. Veamos como:

@Override
public void onUpgrade(SQLiteDatabase db, int versionAnterior, int versionNueva) {
if(versionAnterior == 1 && versionNueva == 2){
db.execSQL(SQLUpdateV2);
}
}

Cuando solo tenemos dos versiones la cosa es más fácil. Simplemente comprobamos que la versión anterior es 1 y la nueva es 2. En ese caso ejecutamos nuestra actualización y listo.

Tened en cuenta que esto que se está ejecutando no nos tenemos que preocupar de ejecutarlo por nuestra cuenta ya que al heredar de la clase SQLiteOpenHelper, cuando creamos un objeto de nuestra clase se ejecutará automáticamente.

Vamos a complicar un poco más la cosa. Ya hemos realizado los cambios, subido la aplicación al market y hay gente que ya se la descargó y otra que no. Por lo tanto, hay gente con la versión 1 y gente con la versión 2. Y nos damos cuenta que tendríamos que haber dado un valor por defecto de 20 a los libros. Vamos otra vez a crear nuestra consulta de actualización. Pero esta vez le llamamos SQLUpdateV3.

private String SQLUpdateV3 = "UPDATE libros SET precio = 20;"

Y el método onUpdate debemos modificarlo de la siguiente forma. No os olvidéis de cambiar el parámetro versión a 3.

@Override
public void onUpgrade(SQLiteDatabase db, int versionAnterior, int versionNueva) {
if(versionAnterior == 1 && versionNueva >= 2){
db.execSQL(SQLUpdateV2);
}
if(versionAnterior >= 1 && versionNueva >= 3){
db.execSQL(SQLUpdateV3);
}

En este caso hemos cambiado un poco la condición para la actualización de la versión 2, serán aquellas cuya versión antigua sea la 1 y la nueva de la 2 en adelante, porque el usuario puede tener la 2 o la 3. Y para la actualización a la versión 3 serán aquellos que tengan la versión anterior 1 en adelante y la nueva debe ser la 3 en adelante.

Debemos hacerlo así por lo que os decía, una vez publicada en el market la app, perdemos el control de la versión de la base de datos que tiene la gente, puede haber gente que pase por todas las versiones de la base de datos y otras que salte de la 1 a la 3 sin pasar por la 2. Una vez que tenemos esto claro es muy fácil hacer actualizaciones en la base de datos de nuestra app.

Guía de instalación de FreeBSD (Parte II)

2012-11-27T00:00:00.000+01:00

En esta segunda entrega de la guía de instalación de FreeBSD vamos a instalar vim, versión mejorada (Vi IMproved) del conocido editor de texto vi, y configurarlo para que se comporte como el vim de Linux. También llevaremos a cabo las modificaciones necesarias para utilizar el mapa de teclado ISO-8859-15 (teclado español con símbolo del Euro).

Comencemos entrando en el sistema como usuario root. Esta es la pantalla de bienvenida:

En FreeBSD, la utilidad destinada a la instalación de paquetes es pkg_add. Instalemos vim (la opción -r le indica a pkg_add que descargue el paquete de los repositorios de FreeBSD):

Paquete instalado. Se nos muestra una advertencia de seguridad y el modo de subsanarla, añadiendo la línea set nomodeline al fichero de configuración de vim (~/.vimrc):

Agregamos dicha línea y otras tres para completar la configuración de vim:

set nocompatible (Evitar cambios inesperados por parte del sistema operativo)

set backspace=2 (Comportamiento de la tecla Retroceso: 2 = borrar carácter)

set tabstop=4 (La tecla Tab provoca un salto de 4 espacios)

El siguiente paso es configurar el mapa de teclado. Editamos el fichero /etc/rc.conf (# vim /etc/rc.conf) y comentamos la segunda línea, que en teoría está para que el mapa de teclado sea el español, pero que en la práctica no funciona. Para entrar en el modo de edición de vim pulsamos la tecla i ; vemos cómo aparece la palabra -- INSERT --. Luego añadimos las líneas marcadas en verde:

Para guardar los cambios, pulsamos la tecla Esc (saliendo así del modo de edición) y escribimos :x para grabar y salir.

A continuación editamos el fichero /etc/login.conf . Añadimos las dos líneas marcadas en verde:

Comentamos las cuatro líneas marcadas en rojo y salimos guardando los cambios:

Para generar una versión en forma de base de datos de /etc/login.conf (/etc/login.conf.db), mejorando así el rendimiento del sistema, ejecutamos el siguiente comando y reiniciamos el equipo:

Como podemos observar en la captura que viene a continuación, ya disponemos de vocales con tilde, letra ñ y símbolo del Euro:

Eso es todo. En la próxima entrega instalaremos X y GNOME, para poder disfrutar por fin de un entorno gráfico. Saludos!!!

SharedPreferences aún más fácil en Android

2012-11-21T13:06:00.002+01:00

Investigando un poco en una de mis librerías favoritas, ActionBarSherlock, encontré una forma de crear pantallas de configuración con muy poquito código. Si recordaís ya vimos algo de este tema en un artículo sobre las SharedPreferences. Vamos a tomar el ejemplo que nos da esta librería y lo veremos en detalle.

Las pantallas de configuración no tienen muchas opciones, pero con lo que nos ofrece es suficiente para la mayoría de cosas que podemos configurar. La primera diferencia con las pantallas que normalmente hacemos es que estas no se guardan en la carpeta layout, sino en la xml. Creamos la carpeta xml, dentro de res, y en xml creamos un archivo llamado preferences.xml.

<?xml version="1.0" encoding="utf-8"?>
<PreferenceScreen xmlns:android="http://schemas.android.com/apk/res/android">
    <PreferenceCategory android:title="@string/inline_preferences">

        <CheckBoxPreference
                android:key="checkbox_preference"
                android:title="@string/title_checkbox_preference"
                android:summary="@string/summary_checkbox_preference" />

    </PreferenceCategory>

    <PreferenceCategory android:title="@string/dialog_based_preferences">

        <EditTextPreference
                android:key="edittext_preference"
                android:title="@string/title_edittext_preference"
                android:summary="@string/summary_edittext_preference"
                android:dialogTitle="@string/dialog_title_edittext_preference" />

        <ListPreference
                android:key="list_preference"
                android:title="@string/title_list_preference"
                android:summary="@string/summary_list_preference"
                android:entries="@array/entries_list_preference"
                android:entryValues="@array/entryvalues_list_preference"
                android:dialogTitle="@string/dialog_title_list_preference" />
    </PreferenceCategory>
    <PreferenceCategory android:title="@string/launch_preferences">
        <PreferenceScreen
                android:title="@string/title_intent_preference"
                android:summary="@string/summary_intent_preference">
            <intent android:action="android.intent.action.VIEW"
                    android:data="http://www.android.com" />
        </PreferenceScreen>
    </PreferenceCategory>
    <PreferenceCategory android:title="@string/preference_attributes">

        <CheckBoxPreference
                android:key="parent_checkbox_preference"
                android:title="@string/title_parent_preference"
                android:summary="@string/summary_parent_preference" />
        <!-- The visual style of a child is defined by this styled theme attribute. -->
        <CheckBoxPreference
                android:key="child_checkbox_preference"
                android:dependency="parent_checkbox_preference"
                android:layout="?android:attr/preferenceLayoutChild"
                android:title="@string/title_child_preference"
                android:summary="@string/summary_child_preference" />
    </PreferenceCategory>
</PreferenceScreen>

Los elementos básicos de esta pantalla son los PreferenceScreen, las PreferenceCategory y los items con los que guardaremos nuestras configuraciones. La PreferenceScreen es la pantalla entera que se nos mostrará, donde se mostrarán el resto de elementos, y las PreferenceCategory nos permiten crear categorías o agrupaciones dentro de nuestra pantalla.

El elemento común a los diferentes items es que debemos definir la propiedad key. Esta va a ser la clave que se guarde en las SharedPreferences para luego poder recuperar los valores almacenados. También podemos darle un título con title y una descripción con summary.

Vamos a ver los elementos que podemos utilizar:

CheckBoxPreference, es un checkbox. En los dos últimos podemos ver un ejemplo de como un CheckBox depende de otro, diciéndole al segundo que depende del primero, este se activará o no según el valor del primero.
EditTextPreference, también muy simple. Un TextBox donde podemos ingresar un texto.
ListPreference, damos al usuario una serie de opciones predefinidas donde se puede escoger uno de los valores. Luego volveremos a ellos para ver como configurarlos.
RingtonePreference. Un item un tanto curioso, nos permite seleccionar una canción cualquiera de nuestro dispositivo.

Para poder configurar un ListPreference debemos crear un array con los valores que puede elegir el usuario. Para ello en la carpeta values dentro de res creamos un archivo llamado arrays.xml, y dentro de este incluimos todos los arrays que necesitemos.

<?xml version="1.0" encoding="utf-8"?>
<resources>
    <string-array name="entries_list_preference">
        <item>Alpha Option 01</item>
        <item>Beta Option 02</item>
        <item>Charlie Option 03</item>  
    </string-array>

    <string-array name="entryvalues_list_preference">
        <item>alpha</item>
        <item>beta</item>
        <item>charlie</item>  
    </string-array>
</resources>

Para indicar los valores de nuestro ListPreference seteamos las propiedades entries, que será el texto que se muestre al usuario, y entryvalues, que serán los valores que manejará internamente la aplicación. Aunque aquí se manejan dos arrays, si queréis, podéis utilizar uno solo en ambos valores.

Otra de las opciones que hay es insertar una PreferenceScreen dentro de otra. En nuestro ejemplo se inserta un Intent dentro de este para que elijamos que aplicación vamos a utilizar para abrir un navegador.

Vamos ahora a ver como mostrar nuestra pantalla de configuración, simplemente creamos una nueva clase llamada Preference que será muy similar a una Activity salvo que heredará de SherlockPreferenceActivity. Acordaros de definirla igual que cualquier otra Activity en el archivo AndroidManifest.xml.

public class Preference extends SherlockPreferenceActivity {    
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        addPreferencesFromResource(R.xml.preferences);
    }
}

Como veis es como una Activity salvo por la herencia y que en vez de hacer un setContentView llamamos a addPreferencesFromResource y le indicamos nuestro archivo de configuración. Al haber heredado de esta clase no tendremos que hacer nada más, sencillo ¿no?

Cada vez que entremos la configuración ya estará cargada correctamente, y para guardar simplemente seleccionamos un valor en cualquiera de nuestros items de configuración y se guardará automáticamente.

Por último, vamos a ver como podemos obtener los valores configurados desde cualquier sitio de nuestra aplicación. Simplemente creamos un objeto de tipo SharedPreferences y obtenemos el valor correspondiente, en este caso el que tiene la key "edittext_preference".

SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(Context);
String valor = prefs.getString("edittext_preference", "valor por defecto");

Para este artículo he seguido el ejemplo que ActionBarSherlock pone a nuestra disposición en su cuenta de Github.com. No he incluido los valores @string de todos los componentes porque, además de no ser el punto importante de este artículo, los podéis encontrar en el lugar indicado o sino sustituirlos vosotros por los que se os antoje.

Espero que mi primera entrada con el nuevo diseño, os resulte más amena y fácil de leer. Como siempre estamos encantados de leer vuestros comentarios y saber que opináis para seguir mejorando.

Escrito por 3pies, desarrollo de aplicaciones móviles Android & web

Guía de instalación de FreeBSD (Parte I)

2012-11-20T20:37:00.000+01:00

FreeBSD es un sistema operativo libre basado en la variante 4.4 BSD-Lite del UNIX de Berkeley (Universidad de California). Es multiusuario, multitarea y multiproceso, y funciona con procesadores Intel, AMD y Cyrix entre otros, tanto en arquitecturas de 32 como de 64 bits. Además, es compatible con los ejecutables binarios de GNU/Linux.

En esta primera parte de la guía aprenderemos a instalar FreeBSD en nuestro disco duro; dicha instalación se lleva a cabo en modo texto, lo que nos recordará en cierto modo a Slackware o Arch Linux. La imagen ISO adecuada para nuestro equipo la podemos encontrar en los siguientes enlaces:

32 bits: FreeBSD-9.0-RELEASE-i386-dvd1.iso
64 bits: FreeBSD-9.0-RELEASE-amd64-dvd1.iso

Una vez preparado el medio de instalación, configuramos el equipo para que arranque desde el lector de DVD. En la siguiente captura observamos el comienzo del proceso de carga:

A continuación se nos presenta una pantalla de bienvenida con varias opciones. Para iniciar la instalación del sistema operativo basta con pulsar 1 ó ENTER:

Antes de proceder, es necesario aclarar que en los sucesivos menús utilizaremos los CURSORES para desplazarnos por ellos, la BARRA ESPACIADORA para seleccionar/deseleccionar elementos y la tecla ENTER para confirmar los cambios realizados. Comenzamos presionando ENTER:

¿Vamos a especificar un mapa de teclado? Sí:

Teclado español con símbolo del Euro (ISO-8859-15):

Le damos un nombre al equipo:

Seleccionamos componentes opcionales; en este caso, sólo la colección de ports (un port se utiliza para instalar una aplicación mediante la compilación de su código fuente, en contraposición al package, que consiste en la instalación de los binarios ya compilados, tal y como sucede con el apt-get install de Ubuntu):

Es el momento de particionar el disco duro. Vamos a hacer un particionado manual:

Observamos un sólo disco de 15 GB sin particiones. La nomenclatura cambia con respecto a Linux; el primer disco duro pasa de ser /dev/sda a /dev/ada0 :

Lo primero es crear la tabla de particiones. Hay varias clases; quizá la más adecuada (por moderna y flexible) sería GPT, pero utilizaremos la clásica MBR:

Tabla de particiones satisfactoriamente creada:

En el siguiente paso encontramos otra diferencia con Linux; en Linux asignamos directamente cada partición creada a una parte del sistema de ficheros, por ejemplo:

/dev/sda1 para /
/dev/sda2 para /home
/dev/sda3 para swap

En FreeBSD es necesario crear primero una partición maestra o slice de tipo freebsd, que contendrá el sistema de ficheros al completo. Si queremos utilizar el disco entero, el slice tendrá su mismo tamaño:

El slice (s1) ha sido creado:

Ahora ya podemos aplicar la metodología propia de Linux en lo que a particionado se refiere. Creamos 4 particiones, una de 2 GB para el directorio raíz / :

Una de 1 GB para el área de intercambio swap :

Una de 1 GB para el directorio /var :

Una de 1 GB para el directorio /tmp :

Y una de 10 GB para el directorio /usr , que es el que más volumen de ficheros va a soportar (en FreeBSD, la localización real de /home es /usr/home):

Aquí está el resultado; cuatro particiones a,d,e,f de tipo freebsd-ufs (lo que vendría siendo ext2 en Linux) y una partición b de tipo freebsd-swap, todo dentro de un único slice s1. ¿Por qué no está la partición c? Porque la letra c se utiliza para representar el espacio libre en disco... curiosidades o caprichos de los de Berkeley:

Pulsamos Finish y luego Commit para llevar a cabo los cambios:

Instalando paquetes:

Paquetes instalados. Se nos pide una contraseña para el usuario root:

Configuración de los dispositivos de red. En este caso tenemos un único dispositivo em0:

¿Queremos configurar el protocolo IP versión 4? Sí:

¿Utilizar DHCP para obtener la IP? Sí:

¿Configurar el protocolo IP versión 6? No:

Direcciones IP de los servidores DNS (ya obtenidas mediante DHCP):

Pasamos al siguiente punto de la instalación, la configuración de la zona horaria. No vamos a utilizar UTC, ya que seleccionaremos el huso horario correspondiente a nuestra localización geográfica:

Europa:

España:

Península:

Abreviatura para el huso horario seleccionado. CET o Central European Time (Francia, Alemania, Italia, España, etc):

Servicios que se iniciarán con el arranque del sistema. Por defecto sólo se inicia el shell seguro sshd, pero vamos a añadir otro servicio, moused, encargado del ratón:

Si por cualquier motivo el sistema se vuelve inestable y queremos ayudar a los programadores de FreeBSD a identificar el problema, podemos habilitar el volcado (o no):

¿Creamos un usuario estándar? Sí:

Como podemos observar en la siguiente captura, se nos solicita diversa información acerca del usuario a crear, pero con introducir el nombre de inicio de sesión y la contraseña nos bastará:

Confirmamos la información introducida y, si lo deseamos, agregamos otro usuario (en este caso no):

Aplicamos la configuración y salimos del instalador:

¿Necesitamos llevar a cabo alguna otra configuración manual a través del terminal? Negativo:

Reiniciamos el sistema:

Y, por fin, pantalla de login:

¿Y cómo se apaga el equipo? Con el comando poweroff:

¡Proceso completado! De todos modos, llegado este punto el sistema puede parecer poco útil, sobre todo por la ausencia de un entorno gráfico al que tan acostumbrados estamos. Por ello, en las siguientes entregas de esta guía llevaremos a cabo algunas configuraciones básicas, así como la instalación de X y GNOME.

Como ya habréis observado, FreeBSD no es tan intuitivo como Ubuntu u otras distribuciones de GNU/Linux, pero es un buen campo de aprendizaje para quienes quieran profundizar en el terreno de los sistemas operativos libres, o incluso utilizarlo como sistema principal, aunque quizá esté más orientado a funcionar como servidor.

Un saludo.

qBittorent, un completo y liviano cliente BitTorrent

2012-11-19T16:00:00.000+01:00

Durante varios años he venido probando diferentes clientes BitTorrent desde la correspondiente versión de GNU/Linux, y sobre todo desde que me decidí a usar Ubuntu como sistema operativo. Los que he probado hasta el día de hoy han sido KTorrent, Deluge, Transmission y uTorrent, aunque finalmente me he decidido por qBittorrent.

Hasta no hace mucho venía usando uTorrent principalmente por su velocidad, pero tras probar qBittorrent, he encontrado mi cliente de descargas para este protocolo, ya que me da la misma velocidad además de otras funcionalidades, pero usando una herramienta de Software Libre, desarrollada por voluntarios y que no tiene nada que envidiarle.

Este ligero cliente Bittorrent es una aplicación escrita en Qt4, y basado en la librería libtorrent-rasterbar, y entre sus características, además de la velocidad, ya mencionada podemos destacar:

Una interfaz muy similar a la de este tipo de clientes, donde hay una clasificación de los torrents según su estado (Descargando, Completados, etc.), aunque nos permite añadir etiquetas con la que realizar nuestra propia clasificación.

Buscador de torrents integrado, en el que localizar lo que necesitemos sin necesidad de acudir al navegador u otros complementos, pudiendo además añadir otros motores de búsqueda. Además el buscador nos permite elegir categorías como 'Juegos', 'Vídeos' o 'Libros' con las que los resultados son más precisos.

Lector RSS, una opción muy interesante para estar al día de las novedades, y que podemos personalizar con diferentes reglas, programando así las descargas de las novedades que en realidad queremos.

Interfaz web con la que controlar las descargas desde cualquier lugar de manera remota.

Además de esto, incorpora otra serie de funcionalidades que son comunes a la mayoría de clientes como:

Es posible añadir torrents directamente desde la URL.
Soporta todas las extensiones Bittorrent como: DHT, Peer Exchange, Full encryption, Magnet/BitComet URIs, ...
Posibilidad de limitar velocidad de descarga/subida, además de la prioridad.
Soporte para redirecionamiento de puertos UPnP/NAT-PMP.
Permite la creación de nuestros propios Torrents , o la selección de archivos a descargar dentro de uno.
Soporte para filtrado de IP.

Si tras esto quieres probar esta interesante aplicación bastará con:

sudo apt-get install qbittorrent

Para obtener más información acerca de ella, nada mejor que acceder a la web oficial del proyecto, donde podrás encontrar su propio foro, el repositorio git o una wiki de ayuda, además de la posibilidad de descargar el código fuente o el binario de instalación para tu distribución preferida.

Saludos.