Tabla de multiplicar para SAP ABAP IV

0 comentarios

De todo hay que aprender y nada puede detenernos, ahora estoy estudiando algo de ABAP IV, como muestra os voy a dejar una tabla de multiplicar realizada bajo SAP ABAP IV.

SAP nos solicita de que numero solicitamos la tabla de multiplicar, tras ello hacemos un bucle para imprimir las diez multiplicaciones necesarias.

*&---------------------------------------------------------------------*
*& Report  Z_LIEM_TEST
*&
*&---------------------------------------------------------------------*
*&
*& El programa solicita un numero y muestra su tabla de multiplicar
*&---------------------------------------------------------------------*

REPORT  z_liem_test.

DATA resultado TYPE string.
DATA multi(17) TYPE c.

SELECTION-SCREEN BEGIN OF BLOCK b1 WITH FRAME.
PARAMETERS p_params TYPE i.
SELECTION-SCREEN END OF BLOCK b1.

IF p_params IS INITIAL.
  WRITE 'No se ha indicado de que tabla quiere'.
ELSE.
  WRITE p_params TO multi.
  DO 10 TIMES.
    DATA index(17) TYPE c.
    DATA res(17) TYPE c.
    DATA resu TYPE i.
    resu = sy-index.
    WRITE sy-index TO index.
    MULTIPLY resu BY multi.
    WRITE resu TO res.
    CONCATENATE index ' * ' multi ' = ' res INTO resultado.
    CONDENSE resultado.
    WRITE resultado.
    SKIP.
  ENDDO.
ENDIF.


Como podemos ver es mucho código para este solo proceso, pero es un primer acercamiento al código  seguiremos haciendo cosas para SAP ABAP IV :)

Crear un "Splash Screen" sencillo en Android

0 comentarios

Ahora vamos a intentar de crear un "splash screen" sencillo para Android. Un "splash screen" o pantalla de acogida no es más que un texto, imagen o programa liviano que cargamos a la espera de cargar todo el contenido completo de nuestro programa.

Este tipo de programas son creados con la clara idea de publicitar la empresa y/o amenizar la espera durante los tiempos de carga, de ahí que haya dicho programa liviano.

Bien, vamos al grano, yo este lo he realizado con un proyecto completamente limpio denominado "SplashScreen", para el que no lo recuerde puede encontrar como crear un proyecto en mi publicación programando Android en Ubuntu 11.10 (II) en la parte final.

Ahora tenemos que comenzar a configurar la actividad referente a nuestro "splash screen", para ello comenzaremos por el XML que contendrá los datos que usaremos en esta actividad, este fichero que yo he denominado "splash_activity.xml" tiene que estar situado en "/SplashScreen/res/layout".

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

<TextView 
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:gravity="center"
    android:textSize ="18sp"
    android:text="@string/hello_world_2"
    />
</LinearLayout>

Ya que estamos en la carpeta nos aseguramos de que tengamos un XML para la actividad principal, este no hará falta tocarlo, pero por si acaso, su contenido tendría que tener esta forma si hace o no hace.

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

<TextView 
    android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_centerHorizontal="true"
        android:layout_centerVertical="true"
        android:text="@string/hello_world"
        tools:context=".MainActivity"
    />
</RelativeLayout>

Ahora tenemos que editar el "AndroiManifest.xml" para que contemple la nueva actividad que tiene que hacer, podéis encontrar una descripción más detallada del "AndroidManifest.xml" en mi entrada AndroidManifest.xml, que es y para que sirve en este mismo blog. Tal y como explique en este fichero pondremos cualquier actividad, servicio, etc. que necesitemos ejecutar, de esta manera podremos ver como nos quedaran dos actividades prácticamente iguales la una a la otra.

<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="lfr.liem.dazkun.test.android.splashscreen"
    android:versionCode="1"
    android:versionName="1.0" >

    <uses-sdk
        android:minSdkVersion="8"
        android:targetSdkVersion="15" />

    <application
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name"
        android:theme="@style/AppTheme" >
        <activity
            android:name=".SplashScreen"
            android:label="@string/title_activity_main" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
        <activity
            android:name=".MainActivity"
            android:label="@string/title_activity_main" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

                <category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

</manifest>

