Vistas de página en total

sábado, 12 de mayo de 2012

Programación Android con AIDE y Java 1


Mi primer programa y el de una Calculadora
VER VIDEO DE AIDE Y JAVA
El hombre inteligente es resultado de la evolución y desarrollo humano y lo ha demostrado en la ciencia y tecnología que ha creado y su inteligencia está representada en el teléfono inteligente que ha sido inventado por el hombre como una extensión de su inteligencia y donde se integran las tecnologías de electrónica, comunicaciones y de computación. Siempre el hombre busca extender sus capacidades limitadas en herramientas que le ayuden a solucionar sus problemas. Así es el caso de  la herramienta AIDE que se usa para poder programar la computadora de un teléfono inteligente. AIDE significa Android Integrated Development Environmente y es un Ambiente de Desarrollo Integrado para Android. Con este sistema se pueden desarrollar y crear programas en el mismo teléfono celular que tengan como sistema operativo android 2.2. Por lo tanto para desarrollar programas es necesario tener un teléfono inteligente o móvil celular como el que tengo, un Samsung Galaxy mini con el sistema operativo android 2.2. Para adquirir AIDE se debe usar el internet del teléfono y de conectarse al mercado o play store de android, buscar AIDE que es libre, bajarlo e instalarlo y listo se puede iniciar a programar. Fabuloso! programar en una mano la computadora de un teléfono inteligente.
P01  Mi primer programa
Después de quedar instalado AIDE buscamos su logo, que es un pequeño android verde entre llaves azules (1) lo presionamos con el dedo y entramos a AIDE (2). Presionamos Create new App Project here, para crear un nuevo proyecto (3) escribimos el nombre del proyecto p01, el nombre del paquete com.gri.p01 y presionamos Create y se crea el nuevo proyecto (4) p01.
 Al generarse el proyecto se generan varias carpetas y archivos. Los 2 puntos(..) significa regresar un nivel superior de la trayectoria de carpetas. Las carpetas creadas son settings, assets, bin (5), gen, res y src (6) y los archivos creados son classpath, project (6), proguard.cfg, Project.properties y AndroidManifiest.xml (7).


Las carpetas principales son res que contiene los recursos que utilizara el programa como menus, imágenes y archivos xml para representar las pantallas del programa. La carpeta src contiene diferentes subcarpetas y la última contiene el o los programas en java de la aplicación.

Vamos a compilar, instalar y ejecutar el proyecto p01. Primero seleccionamos el menú (8) con la tecla de menú y presionamos Run para iniciar la compilación (9), si no detecta errores, pregunta si desea instalarse la aplicación (10), le decimos que si la instale (11) y cuando termina envía el mensaje de instalada y ahora pregunta si se desea abrir o ejecutar, le decimos que la abra y se ejecuta el programa (12). Maravilloso todo el proceso se realiza en el teléfono móvil o inteligente. En mi caso en el Samsung Galaxy mini. 

P01, Mi primer programa, modificado
Ahora vamos a modificar el proyecto usando solo código de java, en lugar de usar un archivo xml para desplegar el mensaje de “Hola…mi primer programa...”,  Primero presionamos la carpeta src (6),  aparece la carpeta com (13), presionamos com y aparece la carpeta gri (14) y aparece la carpeta p01 (15) y despliega el programa principal en java MainActivity.java (16).

 
Al presionar el programa de MainActivity (16) entramos al editor de AIDE y ahora iniciamos la modificación del programa. El proyecto p01 contiene el programa MainActivity.java e inicia definiendo el nombre del paquete package com.gri.p01; a continuación importa las librerías que necesita el programa, define la clase principal de MainActivity y dentro de esta define el método de onCreate y a continuación las instrucciones que debe realizar el programa. Primero presionamos el dedo al inicio de la instrucción setContentView y la comentamos colocando dos diagonales o sea queda como (18):
//setContentView(R.layout.main);
Ahora a continuación de la línea anterior, definimos una nueva instancia u objeto ll1 de LinearLayout (17) y (18).
LinearLayout ll1 = new  LinearLayout(this);
Lo definimos como Vertical.
ll1.setOrientation(LinearLayout.VERTICAL);
Ahora definimos una nueva instancia tv1 de TextView.
TextView tv1 = new TextView(this);
Colocamos el texto de “Hola…mi primer programa…”. 
tv1.setText(“Hola…mi primer programa…”);
Ahora agregamos TextView tv1 a LinearLayout ll1.
ll1.addView(tv1);
Finalmente visualizamos todo la pantalla del teléfono con LinearLayout.
setContentView(ll1);
El programa queda completo (19).
AIDE complenta y checa  las instrucciones y si la instrucción es erronea o falta algo, como en (20) que falta ll1, detecta el error, cuando se corrige (21) queda libre de errores.

 
También se puede usar las características del editor de AIDE, se presiona y mantiene el dedo y aparecen varias opciones del editor (21) y (22). Se presiona Select para seleccionar el principio de un área y el final de esa área de texto para copiarlo o cortarlo. Si se va a copiar el área de texto, se posiciona el dedo en el lugar deseado y aparece un menú donde se selecciona Edit para copiar el área de texto (23) (24) y (25). 


