1.  Copia o arquivo “glomosim-2.03.tar.gz” numa pasta, no meu caso eu coloquei em: “~/Programas”

   Que é o mesmo que dizer “/home/fpujaico/Programas”, logo entra nessa pasta escrevendo num terminal:

   cd ~/Programas

2. Descomprima o arquivo “glomosim-2.03.tar.gz”:

   tar zxvf glomosim-2.03.tar.gz

3. Edite o arquivo .bashrc:

   gedit ~/.bashrc

   E acrescente ao final:

   ## Para compilar GlomoSim.
   PATH=~/Programas/glomosim-2.03/parsec/redhat-7.2/bin:"${PATH}"
   export PCC_DIRECTORY="~/Programas/glomosim-2.03/parsec/redhat-7.2"
    
   ## Para ejecutar GlomoSim
   PATH=~/Programas/glomosim-2.03/glomosim/bin:"${PATH}"

4. Encerra sessão, e abre novamente uma sessão, para atualizar as variaveis de entorno.
5. Para provar que as variaveis estão correctamente carregadas tipea:

   pcc

   E obteras: “No input files.”

   pcc -env

   E obteras as variaveis de entorno por default.

6. Compila glomosim:

   cd ~/Programas/glomosim-2.03/glomosim/main

   make

   * Se o compilador não pode achar o arquivo pc_api.h então ejecuta.

   cp ../../parsec/redhat-7.2/include/*.* ./ e ejecuta novamente o make

7. Test de instalação:

   cd ../bin

   ou

   cd ~/Programas/glomosim-2.03/glomosim/bin

   ./glomosim config.in

Para instalar:

sudo apt-get install pdftk

Para usar:

pdftk  tese-part1.pdf tese-part2.pdf tese-part3.pdf cat output tese-final.pdf

Para ver ejemplos de uso de pdftk entra aquí.

android create project	--target 7 \
			--name HelloWorld \
			--path ./HelloWorldProject \
			--activity HelloWorldActivity \
			--package com.hello.world

Para obtener el binario de la aplicación se entra a la carpeta HelloWorldProject.

cd HelloWorldProject

Y se ejecuta el comando:

ant debug

Obviamente debes tener instalado ant.

Luego si deseas subir la aplicación a un emulador, desde el programa android entra a Virtual Devices, y creamos uno nuevo.

android

finalmente para mandar/instalar la aplicación al dispositivo virtual usa:

adb install bin/HelloWorld-debug.apk

Mira que no es necesario indicar a que dispositivo enviar la aplicación, dado que solo hay uno, que es el virtual que hemos creado.

–target:

ID del objetivo. Para obtener la lista de ID, ejecuta:

android list target

Obteniendo como resultado (en mi caso):

Available Android targets:
id: 1 or "android-3"
     Name: Android 1.5
     Type: Platform
     API level: 3
     Revision: 4
     Skins: QVGA-P, QVGA-L, HVGA-L, HVGA (default), HVGA-P
id: 2 or "Google Inc.:Google APIs:3"
     Name: Google APIs
     Type: Add-On
...

Y asi sigue mostrando todos los ID, El ID=7 que es equivalente a decir “Android-8″ indica que usaremos Android 2.2 (Android en la versión 2.2).
.

–name:

Nombre del proyecto.

–path:

El directorio donde se creará el proyecto de nombre name.

–activity:

Actividad. Una actividad presenta una interfaz gráfica (escrita en XML) que permite al usuario interactuar con la aplicación.

–package:

paquete.

Instala el cliente y servidor de la base de datos y la aplicación pgAdmin para administrar la base de datos PostgreSQL.

sudo apt-get install postgresql postgresql-client postgresql-contrib

Si deseas crear tus funciones escritas en lenguaje C, para ser cargadas dinámicamente por el servidor PostgreSQL, debes instalar también los siguientes paquetes de bibliotecas y cabeceras. (en mi caso PostgreSQL 8.4)

sudo apt-get install libpq-dev postgresql-server-dev-8.4

Cambiando contraseña

Para cambiar la contraseña al ususario postgres ejecuta:

sudo passwd postgres

Interactuando con el servidor

Lo primero es cambiar a el usuario Postgres, dado que este es el usuario de máximos privilegios, para el servidor.

su - postgres

Crea una base de datos prueba1

createdb prueba1

Conectate a la base de datos prueba1

psql prueba1

Crea una tabla

CREATE TABLE tabla1 (pathfilename char(128));

Insertando valores

INSERT INTO tabla1 VALUES ('/home/fernando/texto1.txt');
INSERT INTO tabla1 VALUES ('/home/fernando/texto2.txt');

Viendo datos de la tabla

SELECT * FROM tabla1;

Antes de continuar algunas aclaraciones:

OBJETIVO:

• Crear un archivo binario ejecutable llamado “test“.
• Dar atributos de ejecutable al programa “test”.(Hardware: Necesitas root obligatorio, Emulador: Ya viene rooteado)
• Colocar el programa “test” en nuestro dispositivo Android. Se ejecuta usando algún programa que emule una terminal en Android, escribiendo “./test”. Esto al estilo de los programa ls, mkdir, rm, etc. Que ya están en tu dispositivo Android en la dirección “/system/bin”

REQUISITOS:

• Debes tener descargado y descomprimido el SDK de Android.
• Debes tener descargado y descomprimido el NDK de Android.
• Si deseas testear el programa en un dispositivo real, este debe de estar root-eado. Caso contrario deberas usar un emulador. Por causa de que solo puedes darle atributos de ejecución a un programa cuando  eres root.

METODO:

He descomprimido la SDK y la NDK en mi carpeta “~/Android” obteniendo en el interior a la fecha (Junio-2011) las carpetas “android-sdk-linux_x86″ y “android-ndk-r5c”.

Creando la StandAlone-ToolChain (Cadena de herramientas independientes), Escribe y ejecuta el script.

creando-toolchain.sh:

ANDROIDDIR=~/Android
NDK=$ANDROIDDIR/android-ndk-r5c
 
MAKETOOLCHAIN=$NDK/build/tools/make-standalone-toolchain.sh
 
PLATFORM=android-9
 
INSTALLDIR=$NDK/.standalone/$PLATFORM-toolchain
 
chmod +x $MAKETOOLCHAIN
 
$MAKETOOLCHAIN --platform=$PLATFORM --install-dir=$INSTALLDIR

Sobre el script “creando-toolchain.sh”

• $MAKETOOLCHAIN es la dirección del script que creará el standalone-toolchain en $INSTALLDIR
• Puedes ver las plataformas disponibles en “$NDK/platforms”. Para Gingerbread API (level 9)

Eso es todo! los binarios del toolchain no dependen o contienen un path específico para el host, en otras palabras, se puede instalar en cualquier lugar, o incluso mover si es necesario. Ahora, sólo tienes que agregar la carpeta de binarios “$INSTALLDIR/bin” en tu variable de entorno $PATH:

 gedit ~/.bashrc

y escribiendo al final:

 export PATH=:~/Android/android-ndk-r5c/.standalone/android-9-toolchain/bin:$PATH

Para finalizar reinicia o cierra sesión.

Para compilar, crea el programa test.c:

#include <stdio.h>
 
int main(int argc, char** argv)
{
	printf("HOLA MUNDO\n");
	return 0;
}

y compila con:

arm-linux-androideabi-gcc -o test test.c

Esto creará el programa “test”. Para enviar y dar privilegios de ejecución al programa en tu dispositivo Android, o tu emulador, usa los siguientes comandos tomando en cuenta [1]:

adb push test /data/test
adb shell chmod 777 /data/test

Usando el programa adb tambien puedes ejecutar el programa “test” en tu dispositivo android y ver el resultado:

adb shell /data/test

Si simplemente quieres jugar con la shell de tu dispositivo android ejecuta:

adb shell

PROBLEMAS:

• Necesitas ser root!!!, no puedo esperar que todas las personas que quieran instalar mi programa(osea copiar y dar privilegios de ejecución) sean root. El problema es la instalación, una vez instalado supongo que un usuario normal podría ejecutarlo, pero el trabajo de rootearlo ya se hizo.

[1] Para que esto funcione debes tener instalado el SDK y las carpetas “$ANDROIDDIR/android-sdk-linux_x86/platform-tools” y “$ANDROIDDIR/android-sdk-linux_x86/tools” deben de estar en tu variable de entorno PATH. Para conseguirlo es necesario:

 gedit ~/.bashrc

export PATH=:~/Android/android-sdk-linux_x86/platform-tools:$PATH
export PATH=:~/Android/android-sdk-linux_x86/tools:$PATH

Para finalizar reinicia o cierra sesión.

El NDK de Android es un conjunto de herramientas que permite incorporar los componentes que hacen uso de código nativo en las aplicaciones de Android.

Las aplicaciones para Android se ejecutan en la máquina virtual Dalvik. El NDK permite implementar parte de tus aplicaciones usando código nativo con lenguajes como C y C + +. Esto puede proporcionar beneficios a ciertas clases de aplicaciones, en la medida que se puede reutilizar el código existente y en algunos casos obtener un aumento de la velocidad.

El NDK establece lo siguiente:

• Un conjunto de herramientas y archivos de construcción que se utilizan para generar bibliotecas de código nativo de fuentes en C y C + +.
• Una manera de integrar las correspondientes bibliotecas nativas en un archivo de paquete de aplicaciones (. Apk) que se pueden implementar en los dispositivos Android.
• Un conjunto de cabeceras y bibliotecas nativas del sistema  que estarán soportadas en todas las futuras versiones de la plataforma Android, a partir de Android 1.5. Las aplicaciones que utilizan actividades nativas deben de ejecutarse sobre Android 2.3 o posterior.
• Documentación, ejemplos y tutoriales.

La última versión de la NDK soporta estos conjuntos de instrucciones ARM:

• ARMv5TE (incluyendo instrucciones Thumb-1 )
• ARMv7-A (incluyendo instrucciones Thumb-2 y  VFPv3-D16, con soporte opcional para instrucciones NEON/VFPv3-D32 )

Las futuras versiones de la NDK también prestarán apoyo a:

• Instrucciones x86 (ver CPU-ARCH-ABIS.HTML para más información)

El código máquina ARMv5TE  funcionará en todos los dispositivos  ARM-Based de Android. ARMv7-A sólo se ejecutarán en los dispositivos tales como el Droid de Verizon o Google Nexus One que tengan una CPU compatible. La principal diferencia entre los dos conjuntos de instrucciones es que ARMv7-A soporta instrucciones hardware FPU, Thumb-2, y  NEON. Usted puede apuntar (Target) a uno o ambos conjuntos de instrucciones – ARMv5TE es el valor predeterminado, pero cambiar a ARMv7-A es tan fácil como añadir una línea al archivo de aplicación Application.mk , sin necesidad de cambiar nada mas en el archivo. También se puede construir para ambas arquitecturas al mismo tiempo y tenerlo todo almacenado en el *.Apk final. Toda la información se encontrará en el archivo CPU-ARCH-ABIS.HTML del paquete NDK.

El NDK proporciona las cabeceras estables para libc (la biblioteca de C), libm (la biblioteca matemática), OpenGL ES (3D Graphics Library), la interfaz JNI, y otras bibliotecas, como se indica en la sección de herramientas de desarrollo.