Ahora vamos a los ficheros Java que tenemos en la carpeta "src", tenemos que tener dos ficheros, el "MainActivity.java" y el "SplashScreen.java", fijaros que los nombres coinciden con los que asignamos en el "AndroiManifest.xml" en la parte de " android:name=".MainActivity""  y "android:name=".SplashScreen"". 
El fichero Java principal en un principio no hay que tocarlo, es más, si lo tocáis corre por vuestra propia cuenta y riesgo. De manera que veamos que es lo que sucede con el "SplashScreen.java" que es el que se iniciara en primera instancia.

package lfr.liem.dazkun.test.android.splashscreen;

import android.app.Activity;
import android.content.Intent;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;

public class SplashScreen extends Activity {

 /** Se le llama cuando la actividad es creada por primera vez*/
    @Override
    public void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);
        
        //Creamos un objeto de tipo SplashHandler
        SplashHandler mHandler = new SplashHandler();
        //Le seteamos cual es el XML va a usar como configurador de la actividad
        setContentView(R.layout.splash_activity);
        //Creamos un objeto de tipo Message
        Message msg = new Message();
        //Asignamos un codigo unico al mensaje
        //Despues este codigo sera utilizado para identificar el mensaje.
        msg.what = 0;
        //Enviamos el mensaje que durara 3 segundos (3000 = 3 seg)
        mHandler.sendMessageDelayed(msg, 3000);
    }     
    
    //La clase Handler implementa 'handle' el manejador de los mensajes
    private class SplashHandler extends Handler {
        
     //Este metodo se usa para manejar los mensajes recibidos. 
        public void handleMessage(Message msg)
          {

            final Intent intent = new Intent();
            //switch del identificador del mensaje segun su codigo
            switch (msg.what) {
            case 0:
             super.handleMessage(msg);
             //Creamos un intent para arrancar la actividad
             //Nuestra intención es comenzar MainActivity
             intent.setClass(SplashScreen.this,MainActivity.class);
             startActivity(intent);
             // finalizamos la actual actividad
             SplashScreen.this.finish();
             break;
            default:
             //Duplicamos el codigo por que solo tenemos un splash screen
             //si tuvieramos alguno que tuviera que salir en caso de fallo lo pondriamos aquí
                super.handleMessage(msg);
                intent.setClass(SplashScreen.this,MainActivity.class);
                startActivity(intent);
                SplashScreen.this.finish();
                break;
            }
          }
    }    
   

}

El onCreate es como el que tendremos en cualquiera de nuestras actividades, sencillamente inicializa y llama a su XML el cual contendrá el texto que visualizaremos y la asignación del mensaje que visualizaremos.

El objeto Handler es un controlador de mensajes que nos enviara el mensaje durante tres segundos.

La clase SplashHandler lo que hace es crear un nuevo hilo que mostrara el nuestra pantalla de inicio, el objeto Intent se ocupara de realizar la transición desde nuestro "SplashScreen" a nuestra clase principal, startActivity(intent); arrancaria esa actividad mientras que SplashScreen.this.finish(); haría que nuestra actividad finalizara. El codigo se ha repetido dos veces aunque no sea necesario, pero en toda clausula "switch" tiene que haber una opción "default:" y no quería dejarla en blanco.

Instalar SubVersion en Ubuntu server 12.04

0 comentarios

Una de las herramientas más básicas para todo programador es un controlador de versiones, uno de los más conocidos o como mínimo el único que me he encontrado en mi trabajo diario es el SVN.

Se trata de una herramienta opensource con un gran potencial y muy estable, podéis encontrar muchas más información sobre el en su pagina principal: http://subversion.tigris.org/.

Para instalar el servidor de subversion o SVN como prefiráis,  solo tenemos que hacer un par de cosas. Partamos de que estoy utilizando una maquina virtual con el Ubuntu Server 12.04 instalada, prácticamente sin nada más, solo el Xfce que ya le instale en la entrada "Como instalar Xfce en Ubuntu Server 12.04 lts" por si queréis dejar el entorno tal y como yo lo tengo.


Ahora solo tenemos que instalar lo que serian los paquetes básicos del subversion, para ello introduciremos la siguiente linea:



sudo aptitude install subversion subversion-tools