El programa MainActivity .java completo queda como:
package com.gri.p01;
import android.app.*;
import android.os.*;
import android.view.*;
import android.widget.*;
public class MainActivity extends activity{
@Override
public void onCreate(Bundle saveInstancesState{
                        super.onCreate(savedInstanceState);
                        //setContentView(R.layout.main);
                        LinearLayout ll1 = new LinearLayout(this);
                        ll1.setOrientation(LinearLayout.VERTICAL);
                        TextView tv1 = new TextView(this);
                        tv1.setText(“Hola…mi primer programa…”);
                        ll1.addView(tv1);
                        setContentView(ll1);
            }//oncreate
}//class


Ahora tenemos listo el programa modificado MainActivity para compilarlo, instalarlo y ejecutarlo. Primero seleccionamos el menú (26), presionamos Run para compilar el programa (27), si no hay errores, pregunta si desea reemplazar el programa ya instalado, presionamos aceptar e inicia la instalación (28) y (29). Cuando termina de instalarse pregunta si desea abrir o ejecutarse el programa del proyecto p01 (31). Para salir se presiona el menú y la opción de más u otros se busca salir y se presiona. Se sale de AIDE y despliega el menú del sistema (32).

Programa de una calculadora simple utilizando código java
En nuestras páginas anteriores del blog hablamos de cómo podemos hacer operaciones aritméticas simples mentalmente, pero cuando aumenta el tamaño de las cantidades, es difícil hacerlo mentalmente, necesitamos un procedimiento o programa para efectuar las operaciones. Ahora veremos como con un programa de una calculadora en nuestro teléfono inteligente puede realizar operaciones simples y mucho más complicadas, cuyas soluciones son extremadamente rápidas y que se puede repetir muchas veces. Estas son  las principales diferencias de una computadora con respecto del hombre, la velocidad y la repetición.


Ahora vamos crear el programa de la calculadora. Primero creamos un nuevo proyecto  MyApp5 con el modulo com.mycompany.myapp5 y vamos a la carpeta src y  editamos el programa MainActivity.
MainActivity.java
package com.mycompany.myapp5;

import android.app.*;
import android.os.*;
import android.text.*;
import android.view.*;
import android.view.View.*;
import android.widget.*;
import android.graphics.*;

public class MainActivity extends Activity implements OnClickListener
{
            //Definimos los botones para las operaciones de suma +, resta -,
//multiplicación *, y división /
            Button b1;
            Button b2;
            Button b3;
            Button b4;
           
//Definimos los cuadros de texto donde introduciremos los datos
            EditText et1;
            EditText et2;
           
            //Definimos la vista de texto, donde veremos los resultados de las operaciones
            TextView tv2;
                       