Bien, lo siguiente que tenemos que comprobar es que tenemos instalado los módulos dav y dav_svn y para ello tenemos que introducir los comandos:


a2enmod dav
a2enmod dav_svn

Si los tenemos instalados tendríamos que ver una pantalla como esta:



Si alguno de los dos modulos no esta instalado solo tendremos que instalar una cosilla más en nuestro servidor.


sudo aptitude install libapache2-svn


Ahora que ya lo hemos instalado volveremos a comprobar si ya funcionan los comandos, personalmente no he detectado ningún error más hasta este punto pero si alguien lo tiene que me lo haga saber e intentare reproducir el error en mi maquina para daros una solución.


Bien, el sistema de control de versiones SVN ya esta instalado en vuestras maquinas, si queréis mirar si la instalación ha sido satisfactoria solo tenéis que escribir:



svnadmin help

Como instalar Xfce en Ubuntu Server 12.04 lts

4 comentarios

Cuando tienes que virtualizar servicios por la comodidad del transporte te encuentras con la necesidad de no ocupar mucha memoria, lo cual acostumbra a ser un inconveniente en un mundo tan acostumbrado al entorno gráfico ya que este ocupa mucho en memoria, asimismo las versiones "desktop" acostumbran a incorporar mucho software que no hace falta y/o nos distrae de nuestro objetivo.

A la hora de virtualizar sistemas operativos suelo decantarme por Oracle VirtualBox el cual es compatible con Windows, OS X, Solaris y Linux, su gran versatilidad es lo que hace que me decante por el, amén de que es el mejor a mi parecer por su facilidad y robustez.

El sistema operativo que he elegido es el Ubuntu Server 12.04 lts, se que no es el más liviano de todos los que existen, los hay como Tiny core Linux que ocupan solo 11Mb y que serian una perfecta elección para cualquier equipo con pocos recursos o incluso una maquina virtual, pero mi elección se basa en que necesitaba una maquina para usarla como servidor y ya de paso ponerle el SVN, la idea es clara, tener un control de todo el código creado y no perderlo en uno de mis muchos formateo amén de la utilización de varios ordenadores y SO.

Pero Ubuntu Server, como todo buen servidor, no dispone de parte gráfica de manera con la que trabajar, lo que si que dispone es del basto universo de software del que hay en su repositorio, de manera que para instalar el Xfce solo tenemos que seguir estos simples pasos.


  1. Activar el repositorio "universe" en caso de que no lo este, para ello tenemos que comprobar que las siguientes dos lineas existen en el fichero "/etc/apt/sources.list"

deb http://es.archive.ubuntu.com/ubuntu/ precise universe
deb-src http://es.archive.ubuntu.com/ubuntu/ preciseuniverse
  1. Actualizar los repositorios

sudo apt-get update
  1. Instalar los packages necesarios para poner el sistema grafico

sudo apt-get install wdm x-window-system-core xfce4
  1. Durante la instalación es posible que nos solicite el tamaño de la pantalla, esto ya va a gustos.
  2. Y ahora para comenzar a utilizarlo solo tenemos que escribir es “startx”
Solo le he encontrado una pega a este método y es que sobrecarga el arranque al añadir el GRUB y que siempre se me va al sistema gráfico en lugar de quedarse en consola a la espera de que yo decida de activar el sistema gráfico. Pero no pasa nada, otra cosa con la que picarme sanamente, el próximo paso lógico tras terminar de montar todo el servidor sera desactivar el auto arranque del modo gráfico.

Ampliar memoria en el WebLogic

0 comentarios

Esto es algo que siempre olvido y termino recurriendo a Google para averiguarlo.

Para ampliar la memoria lo primero que tenemos que hacer es localizar desde que directorio se ejecuta. Pensad que el WebLogic no tiene que estar instalado necesariamente en la misma ruta que la ejecución de nuestro proyecto, por ejemplo, mi servidor se encuentra en "c:\ORACLE\Middleware\wls1211\wlserver\server\" mientras que la ejecución de mi proyecto se encuentra en "c:\ORACLE\Middleware\user_projects\domains\Cartera\startWebLogic.cmd" a partir de este fichero nos encontraremos la manera de llegar al fichero "real" de ejecución.

Normalmente este fichero suele tener la siguiente estructura.

@ECHO OFF

@REM WARNING: This file is created by the Configuration Wizard.
@REM Any changes to this script may be lost when adding extensions to this configuration.

SETLOCAL

set DOMAIN_HOME=C:\ORACLE\Middleware\user_projects\domains\Cartera

call "%DOMAIN_HOME%\bin\startWebLogic.cmd" %*



ENDLOCAL



En caso de que usemos Linux tendremos algo parecido a lo siguiente
#!/bin/sh

# WARNING: This file is created by the Configuration Wizard.
# Any changes to this script may be lost when adding extensions to this configuration.

DOMAIN_HOME="C:/ORACLE/Middleware/user_projects/domains/Cartera"

${DOMAIN_HOME}/bin/startWebLogic.sh $*





Si nos fijamos en ambos casos nos redirecciona a la carpeta de instalación. Esto hace que este fichero sea una mera plataforma para arrancar el sistema ya que setea en ambos ficheros la misma dirección.

En el siguiente fichero tenemos el grueso del asunto, el como se va a cargar todo lo que tenemos relacionado con WebLogic. Y lo que no pone es lo que más nos interesa en este momento, hay una variable  muy importante que es "MEM_ARGS", esta variable que no esta bien definida en el fichero es la responsable de que podamos ampliar la memoria con la que arrancamos.

Para inicializarla solamente le tenemos que poner la siguiente linea dentro del fichero, indistintamente de que tratemos con el "bat" o el "sh".

set MEM_ARGS=-Xms512m -Xmx1024m -XX:CompileThreshold=8000 -XX:PermSize=64m -XX:MaxPermSize=256m


Y de esta manera nos cargara con la memoria que le indicamos.


AndroidManifest.xml, que es y para que sirve.

0 comentarios

Ahora que ya lo tenemos todo instalado lo siguiente seria saber que es lo que sucede cuando creamos un nuevo proyecto, como ya hemos visto una vez que creamos el proyecto se nos crea una serie de carpetas y ficheros esenciales para la ejecución de cualquier proyecto, el fichero que nos ocupa hoy es el AndroidManifest.xml el principal fichero para la creación de cualquier proyecto, sea del tamaño que sea.

El fichero se encuentra en la raíz de cualquier proyecto. Dentro de  AndroidManifest.xml podemos declarar todo lo que pueda suceder en nuestra aplicación, tales como las actividades, los servicios y demás, y la manera en que interactúan entre ellos y con el sistema. En este podríamos indicar que actividad es la que aparecerá en el menú principal del dispositivo, también conocido como "launcher".

Cuando creamos el proyecto se nos genera automáticamente el AndroidManifest.xml con la estructura básica para un programa básico; con la declaración de una actividad y nada más. Según aumente la dificultad de nuestro programa el AndroidManifest.xml aumentara de lineas de código y por ende aumentara en declaraciones.

La  estructura de este fichero esta basado en el  XML v1.0 y lo tenemos que encapsular en UTF-8. El elemento raíz de todo los archivos es, obviamente, un elemento "manifest"
<manifest android:versioncode="1" android:versionname="1.0" package="lfr.liem.dazkun.test.android.helloandroid" xmlns:android="http://schemas.android.com/apk/res/android">

    <uses-sdk android:minsdkversion="4">

    <application android:icon="@drawable/ic_launcher" android:label="@string/app_name">
        <activity android:label="@string/app_name" android:name=".HelloAndroidActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN">

                <category android:name="android.intent.category.LAUNCHER">
            </category></action></intent-filter>
        </activity>
    </application>

</uses-sdk></manifest>
Uno de los datos más importantes que debemos indicar en la declaración del manifiesto es el del atributo "package" el cual corresponde al espacio de nombres que definimos en el momento de la creación del proyecto. En el código que ya realizamos anteriormente tenemos que el package es "lfr.liem.dazkun.test.android.helloandroid", el cual indica el nombre del paquete Java que contiene el elemento raíz de nuestra aplicación, o lo que es lo mismo, la actividad principal de arranque que necesitamos para que inicie siempre antes que las demás.
Posteriormente pasaremos a declarar cada una de las actividades, para ello deberemos seguir una convención de nombres, la convención consiste en poner el nombre de la clase Java que representa la "Activity" y anteponerle un punto al nombre. Por ejemplo, en nuestro caso la actividad que necesitamos ejecutar es "liem.dazkun.test.android.helloandroid.HelloAndroidActivity.java" y por ello en el tag "activity" tendríamos que poner el android:name como ".HelloAndroidActivity" quedando de la siguiente manera.