    // Called when the activity is first created
    @Override
    public void onCreate(Bundle savedInstanceState)
            {
            super.onCreate(savedInstanceState);
                        //Comentamos la siguiente instrucción para utilizar solo código java
                        //para desplegar la información en la pantalla

            //setContentView(R.layout.main);

                        // Definimos toda la pantalla para desplegar con linearLayout ll1
                        LinearLayout ll1 = new LinearLayout(this);
                        //Definimos la pantalla como vertical
                        ll1.setOrientation(LinearLayout.VERTICAL);
                        //Creamos una instancia de TextView tv1 para el titulo de Calculadora
                        TextView tv1 = new TextView(this);
                        tv1.setText("Calculadora");
                        //Ponemos el texto del título en color azul
                        tv1.setTextColor(Color.BLUE);
                        //Ponemos el tamaño del texto a 20
                        tv1.setTextSize(20);
                        //Centramos el titulo
                        tv1.setGravity(0x01);
                        //Agregamos la instancia de TextView tv1 a LinearList ll1
                        ll1.addView(tv1);
                       
                        //Creamos LinearLayout ll2 como horizontal para alinear los botones
                        LinearLayout ll2 = new LinearLayout(this);
                        ll2.setOrientation(LinearLayout.HORIZONTAL);
                        //Creamos una instancia Button b1 para la operación suma +
                        b1 = new Button(this);
                        b1.setText("Suma");
                        ll2.addView(b1);
                        //Creamos una instancia Button b1 para la operación resta -
                        b2 = new Button(this);
                        b2.setText("Resta");
                        ll2.addView(b2);
                        //Creamos una instancia Button b1 para la operación multiplicación *
                        b3 = new Button(this);
                        b3.setText("Multiplica");
                        ll2.addView(b3);
                        //Creamos una instancia Button b1 para la operación de suma +
                        b4 = new Button(this);
                        b4.setText("Divide");
                        ll2.addView(b4);
                        //Agregamos LinearLayout ll2 en ll1
                        ll1.addView(ll2);
                       
                        //Creamos una instancia EditText et1 para introducir el primer dato1
                        et1 = new EditText(this);
                        et1.setText("Borra e Introduce un numero...");
                        ll1.addView(et1);
                        //Creamos una instancia EditText et2 para introducir el segundo dato2
                        et2 = new EditText(this);
                        et2.setText("Borra e Introduce otro...");
                        ll1.addView(et2);
                        //Creamos una instancia TextView tv2 para desplegar los resultados
                        tv2 = new TextView(this);
                        ll1.addView(tv2);
                        //Despliega toda la pantalla definida por LinearLayout ll1
                        setContentView(ll1);
                       
                        //Definimos los botones para escuchar o detectar cuando se presionan
                        b1.setOnClickListener(this);
                        b2.setOnClickListener(this);
                        b3.setOnClickListener(this);
                        b4.setOnClickListener(this);
                       
            }// oncreate

            //Método a ejecutar cuando se presiona los botónes b1 de suma,
//b2 de resta, b3 multiplicación y b4 división
            public void onClick(View view){
                        // Pregunta si se presiona b1
                        if(view == b1){
                        //Captura dato1 y dato2
                        String txt1 = et1.getText().toString();
                        String txt2 = et2.getText().toString();
                        //Convierte el texto a punto flotante
                        float num1 = Float.parseFloat(txt1);
                        float num2 = Float.parseFloat(txt2);
                        //Efectúa la operación de suma decimal
                        float res1 = num1 + num2;
                        //Despliega el resultado
                       tv2.append("Resp + : "+res1+"\n");
                        // Pregunta si se presiona b2
                        }else{if(view == b2){
                            //Captura dato1 y dato2        
                            String txt1 = et1.getText().toString();
                            String txt2 = et2.getText().toString();
                            //Convierte el texto a punto flotante
                            float num1 = Float.parseFloat(txt1);
                            float num2 = Float.parseFloat(txt2);
                            //Efectúa la operación de resta decimal
                           float res1 = num1 - num2;
                            //Despliega el resultado
                           tv2.append("Resp - : "+res1+"\n");
                                   // Pregunta si se presiona b3
                                   }else{if(view == b3){
                                    //Captura dato1 y dato2
                                    String txt1 = et1.getText().toString();
                                    String txt2 = et2.getText().toString();
                                     //Convierte el texto a punto flotante
                                    float num1 = Float.parseFloat(txt1);
                                     float num2 = Float.parseFloat(txt2);
                                     //Efectúa la operación de multiplicación decimal
                                     float res1 = num1 * num2;
                                     //Despliega el resultado
                                    tv2.append("Resp x : "+res1+"\n");
                                               // Pregunta si se presiona b3
                                               }else{if(view == b4){
                                                   //Captura dato1 y dato2        
                                                   String txt1 = et1.getText().toString();
                                                   String txt2 = et2.getText().toString();
                                                   //Convierte el texto a punto flotante
                                                  float num1 = Float.parseFloat(txt1);
                                                  float num2 = Float.parseFloat(txt2);
                                                   //Efectúa la operación división decimal
                                                 float res1 = num1 / num2;
                                                 //Despliega el resultado
                                                tv2.append("Resp / : "+res1+"\n");
                                    }//b4
                        }//b3
            }//b2
       }//b1
    }//onclick
}//class main activ

Programa de una calculadora simple utilizando código java y xml 
Programa de la calculadora simple utilizando código java y un archivo main.xml para definir la interface  de la pantalla.


Creamos un nuevo proyecto MyApp6 con el modulo com.mycompany.myapp6. Presionamos la carpeta res y a continuación layout y aparece el archivo main.xml lo editamos y ponemos todas las definiciones para la interface con la pantalla del teléfono. Para comentarios se usa <!-- Comentarios -->

Main.xml
<?xml version="1.0" encoding="utf-8"?>

<!-- Definimos la pantalla con LinearLayout para la aplicación -->

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="fill_parent"
    android:layout_height="fill_parent"
    android:orientation="vertical" >