<application android:icon="@drawable/ic_launcher" android:label="@string/app_name">
        <activity android:label="@string/app_name" android:name=".HelloAndroidActivity">
            <intent-filter>
                <action android:name="android.intent.action.MAIN">

                <category android:name="android.intent.category.LAUNCHER">
            </category></action></intent-filter>
        </activity>
    </application>

Esto sucede de esta manera por que en la parte de "package" ya hemos puesto como root la parte principal "lfr.liem.dazkun.test.android.helloandroid" prácticamente se podría decir que el package + el activity te tiene que dar la ruta completa del paquete que se va a ejecutar..

Dentro del AndroidManifest.xml se pueden implementar también permisos, dispositivos y aplicaciones para ello existen los siguientes elementos que se pueden implementar en el AndroidManifest.xml.

  • uses-permission: Con este elemento se pueden declarar los permisos que necesitará nuestra aplicación para funcionar correctamente. Para ello podemos encontrar permisos para acceder al GPS del teléfono así como a los datos de localización para realizar las funciones.
  • permission: Este elemento declara los permisos que las actividades o servicios necesitan para poder mantener el correcto uso de los datos de la aplicación y ya de paso mantener la lógica de la misma.
  • instrumentation: Con este elemento lo que buscaremos es la declaración del código que deberá ser invocado cuando un evento clave del sistema sea llamado por el usuario, tales como el arranque de una actividad como podría ser el logueo o monitoreo.
  • application: Esta es la piedra angular de todo nuestro proyecto en el definiremos las entrañas de nuestro programa (nombre, actividad principal, icono, etc.) que el archivo  AndroidManifest.xml  describe.
Existen una estructura mucho más amplia que se puede implementar, aunque estos son los básicos. La lista completa seria la siguiente.

<manifest>

    <uses-permission>
    <permission>
    <permission-tree>
    <permission-group>
    <instrumentation>
    <uses-sdk>
    <uses-configuration>  
    <uses-feature>  
    <supports-screens>  
    <compatible-screens>  
    <supports-gl-texture>  

    <application>

        <activity>
            <intent-filter>
                <action>
                <category>
                <data>
            </data></category></action></intent-filter>
            <meta-data>
        </meta-data></activity>

        <activity-alias>
            <intent-filter> . . . </intent-filter>
            <meta-data>
        </meta-data></activity-alias>

        <service>
            <intent-filter> . . . </intent-filter>
            <meta-data>
        </meta-data></service>

        <receiver>
            <intent-filter> . . . </intent-filter>
            <meta-data>
        </meta-data></receiver>

        <provider>
            <grant-uri-permission>
            <meta-data>
        </meta-data></grant-uri-permission></provider>

        <uses-library>

    </uses-library></application>

</supports-gl-texture></compatible-screens></supports-screens></uses-feature></uses-configuration></uses-sdk></instrumentation></permission-group></permission-tree></permission></uses-permission></manifest>

Aparte cada uno de los tags puede contener sus propios parámetros e incluso contener algún nivel más, por ejemplo el tag "Action" solo contiene un parámetro, android:name, pero si miramos el tag "Activity" tendriamos todos estos parametros.

<activity android:allowTaskReparenting=["true" | "false"]
          android:alwaysRetainTaskState=["true" | "false"]
          android:clearTaskOnLaunch=["true" | "false"]
          android:configChanges=["mcc", "mnc", "locale",
                                 "touchscreen", "keyboard", "keyboardHidden",
                                 "navigation", "screenLayout", "fontScale", "uiMode",
                                 "orientation", "screenSize", "smallestScreenSize"]
          android:enabled=["true" | "false"]
          android:excludeFromRecents=["true" | "false"]
          android:exported=["true" | "false"]
          android:finishOnTaskLaunch=["true" | "false"]
          android:hardwareAccelerated=["true" | "false"]
          android:icon="drawable resource"
          android:label="string resource"
          android:launchMode=["multiple" | "singleTop" |
                              "singleTask" | "singleInstance"]
          android:multiprocess=["true" | "false"]
          android:name="string"
          android:noHistory=["true" | "false"]  
          android:permission="string"
          android:process="string"
          android:screenOrientation=["unspecified" | "user" | "behind" |
                                     "landscape" | "portrait" |
                                     "reverseLandscape" | "reversePortrait" |
                                     "sensorLandscape" | "sensorPortrait" |
                                     "sensor" | "fullSensor" | "nosensor"]
          android:stateNotNeeded=["true" | "false"]
          android:taskAffinity="string"
          android:theme="resource or theme"
          android:uiOptions=["none" | "splitActionBarWhenNarrow"]
          android:windowSoftInputMode=["stateUnspecified",
                                       "stateUnchanged", "stateHidden",
                                       "stateAlwaysHidden", "stateVisible",
                                       "stateAlwaysVisible", "adjustUnspecified",
                                       "adjustResize", "adjustPan"] >  
</activity>

Pero esto es algo que veremos poco a poco, la verdad es que es mucha información en demasiado poco tiempo. Tened en cuenta que a traves de este fichero se tiene que codificar desde un simple popup, hasta un programa que se alimente de un webservice e imprima de manera remota en una impresora wifi.

Programando Android en Ubuntu 11.10 (II)

0 comentarios

Ahora que ya tenemos instalado el SDK de Android instalado tenemos que pasar al Eclipse para configurar todo y que funcione, si no de nada serviría todo esto ¿no?.

Lo primero que tenemos que hacer es cargar el Eclipse y desde allí irnos a la instalación de software que nos encontramos en la ruta: Help --> Install New Software 


Le damos a "Add..." e introducimos con el nombre ADT Plugin y la URL que nos facilita Google, que a día de hoy seria https://dl-ssl.google.com/android/eclipse/


Una vez introducida y esperar un poco podremos ver todo lo que se puede instalar de esta URL, lo seleccionamos todo y le damos a siguiente "next".


Puede ser que todo falle, como ha sido mi caso y veamos la siguiente pantalla.


Bien, si esto sucede lo que tenemos que hacer es instalar el marketplace de eclipse, parece una tontería, pero tarde casi una semana en averiguarlo :s, intente instalar el WTS, el equinox y un montón de cosas más pero todas con el mismo fallo de antes. Para poder instalar el marketplace solo tenemos que acceder al install como ya hemos hecho y seleccionar el repositorio "Indigo", en caso de no tenerlo es el  "http://download.eclipse.org/releases/indigo/" cuando haya cargado todo tenemos que instalar General Purpose Tools --> Marketplace Client.

Bien ahora que ya tenemos el marketplace instalado reiniciamos y volvemos a empezar con la instalación del "ADT Plugin", ahora sí que sí que nos saldrá la siguiente imagen, la aceptamos como es obvio y seguimos hacia delante.

Pero no todo es de color de rosa, por lo visto los sdk de Google no están firmados, pero como somos chicos listos y las urls las hemos buscado nosotros mismos, podemos fiarnos, de manera que cuando nos aparezca la siguiente imagen la aceptamos sin dudarlo.


Tras la instalación el Eclipse nos pedirá que reiniciemos, como no queda otra pues reiniciamos y todos tan felices :). Bien, ya hemos reiniciado, ahora nos aparecerá la siguiente pantalla, si en lugar de hacer lo que yo voy a mostrar aquí pusiéramos en la parte de abajo la ruta en la que hemos instalado los SDK todo hubiera terminado, pero si lo hiciéramos, todo seria demasiado fácil, de manera que haremos todos los pasos.

Lo interesante de esto es que haciéndolo de la segunda manera nos encontramos que la primera parte de este mini manual (programando android en Ubuntu) ha sido del todo innecesaria, pero lo suyo es aprender, no escribo esto para nadie lo escribo para aprender yo y al final todo suma.


Bien, vamos a seleccionar el primer checkbox, y ya de paso como la versión 4.0 de Android solo esta en unos muy pocos terminales vamos a descargar la versión 2.1 que esta en alguna más. Podemos modificar la ruta en la que vamos a instalar todo, pero vamos cuanto más estándar sea todo mucho mejor, sobretodo a la hora de buscar información y ayuda.