            <!-- Creamos la instancia TextView para el titulo Calculadora y caract. -->
                       
            <TextView
              android:layout_width="fill_parent"
              android:layout_height="wrap_content"
              android:textColor="#111199"
              android:textSize="25sp"
              android:gravity="center"
              android:text="Calculadora" />
           
            <!—LinearLayout vertical para los botones de las operaciones -->
           
            <LinearLayout
                        android:layout_width="fill_parent"
                        android:layout_height="wrap_content"
                        android:orientation="horizontal" >

            <!-- Instancia Button b1 para sumar y el método suma cuando se presione -->
           
            <Button
                android:id="@+id/b1"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:onClick="suma"
                android:text="Sumar" />

            <!-- Instancia Button b2 para restar y el método resta cuando se presione -->

            <Button
                android:id="@+id/b2"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:onClick="resta"
                android:text="Restar" />

            <!-- Instancia Button b3 para multiplicar y el método multiplica cuando se presione -->
           
            <Button
                android:id="@+id/b3"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:onClick="multiplica"
                android:text="Multiplicar" />

<!-- Instancia Button b4 para dividir y el método divide cuando se presione -->
           
            <Button
                android:id="@+id/b4"
                android:layout_width="wrap_content"
                android:layout_height="wrap_content"
                android:onClick="divide"
                android:text="Dividir" />                  
                       
            </LinearLayout>

            <!—Crear instancia de EditText et1 para introducir dato1 -->
           
            <EditText
                 android:id="@+id/et1"
                 android:layout_width="fill_parent"
                 android:layout_height="wrap_content"
                 android:numeric="integer"
                 android:inputType="numberDecimal"
                 android:text="Borra e introduce 1 decimal: " />

        <!—Crear instancia de EditText et2 para introducir dato2 -->
                         
        <EditText
                 android:id="@+id/et2"
                 android:layout_width="fill_parent"
                 android:layout_height="wrap_content"
                 android:numeric="integer"
                 android:inputType="numberDecimal"
                 android:text="Borra e introduce otro 2 decimal: " />

         <!-- Crear instancia de TextView tv1 para desplegar resultados -->
                       
          <TextView
                 android:id="@+id/tv1"
                 android:layout_width="fill_parent"
                 android:layout_height="wrap_content"
                 android:textColor="#119911"
                 android:text="Resultados \n" /> 
          
</LinearLayout>

Ahora seleccionamos la carpeta src y seleccionamos y editamos el programa MainActivity donde  se agregan e introducen las siguientes instrucciones.

MainAtivity.java

package com.mycompany.myapp6;

import android.app.*;
import android.os.*;
import android.view.*;
import android.widget.*;

public class MainActivity extends Activity
{
            //Crear las instancias de Button b1, b2, b3 y b4 para las operaciones de
            //suma, resta, multiplicación y división
            Button b1;
            Button b2;
            Button b3;
            Button b4;
            EditText et1;
            EditText et2;
            TextView tv1;
           
    // Called when the activity is first created
    @Override
    public void onCreate(Bundle savedInstanceState)
            {
        super.onCreate(savedInstanceState);

              //Importante, No se comenta la siguiente instrucción
             setContentView(R.layout.main);

                        //Se buscan las definiciones de los botones en main.xml
                        b1 = (Button)findViewById(R.id.b1);
                        b2 = (Button)findViewById(R.id.b2);
                        b3 = (Button)findViewById(R.id.b3);
                        b4 = (Button)findViewById(R.id.b4);
                       
                        //Se buscan las definiciones de los textos de edición, en main.xml
                        et1 = (EditText)findViewById(R.id.et1);
                        et2 = (EditText)findViewById(R.id.et2);

                        //Se buscan las definiciones de la vista del texto en main.xml
            tv1 = (TextView)findViewById(R.id.tv1);
   }//oncreate