Bueno, tal y como podemos observar en la imagen, aquí también nos pide que demos nuestro apoyo y estadísticas a Google, aquí ya cada uno a mi no me importa enviárselo, total, lo único que hago es programar.


Bien, una vez lo tengamos si nos vamos a window --> preferences --> Android podemos modificar el directorio desde el que trabajamos. Voy a poner el que hemos puesto en la primera parte para que de esta manera sirva para algo lo que hicimos hace poco más de una semana.


Ahora lo único que nos queda es comprobar que toda la instalación es correcta, para eso lo mejor que tenemos es hacer un "HelloWorld". Para eso nos creamos un nuevo proyecto en File --> New --> Project... seleccionamos el tipo Android --> Android Project tal y como se muestra en la siguiente pantalla.


Tras pulsar en " Next > " nos aparecerá, tenemos varias opciones dentro de la pantalla, pero como se trata de una prueba sin más podemos dejarlo todo tal y como viene de serie. En la zona de "Project Name" ponemos el nombre que le queremos dar al proyecto, como va a ser un simple hola mundo le ponemos un nombre acorde a lo que vamos a hacer. En mi caso en lugar de saludar al mundo saludo a Android, que me hace más caso. 


Bien, tras pasar la pantalla nos veremos en una ventana que nos preguntara sobre que arquitectura queremos trabajar, tengamos en cuenta que cada plataforma tiene sus peculiaridades y sus beneficios, en este caso como solo es un hola mundo pues lo compilare con la 1.6, luego ya lo ejecutare donde quiera gracias a la retro compatibilidad de la que se goza en el SO.


Cuando le demos a siguiente nos pedirá que le pongamos el nombre de la aplicación, el nombre del paquete y que seleccionemos cual es el mínimo de SDK que va a requerir nuestro programa. En este caso para poder averiguar cual es el nivel de cada SDK tenemos que fijarnos en el paso anterior, solo como guia la 1.6 es el lvl 4, la versión 2.3 es el lvl 10 y la versión 4.0 es el lvl 15.


Bien, el nombre del paquete lo podemos escribir como queramos, pero cierto es que si queremos seguir la convención tenemos que escribirlo en minusculas.


Bien, ahora para poder hacer un hola mundo tenemos que buscar el HelloAndroidActivity que se encontraría en [Application Name]/src/[Package Name]/[Application Name]Activity.java


Una vez lo tengamos cargado tendriamos que modificar el codigo y añadir lo siguiente.

public class HelloAndroidActivity extends Activity {
    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        TextView tv = new TextView(this);
        tv.setText("Hello, Android");
        setContentView(tv);

    }
}

Ahora que ya lo tenemos todo bien tenemos que ejecutarlo mediante el boton de "Run As" con ello nos aparecera la siguiente pantalla en la que seleccionaremos como queremos que se ejecute el codigo.


Pero como no tenemos configurado ningun dispositivo nos dara un "error" el cual nos derivara a la creación de dispositivos.


En la siguiente pantalla se pueden configurar tantos dispositivos como se quiera, pero con uno es suficiente.



Tras un par de ajustes el emulador cargara perfectamente, y de manera automatica tendremos nuestro programa funcionando :)


Por cierto, el Dalvkit de Android es 100% funcional, podemos navegar a la pagina que queramos.


Programando Android en Ubuntu 11.10 (I)

0 comentarios

Lo primero que tenemos que tener para poder programar Android sobre el Ubuntu 11.10 es un IDE (por sus siglas en inglés de integrated development environment) el más conocido por todos en el mundillo de la programación Java, así como el que recomienda Google, es el Eclipse, el cual podemos encontrar fácilmente en el centro de software de Ubuntu sirviéndonos del recuadro de búsqueda que tenemos arriba a la derecha, tal y como se puede ver en la siguiente imagen.


Otra cosa importante que tenemos que tener en cuenta es que vamos a necesitar el SDK (por sus siglas en ingles de Software Development kit) de Java, para ello tendremos que instalar el JDK (por sus siglas en ingles de Java Development Kit). En mi caso inexplicablemente no lo he encontrado en el "centro de software de Ubuntu" de manera que he tenido que utilizar el terminal para poder instalarlo; para abrir el terminal podemos utilizar o bien la búsqueda del menú (no me preguntéis que poner para que salga) o bien la combinación de teclas "ctrl + alt + T" tengo entendido que hay ocasiones en la que falla, no ha sido mi caso. Con el terminal abierto tenemos que introducir los siguientes comandos.



sudo apt-get install python-software-properties
sudo add-apt-repository ppa:ferramroberto/java
sudo apt-get update
sudo apt-get install sun-java6-jdk sun-java6-plugin

Con esto ya tendremos instalado el JDK, ahora tenemos que activar las alternativas de Java, para ello introduciremos el siguiente comando.


sudo update-alternatives --config java

Tras este comando podremos observar la siguiente imagen. Personalmente me he quedado con el OpenJDK ya que no tengo ningún problema (como mínimo de momento) en desarrollar con el.


Ahora es el turno de instalar Android, para ello tenemos que descargarnos el paquete correspondiente desde esta pagina. A partir de aquí no uséis el copy paste a lo tonto que no funcionara. Ahora que ya tenemos el fichero nos vamos hasta el directorio en que nos lo ha descargado mediante los comandos "ls" (para ver el contenido del directorio), "cd" (para entrar en un directorio) y ... bueno con esos dos ya hacemos.

Una vez estamos en la carpeta tenemos que descomprimir el fichero, para ello tenemos que usar el comando 

tar -xf android-sdk_r12-linux_x86.tgz
Ahora para poder ver el GUI (por sus siglas en inglés de Graphical User Interface) que nos permitirá instalar todas las cosas de Android solo tenemos que poner el comando:

android-sdk*/tools/android
En el terminal veremos algo parecido a lo que aparece en la siguiente imagen.


Al tiempo que se nos carga una nueva ventana que nos permitirá instalar todo lo que nos haga falta de Android incluyendo las diferentes API. Mi consejo es que os pongáis las APIs correspondiente a la versión 1.6, a la que tengáis en el móvil y la ultima versión que haya salido a la calle; con la 1.6 os podéis asegurar la completa compatibilidad entre sistemas, con la que tengáis en el móvil podéis ver mejor los fallos a través del emulador y con la ultima podréis comprobar que realmente funciona bien en los últimos SO que salen en la calle. 


Como podéis ver en mi caso tuve que ejecutar por dos veces la instalación, se me fue un poco la cabeza y como tenia sueño simplemente cerré el portátil, entrando este en invernación, con su consecuente perdida de conexión y... bueno, de todo. Cuando volví a cargar el PC lance otra vez la petición para el GUI  lo que no entiendo muy bien es por que me apareció la que podéis ver a continuación, pero tanto en una como en la otra podemos descargar las mismas cosas.


Ahora ya lo tenemos todo instalado, lo siguiente seria cargar Eclipse y configurarlo para programar Android, pero como este post me ha quedado muy largo ya si eso lo dejamos para otro momento.

Learn with Codecademy Lesson 1

0 comentarios


Como podemos observar las lecciones son muy rapidas de hacer, enseñando desde una base que casi roza el insulto a nuestra inteligencia, pero como ya dije el otro día hay que comenzar desde abajo y contra más abajo comencemos mucho mejor.

Personalmente espero que esto mejore mucho por que si no me veo muy aburrido dentro de demasiado poco.

Learn with Codecademy

0 comentarios

Hoy os traigo la competencia, en este caso tenemos codecademy una pagina que nos propone unos cursos básicos de programación. El registro es muy simple, tanto que podrás utilizar directamente tu cuenta del Facebook.

La pagina esta en ingles, pero seamos sinceros con nosotros mismos, todos los sitios interesantes de programación están en ingles y ya no digamos nada de la documentación. El sistema nos enviara un mail cada semana animándonos a que hagamos el ejercicio de esa semana, de tal manera que en un solo año ya sabremos programar.

Puede parecer raro pero creo repasar las bases de la programación es algo que todos tendríamos que hacer como ejercicio, tenemos que pensar que todo el mundo entra en una espiral de vicio que termina por hacernos pensar que lo que nosotros hacemos es lo correcto, por eso es tan importante repasar la base.