   //Método de suma cuando se presiona botón sumar
   public void suma(View view){
              //Captura dato1 y dato2          
              String s1 = et1.getText().toString();
              String s2 = et2.getText().toString();
              //Convierte el texto a punto flotante
              float f1 = Float.parseFloat(s1);
              float f2 = Float.parseFloat(s2);
              //Efectúa la operación suma decimal
              float f3 = f1+f2;
              //Despliega el resultado
              tv1.append("Res de + : "+f3+"\n");
  }
  //Método de resta cuando se presiona botón restar
  public void resta(View view){
              //Captura dato1 y dato2          
              String s1 = et1.getText().toString();
              String s2 = et2.getText().toString();
              //Convierte el texto a punto flotante
              float f1 = Float.parseFloat(s1);
              float f2 = Float.parseFloat(s2);
              //Efectúa la operación resta decimal
              float f3 = f1-f2;
              //Despliega el resultado
              tv1.append("Res de - : "+f3+"\n");                                
            }
  //Método de multiplica cuando se presiona botón multiplicar
  public void multiplica(View view){
              //Captura dato1 y dato2          
              String s1 = et1.getText().toString();
              String s2 = et2.getText().toString();
              //Convierte el texto a punto flotante
              float f1 = Float.parseFloat(s1);
              float f2 = Float.parseFloat(s2);
              //Efectúa la operación multiplicación decimal
              float f3 = f1*f2;
              //Despliega el resultado
              tv1.append("Res de x : "+f3+"\n");
            }
  //Método de divide cuando se presiona botón dividir
  public void divide(View view){
              //Captura dato1 y dato2          
              String s1 = et1.getText().toString();
              String s2 = et2.getText().toString();
              //Convierte el texto a punto flotante
              float f1 = Float.parseFloat(s1);
              float f2 = Float.parseFloat(s2);
              //Efectúa la operación división decimal
              float f3 = f1/f2;
              //Despliega el resultado
              tv1.append("Res de / : "+f3+"\n");
            }
}//class

Esta introducción a AIDE y java con los programas de la Calculadora es complicado para las personas que nunca han programado una computadora, pero se debe de tener en cuenta que la computadora es solo una herramienta que ayuda al hombre en solucionar problemas y ahora tienen la oportunidad de poder programar la computadora de su teléfono inteligente. Para cualquier aprendizaje se debe poner mucha voluntad y esfuerzo, además de seguir un entrenamiento, en este caso en el lenguaje de java y que veremos en las siguientes páginas del blog de la Evolución y Desarrollo Humano y demostrar que la inteligencia de cualquier hombre de esta época de la información y del conocimiento, puede programar un teléfono inteligente o móvil. Para programar, primero es necesario que las personas sepan lo que la computadora va a realizar, en este caso las operaciones matemáticas sencillas y se debe instruir a la computadora por medio de un programa que tiene una secuencia de instrucciones para que realicen las operaciones. Para eso es necesario aprender los principios básicos del lenguaje java. En la siguiente página del blog veremos los principios del lenguaje java.   




sábado, 5 de mayo de 2012

Computadora de un Teléfono Inteligente


El teléfono inteligente es una computadora con la principal función de comunicarse y efectuar computaciones. Una computadora es un dispositivo electrónico que tiene un procesador central, memoria interna en rom y ram, memoria externa en discos y otros, dispositivos de entrada y salida. Para funcionar tiene un sistema operativo y programas de aplicaciones. El sistema operativo es un programa principal que controla la computadora. Un programa es una secuencia de instrucciones, que bajo el control del procesador central, son obtenidos de la memoria una a una y ejecutadas. Las instrucciones son aritméticas, lógicas, de decisión y control, de entrada y salida y otras instrucciones. Cada instrucción a nivel de máquina es una secuencia de unos y ceros.  Una instrucción tiene una parte que indica la operación a realizar (aritmética, lógica, de decisión, etc.) y otra parte la dirección en memoria de los operandos o datos. Programar en este nivel de máquina de puros unos y ceros sería muy difícil pero no imposible. Para ayudar a la programación se inventaron los lenguajes de programación de alto nivel, donde las instrucciones, por ejemplo las aritméticas se identifican con nombres de ADD o +, SUBSTRACT o -, MULTIPLY o * , DIVIDE o /. Una vez escrito y terminado el programa es traducido o compilado  por otro programa que los convierte a un lenguaje de máquina y poder ejecutarse para obtener los resultados deseados. Cuando se invento la computadora su objetivo principal era de realizar computaciones, posteriormente se incluyo la comunicación de usuarios para accessar a la computadora con cables en un sitio local y a través de líneas telefónicas para sitios remotos. Con el paso del tiempo se crearon redes locales que conectaban a varias computadoras en un área local de un edificio o varios cercanos. Siguieron las redes amplias donde se conectaban varias computadoras en un área amplia dentro de una ciudad, país o a nivel mundial utilizando sistemas propietarios de comunicaciones, usadas principalmente por grandes compañías. Cuando surge internet, que es la biblioteca global de la información y el conocimiento,  es una red de redes de computadoras, donde  se conectan todas las computadoras del mundo, utiliza el sistema de comunicación mundial. Pero cualquier persona puede conectarse a internet, usando cualquier clase de computadora y una línea de comunicación, lo más importante, también puede usar su teléfono inteligente o móvil para navegar por internet entre otras muchas funciones del teléfono. Concluimos que  el teléfono móvil  integra las tecnologías de electrónica, computación y comunicaciones en la mano del hombre
.
CDC 6600
Supercomputadora
Las primeras computadoras eran grandes y de alto costo, además se necesitaba mucho espacio para la computadora, solo disponible en instituciones y compañías grandes. Para programarlas se necesitaba un entrenamiento en un lenguaje de programación como fortran o cobol, que no cualquiera podía realizar.  Para hacer y ejecutar un programa, primero se aprendía el lenguaje, despues se escribía en una hoja de codificación, se entregaba al departamento de perforación, donde se recogía el programa en un paquete de tarjetas después de pasar uno o varios días, a continuación se llevaba a una ventanilla del centro de computación para procesar el programa, después de cierto tiempo de días se recogía el paquete de tarjetas y un listado del programa que normalmente indicaba errores del programa, se corregía y se repetía el proceso descrito. A este modo de hacer y ejecutar los programas se les llamo sistemas de computación en batch o de lotes. 
Cuando surgen los sistemas interactivos de tiempo compartido y de las redes locales, el programador interacciona con una terminal o una computadora personal conectada a una computadora central de gran poder de computo, para hacer y ejecutar sus programas, aumentando la eficiencia en la programación. Posteriormente en las redes locales y amplias las computadoras personales se convierten en una computadora servidor de gran poder de computo y se conectan las computadoras cliente para compartir los recursos de la red, como impresoras y bases de datos, así surge la programación distribuida de aplicaciones cliente-servidor. 
Hoy en día con la computadora de un teléfono inteligente continúa la programación distribuida de aplicaciones cliente-servidor, pero también las aplicaciones locales. Los programas se crean y prueban en una computadora personal utilizando algún lenguaje como java, c++  u otro y cuando están sin errores se transfieren al teléfono inteligente por cable usb o de forma inalámbrica. Pero ahora se ha llegado a utilizar al propio teléfono celular como una herramienta para desarrollar sus propios programas, increíble que ahora la programación de una computadora se realice en la mano del hombre, recordemos que un principio el ciclo de desarrollo de un programa era de varios días y ahora se reduce a muy poco tiempo, dependiendo de lo complicado que sea el programa. Ahora cualquier persona que tenga un teléfono inteligente con Android 2.2 puede aprender a programar su propia computadora que está en el teléfono inteligente.
Microcomputadora
Una de las primeras computadoras personales que se construyeron  y  utilizo  el lenguaje basic, fue la Radioshack TRS-I. Fue una computadora con un procesador central Z80, memoria rom de 4Kbytes donde tenía el sistema operativo rudimentario y el lenguaje basic y una ram de 12Kbytes donde se ejecutaban los programas, los dispositivos de entrada un teclado y de salida una pantalla de tv y el cassette para guardar programas y datos era un dispositivo de entrada y salida. Para funcionar tiene el sistema operativo en rom  y los programas de aplicaciones se crean y almacenan en cassettes. El sistema operativo con basic es un programa principal que controla la computadora. Un programa es una secuencia de instrucciones, que bajo el control del procesador central Z80, son obtenidos de la memoria una a una y ejecutadas. Las instrucciones son aritméticas, lógicas, de decisión y control, de entrada y salida, entre otras instrucciones. Cada instrucción a nivel de máquina es una secuencia de unos y ceros. Cada instrucción tiene una parte que indica la operación a realizar (aritmética, lógica, de decisión, etc.) y otra parte la dirección en memoria de los operandos o datos. Programar en este nivel de máquina de puros unos y ceros sería muy difícil pero no imposible. Para ayudar a la programación se inventaron los lenguajes de programación de alto nivel como el BASIC, donde las instrucciones, por ejemplo las aritméticas se identifican con nombres de ADD o +, SUBSTRACT o -, MULTIPLY o * , DIVIDE o /. Una vez escrito y terminado el programa es traducido o compilado  por otro programa, en este caso el programa basic es un intérprete que los convierte a un lenguaje de máquina del Z80 y al ejecutarse puede obtener los resultados deseados.
Teléfono Inteligente
Ahora vamos analizar un teléfono móvil o inteligente como el Samsung Galaxy mini. Es una computadora de un teléfono móvil que tiene la función principal de comunicaciones telefónicas y computaciones. Tiene un procesador central Qualcomm MSM7227 con l arquitectura ARMv6 a 600Mhz y un procesador GPU Adreno 200, memoria ram de 384Mbytes, en rom  de 512 Mbytes, 164 Mbytes de memoria interna y otra externa de un microSD de 2Gbytes hasta 32 Gbytes, dispositivos de entrada y salida, la pantalla de salida del teléfono también hace la función de entrada como teclado. Para funcionar tiene un sistema operativo y programas de aplicación, como sistema operativo tiene android 2.2 un descendiente de Linux. El sistema operativo es un programa que controla todo el teléfono. Cada programa es una secuencia de instrucciones del procesador arm6, de unos y ceros. Cada instrucción a nivel de máquina tiene una parte que indica la operación a realizar y la otra parte la dirección de memoria de los operandos o datos. Pero también tiene lenguajes de alto nivel para programar como Java. Cuando se escribe un programa en java, se compila y se deja en un lenguaje de una máquina virtual java, en el caso de android hace una segunda traducción para llevarlo a una máquina virtual dalvik optimizado para teléfonos móviles o inteligentes. Para ejecutarse utiliza un programa intérprete del sistema operativo android que traduce las instrucciones dalvik a instrucciones del procesador arm6 y las ejecuta. Hermosa secuencia, nada sencilla pero así trabaja la computadora del teléfono móvil. 

Desarroollo de programas con Eclipse y Java en una PC
Actualmente para crear o desarrolla programas de aplicación para teléfonos móviles se utiliza una computadora personal, una laptop que tienen como sistema operativo Windows o Linux, u otro. Primero se debe de bajar e instalarse  el SDK7 de java, un programa de desarrollo como eclipse3, el SDK de android y el plug de SDK para eclipse3. Hay muchos sitios de internet que detallan el proceso de instalación y uso. Para realizar un programa para teléfonos android, primero se usa eclipse, se crea un proyecto, se escribe el programa, se compila si hay errores se corrigen, si no hay errores, lanza un simulador de un telefóno con android, lento la primera vez, y se ejecuta el programa y lo deja en la carpeta bin. Después el programa binario de un archivo apk se lleva al teléfono móvil ya sea con una interface usb o usando dropbox que es una nube o cloud, donde se almacena los archivos y se transfieren a diferentes computadoras que seleccionamos y que puede  incluir a un teléfono móvil. En cualquier caso al descargarse en el teléfono se da click sobre el programa binario apk, se instala y listo se puede ejecutar y usarse. Una secuencia un poco larga.

Desarrollo de Programas con AIDE y Java en un Telefóno Inteligente
Pero  a sucedido algo maravilloso y es que en un teléfono móvil ya se puede programar con Java y AIDE, tal como él, samsug galaxy mini con android2.2 el nombre de AIDE significa Android Integrated Development Environmente, es decir algo parecido a eclipce, es un sistema para desarrollar aplicaciones de android en nuestro propio teléfono, claro existe pequeñas limitaciones físicas en los teléfonos móviles, un poco menos en las tablet, pero así empezaron las pc y terminaron por eliminar los mainframes o grandes computadoras. Para desarrollar aplicaciones con AIDE solo se necesita un teléfono móvil con android2.2, conectarse al mercado de android, buscar AIDE que es libre, bajarlo e instalarlo, y listo ya tenemos la herramienta para hacer programas en nuestro propio teléfono móvil. Primero ejecutamos AIDE, si es la primera vez, crea un proyecto para el programa hola mundo y a partir de ahí se puede crear otros programas, maravilloso. Como la calculadora simple que programe y vamos a usar más adelante.
Increíble y maravilloso que hoy en una mano tengamos una computadora de un teléfono móvil, en mi caso mi Samsung galaxy mini. Todo esto, lo repito otra vez, resultado de la evolución y desarrollo humano. Así como el hombre primitivo uso la tecnología de la mano para hacer utensilios, el hacha, lanza, el arco y flechas, y usarlo para sobrevivir. Hoy día miles de hombres con diversos intereses han desarrollado y creado la tecnología electrónica, de computación y de comunicaciones, y las  tres  se han integrado para crear la computadora de un teléfono móvil o teléfono inteligente y está disponible en la mano del hombre inteligente, para una multitud de usos: hablar por teléfonos, enviar mensajes, cálculos matemáticos, navegar por  internet, oír música o la radio, ver televisión, uso del gps, ver videos en youtube, redes sociales como facebook, entretenimiento, etc. Debemos valorar al propio hombre como resultado de la evolución y desarrollo  humano. De valorar la inteligencia de los hombres que han contribuido en las diferentes ramas del conocimiento humano y de crear la ciencia y tecnología, para ofrecer a la humanidad una mejor vida y comodidad, que nunca tuvieron nuestros antepasados, los hombres primitivos, hagamos reconocimiento a ellos que fueron los que iniciaron el diseño de la computadora mental humana y que posteriormente el hombre ha tratado de crear un modelo o simulación de la mente humana, al crear la computadora y que culmina ahora en una computadora de un teléfono móvil.
Computadora Mental Humana
En mi página anterior hablamos de la computadora mental del hombre e hicimos una descripción de la mente humana  y dijimos que el cerebro es el hardware y la red neuronal y subredes forman el software de la computadora mental humana que contiene todos los programas y sistema operativo que controlan todo el cuerpo y la interacción con su medio ambiente. Algunos piensan que comparar o igualar el cerebro-mente a una computadora es degradante, puede ser que lo sea, pero veamos como realizamos operaciones aritméticas, mentalmente podemos hacer operaciones sencillas de suma 2+2=4, de resta 10-5, multiplicación 5x5=25 y división de 100/10=10.  Pero cuando aumentamos las cifras, muy pocas personas lo pueden hacer. Por ejemplo para multiplicar 54678934 x23451 ya usamos un medio externo como una hoja y un lápiz o lapicero para escribir,  este lo usamos para anotar las cantidades y además seguimos una secuencia de pasos de un procedimiento o programa para multiplicar, si no aprendemos las tablas de multiplicar o el procedimiento o programa no podremos realizar la multiplicación.         
También una computadora si no se programa para solucionar las operaciones matemáticas, nunca resolverá la operación. La diferencia principal es que la computadora es mucho más rápida y nunca se cansa,  puede programarse para operaciones rutinarias y sumamente complicadas con grandes cantidades. Creo que esta fue una de las  razones principales de haber inventado la computadora. 

Para ver de una forma real, vamos a utilizar un teléfono móvil como el Samsung galaxy mini, con un programa simple de una calculadora decimal que programe con AIDE en mi propio teléfono, que realiza las operaciones aritméticas decimales de sumar 2+2=4, restar 10-5=5, multiplicar 5x5=25 y dividir 100/10=10. Y operaciones más complicadas, que debido a sus resultados de cantidades grandes, se utiliza la representación exponencial E que significa 10 elevado a una potencia, por ejemplo la división de 566789346786543365.4567 entre 236748451.4678 da 2.3940572E9 o sea 2.3940572x10 a la potencia de 9 y a partir del punto se cuentan 9 posiciones a la derecha y queda el resultado en 2394057200.00. Para estas operaciones no necesitamos una calculadora, mucho menos un computadora. Pero aumentemos las cifras, posiblemente se realicen, pero aumentemos las veces de hacer las operaciones, resulta monótono y cansado. La idea principal es de cómo utilizar un programa que se hizo con AIDE y en la próxima página del blog, veré como se programa con java en AIDE y de hacer el programa de la calculadora en forma detallada.