snkeduar

Cuantas veces los programadores novatos queremos hacer algo y no podemos, ya sea porque no nos gusta leer, por que no encontramos informacion, manuales, tutoriales o si la encontramos no le entendemos por que no esta completa. bueno pues lo que me he propuesto es hacer tutoriales de visual basic .net pero a manera que sea facil para ustedes por ahora solo tengo cinco y sigo creando para subirlos y compartirlos con ustedes, espero que les agraden y que comenten de que podria hacer los tuto para subirlos. Hola Mundo ESTE ESTA EN 2010 pero si lo hacen con 2008 igual y funciona suma de dos numeros crear un mini validador de datos (validar un usuario es simple) validar entrada de datos con error provider muy bueno Espero sus comentarios y sus sugerencias estoy para ayudarlos codigo ancii thesnkeduar asi me encuentran en youtube

Espero que les guste el video link: http://www.youtube.com/watch?v=Pr4XCT37RSo&list=UUV1pVPANGJs0Zs-JXSaNtvw&index=1&feature=plcp

Descarga de herramientas necesarios para programar para Android. 1 - Primero debemos instalar el compilador de Java y la máquina virtual. Estas herramientas las podemos descargar de: Java SE Development Kit (JDK). 2 - El segundo paso es la descarga del ADT (que contiene todo lo necesario para comenzar el desarrollo de aplicaciones en Android), lo hacemos del sitio (descargar el de 32 o 64 bit según el JDK de Java que ya tenemos instalado del paso anterior): Android SDK. 3 - El tercer paso es descomprimir el ADT, por ejemplo en la raiz de c: 4 - El cuarto paso es ejecutar el Eclipse: Nos dirigimos a la carpetas creadas cuando descomprimimos el ADT y vemos que tenemos dos carpetas: eclipse sdk Entramos a la carpeta eclipse y ejecutamos eclipse.exe Debe aparecer una ventana de inicio similar a esta: Nos pide seguidamente la carpeta donde deseamos ir almacenando los proyectos que desarrollemos: Ahora ya estamos en el entorno que tiene una vista similar a esta (recordemos que es el Eclipse con algunos cambios desarrollados por Google), la primera vez que ingresamos nos aparece una pantalla de bienvenida pero podemos cerrarla haciendo clic en la cruz de la pestaña y ya tenemos el entorno de trabajo: 7 - Por último debemos crear el AVD (Android Virtual Device) para ello nos dirigimos a la opción Window -> Android Virtual Device Manager. En este diálogo debemos crear el emulador de Android (presionamos el botón New...): En este diálogo asignamos un nombre a nuestro AVD, elegimos un dispositivo (que no sea tan grande ya que no entrara en pantalla, podemos probar con WVGA(480,800)), lo enlazamos con la versión de SDK respectivo, fijamos un tamaño al SD Card: Ya tenemos todo configurado para el desarrollo de aplicaciones Android. 2 - Pasos para crear el primer proyecto Android Ya tenemos todo lo necesario instalado para implementar el primer proyecto. Desde el menú de opciones: File -> New -> Android Application Project En este diálogo especificamos el nombre de la aplicación y proyecto (pueden ser iguales) y el nombre del paquete java donde se almacenarán los archivos java que creemos (normalmente la url de su empresa al revés). Ahora empezaremos a presionar el botón next para pasar a otras configuraciones de nuestra aplicación, por el momento dejaremos todos los valores por defecto en cada una de los diálogos que aparece (son 5 diálogos actualmente), en el último diálogo debe aparecer el botón "Finish" el cual presionamos. El ADT nos genera todos los directorios y archivos básicos para iniciar nuestro proyecto: No haremos en este momento un análisis del significado y objetivo de cada uno de estos directorios y archivos generados, sino a medida que avancemos con este curso iremos viendo en forma puntual y profunda. La interfaz visual de nuestro programa para Android se almacena en un archivo XML en la carpeta res, subcarpeta layout y el archivo se llama activity_main.xml. En esta carpeta tenemos creada nuestra primer pantalla. Al seleccionar este archivo el ADT nos permite visualizar el contenido en "vista de diseño (Graphical Layout)": Si seleccionamos la otra pestaña podemos visualizar el archivo activity_main.xml en formato de texto: El ADT ya insertó un control de tipo RelativeLayout que permite ingresar controles visuales alineados a los bordes y a otros controles que haya en la ventana (más adelante analizaremos este layout) Ya veremos que podemos modificar todo este archivo para que se adapte a la aplicación que queremos desarrollar. Luego contenido en el control RelativeLayout hay otro control de tipo TextView que es básicamente una etiqueta o label que mostrará en pantalla el valor almacenado en la propiedad text. Podemos modificar directamente el archivo xml o en "vista de diseño" modificar los valores de las propiedades. Elegimos nuevamente la pestaña "Graphical Layout" y seleccionamos el TextView con el mouse y vemos que en la parte derecha de la pantalla aparece una ventana llamada "properties": Y estando seleccionado el TextView buscamos la propiedad Text y cargamos: "Mi primer programa para Android" y presionamos enter, podemos ver que se actualiza la vista: Con esto ya podemos probar nuestra primer aplicación para un dispositivo Android. SELECCIONAMOS con el mouse en la ventana de la izquierda (Package Explorer) el proyecto001 y presionamos el ícono de Run (triángulo verde) o desde el menú. Seleccionamos que se ejecute como aplicación "Android Application". Ahora se abrirá el AVD(Android Virtual Device) esto tarda bastante tiempo, es muy importante recordar que luego de ver ejecutándose el programa NO debemos cerrar el AVD para que la próxima ejecución se inicie más rápido (podemos minimizar el AVD) Ahora podemos ver nuestra primer aplicación corriendo en el emulador de Android: Como hemos visto el ADT nos genera en forma automática todas las carpetas y archivos básicos que necesitamos en un principio. En el siguiente concepto podremos empezar a programar verdaderamente. El único objetivo de este ejercicio es recordar los pasos para crear un proyecto. 3 - Captura del clic de un botón Problema: Realizar la carga de dos números en controles de tipo EditText. Mostrar un mensaje que solicite la carga de los valores. Disponer un Button para sumar los dos valores ingresados. Mostrar el resultado en un tercer TextView. La interfaz visual debe quedar algo semejante a esto: Veamos paso a paso como creamos la interfaz visual de nuestro programa. Primero borramos el TextView que aparece por defecto cuando se crea un proyecto con el ADT. Ahora desde la ventana "Palette" seleccionamos de la pestaña "Form Widgets" el control "TextView" y lo arrastramos a la ventana de diseño de nuestra interfaz: Ahora lo seleccionamos y en la ventana de propiedades especificamos la propiedad text (como habíamos visto anteriormente) disponemos el texto "Ingrese el primer valor:": También vamos a especificar la propiedad "Id", la misma aparece primera en la paleta de propiedades y le asignaremos el valor @+id/tv1 (el nombre es el que se indica luego de la barra es decir cambiamos textView1 por tv1) Cuidado de no borrar @+id/ Hemos entonces asignado como nombre a este objeto: tv1 (recordemos que se trata de un objeto de la clase TextView) Ahora de la paleta de componentes seleccionamos la pestaña "Text Fields" y arrastramos el primero (el que tiene la etiqueta abc) En la ventana de properties estando seleccionado el EditText configuramos la propiedad Id... con el nombre et1 (este nombre haremos referencia posteriormente desde Java) Efectuamos los mismos pasos para crear el segundo TextView y EditText (inicializamos las propiedades respectivas) Definimos los id con los nombres tv2 y et2, el resultado visual debe ser algo semejante a esto: De la pestaña "Form Widgets" arrastramos un control de tipo "Button": Inicializamos la propiedad text con el texto "Sumar" y la propiedad id la dejamos con el valor ya creado llamado "button1". Para terminar con nuestra interfaz visual arrastramos un tercer objeto de tipo TextView y definimos la propiedad id con el valor "tv3" y la propiedad text con el texto "resultado", recordemos que la interfaz final debe ser semejante a esta: Si en este momento ejecutamos la aplicación aparece la interfaz visual correctamente pero cuando presionemos el botón no mostrará la suma. Es fundamental una vez finalizada la interfaz visual proceder a grabarla (icono de los diskettes) o la opción File->Save para que se actualicen los archivos que se generan automáticamente. Hasta ahora hemos trabajado solo con el archivo xml (activity_main.xml) donde se definen los controles visuales de la ventana que estamos creando. Abrimos seguidamente el archivo MainActivity.java que lo podemos ubicar en la carpeta src: La clase MainActivity hereda de la clase Activity. La clase Activity representa una ventana de Android y tiene todos los métodos necesarios para crear y mostrar los objetos que hemos dispuesto en el archivo xml. El código fuente de la clase MainActivity.java es: package com.javaya.proyecto002; import android.os.Bundle; import android.app.Activity; import android.view.Menu; public class MainActivity extends Activity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); } @Override public boolean onCreateOptionsMenu(Menu menu) { // Inflate the menu; this adds items to the action bar if it is present. getMenuInflater().inflate(R.menu.activity_main, menu); return true; } } Como mínimo se debe sobrescribir el método onCreate heredado de la clase Activity donde procedemos a llamar la método setContentView pasando como referencia una valor almacenado en una constante llamada activity_main contenida en una clase llamada layout que a su vez la contiene una clase llamada R (veremos más adelante que el ADT se encarga de crear la clase R en forma automática y sirve como puente entre el archivo xml y nuestra clase MainActivity) Luego veremos el otro método onCreateOptionsMenu. Captura de eventos. Ahora viene la parte donde definimos variables en java donde almacenamos las referencias a los objetos definidos en el archivo XML. Definimos tres variables, dos de tipo EditText y finalmente una de tipo TextView (estas dos clases se declaran en el paquete android.widget, es necesario importar dichas clases para poder definir las variables de dichas clases): package com.javaya.proyecto002; import android.app.Activity; import android.os.Bundle; import android.view.Menu; import android.widget.EditText; import android.widget.TextView; public class MainActivity extends Activity { private EditText et1,et2; private TextView tv3; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); } @Override public boolean onCreateOptionsMenu(Menu menu) { // Inflate the menu; this adds items to the action bar if it is present. getMenuInflater().inflate(R.menu.activity_main, menu); return true; } } La forma más fácil de importar las clases EditText y TextView es tipear las dos líneas: private EditText et1,et2; private TextView tv3; y luego presionar las teclas Control-Shift-O Esto hace que se escriban automáticamente los dos import: import android.widget.EditText; import android.widget.TextView; Los nombres que le dí a los objetos en este caso coinciden con la propiedad id (no es obligatorio): private EditText et1,et2; private TextView tv3; No definimos TextView para los dos mensajes "Ingrese el primer valor" e "Ingrese el segundo valor" ya que no necesitaremos interactuar con ellos. También veremos que el objeto de la clase Button no es necesario definir un atributo sino que desde el archivo XML inicializaremos la propiedad OnClick. En el método onCreate debemos enlazar estas variables con los objetos definidos en el archivo XML, esto se hace llamando al método findViewById: public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.main); et1=(EditText)findViewById(R.id.et1); et2=(EditText)findViewById(R.id.et2); tv3=(TextView)findViewById(R.id.tv3); } Al método findViewById debemos pasar la constante creada en la clase R (recordemos que se crea automáticamente esta clase) el nombre de la constante si debe ser igual con el nombre de la propiedad del objeto creado en el archivo XML. Como la clase findViewById retorna una clase de tipo View luego debemos utilizar el operador cast (es decir le antecedemos entre paréntesis el nombre de la clase) Ya tenemos almacenados en las variables las referencias a los tres objetos que se crean al llamar al método:setContentView(R.layout.main); . Ahora planteamos el método que se ejecutará cuando se presione el botón (el método debe recibir como parámetro un objeto de la clase View) En nuestro ejemplo lo llamé sumar: package com.javaya.proyecto002; import android.app.Activity; import android.os.Bundle; import android.view.Menu; import android.view.View; import android.widget.EditText; import android.widget.TextView; public class MainActivity extends Activity { private EditText et1,et2; private TextView tv3; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); et1=(EditText)findViewById(R.id.et1); et2=(EditText)findViewById(R.id.et2); tv3=(TextView)findViewById(R.id.tv3); } @Override public boolean onCreateOptionsMenu(Menu menu) { // Inflate the menu; this adds items to the action bar if it is present. getMenuInflater().inflate(R.menu.activity_main, menu); return true; } //Este método se ejecutará cuando se presione el botón public void sumar(View view) { } } Debemos importar lar clase View (Control-Shift-O) Ahora debemos ir al archivo XML e inicializar la propiedad OnClick del objeto button1 con el nombre del método que acabamos de crear (este paso es fundamental para que el objeto de la clase Button pueda llamar al método sumar que acabamos de crear): Finalmente implementaremos la lógica para sumar los dos valores ingresados en los controles EditText: public void sumar(View view) { String valor1=et1.getText().toString(); String valor2=et2.getText().toString(); int nro1=Integer.parseInt(valor1); int nro2=Integer.parseInt(valor2); int suma=nro1+nro2; String resu=String.valueOf(suma); tv3.setText(resu); } Extraemos el texto de los dos controles de tipo EditText y los almacenamos en dos variables locales de tipo String. Convertimos los String a tipo entero, los sumamos y el resultado lo enviamos al TextView donde se muestra la suma (previo a convertir la suma a String) La clase completa queda entonces como: package com.javaya.proyecto002; import android.app.Activity; import android.os.Bundle; import android.view.Menu; import android.view.View; import android.widget.EditText; import android.widget.TextView; public class MainActivity extends Activity { private EditText et1,et2; private TextView tv3; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); et1=(EditText)findViewById(R.id.et1); et2=(EditText)findViewById(R.id.et2); tv3=(TextView)findViewById(R.id.tv3); } @Override public boolean onCreateOptionsMenu(Menu menu) { // Inflate the menu; this adds items to the action bar if it is present. getMenuInflater().inflate(R.menu.activity_main, menu); return true; } //Este método se ejecutará cuando se presione el botón public void sumar(View view) { String valor1=et1.getText().toString(); String valor2=et2.getText().toString(); int nro1=Integer.parseInt(valor1); int nro2=Integer.parseInt(valor2); int suma=nro1+nro2; String resu=String.valueOf(suma); tv3.setText(resu); } } Si ejecutamos nuestro programa podemos ver ahora que luego de cargar dos valores al presionar el botón aparece en el tercer TextView el resultado de la suma de los dos EditText: 4 - Controles RadioGroup y RadioButton El objetivo de este concepto es practicar la implementación de un programa que requiera controles de tipo RadioButton para seleccionar una actividad. Aprenderemos como agrupar un conjunto de RadioButton y verificar cual está seleccionado. Problema: Realizar la carga de dos números en controles de tipo EditText. Mostrar un mensaje que solicite la carga de los valores. Disponer dos controles de tipo RadioButton para seleccionar si queremos sumar o restar dichos valores. Finalmente mediante un control de tipo Button efectuamos la operación respectiva. Mostramos el resultado en un TextView. El problema es similar al anterior. Para disponer los controles de tipo RadioButton debemos en realidad primero insertar un control de tipo RadioGroup (este control se encuentra en la paleta de componentes en la pestaña Form Widgets): Cuando arrastramos el control RadioGroup al formulario se generan automáticamente 3 objetos de la clase RadioButton contenidos dentro del RadioGroup, podemos fácilmente identificar que los controles RadioButton pertenecen a dicho RadioGroup viendo la ventana de "Outline" del Eclipse (donde nos muestra todos los controles insertados hasta el momento): Nuestro problema solo requiere dos controles de tipo RadioButton. Para borrarlo lo podemos hacer directamente del formulario seleccionándolo y presionando la tecla delete o seleccionándolo desde la ventana "Outline" y luego presionando la tecla delete . Ahora a los dos controles de tipo RadioButton definimos sus id (los llamaremos r1 y r2 respectivamente) Cambiamos sus propiedades text por los textos "sumar" y "restar". No olvidemos también cambiar los id de los controles EditText por et1 y et2 (igual que en el problema anterior) Por último agreguemos un botón y un TextView para mostrar el resultado Inicializamos las propiedades del botón con los valores: id : button1 text : operar Y el tercer TextView con los valores: id : tv3 text : resultado Podemos controlar en la ventana "Outline" el id definido para cada control (tv1, et1, tv2, et2, radioGroup1, r1, r2, button1, tv3) También podemos observar de que clase es cada control visual y el texto de la propiedad text para aquellos controles que tienen sentido su inicialización. Si nuestro problema requería más de 3 RadioButton deberíamos arrastrar dentro del RadioGroup otros controles de tipo RadioButton que se encuentran también en la pestaña de "Form Widgets" Captura del evento clic del button e identifiación del RadioButton seleccionado. El código fuente de la clase MaintActivity es: package com.javaya.proyecto003; import android.app.Activity; import android.os.Bundle; import android.view.Menu; import android.view.View; import android.widget.EditText; import android.widget.RadioButton; import android.widget.TextView; public class MainActivity extends Activity { private EditText et1,et2; private TextView tv3; private RadioButton r1,r2; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); et1=(EditText)findViewById(R.id.et1); et2=(EditText)findViewById(R.id.et2); tv3=(TextView)findViewById(R.id.tv3); r1=(RadioButton)findViewById(R.id.r1); r2=(RadioButton)findViewById(R.id.r2); } @Override public boolean onCreateOptionsMenu(Menu menu) { // Inflate the menu; this adds items to the action bar if it is present. getMenuInflater().inflate(R.menu.activity_main, menu); return true; } //Este método se ejecutará cuando se presione el botón public void operar(View view) { String valor1=et1.getText().toString(); String valor2=et2.getText().toString(); int nro1=Integer.parseInt(valor1); int nro2=Integer.parseInt(valor2); if (r1.isChecked()==true) { int suma=nro1+nro2; String resu=String.valueOf(suma); tv3.setText(resu); } else if (r2.isChecked()==true) { int resta=nro1-nro2; String resu=String.valueOf(resta); tv3.setText(resu); } } } Primero debemos enlazar el objeto button1 con el método operar. Para esto similar al problema anterior seleccionamos el control button1 y cambiamos la propiedad OnClick por el valor operar (si no hacemos esto nunca se ejecutará el método operar de la clase MainActivity) Como podemos ver el código fuente es igual al problema anterior. Tenemos dos objetos más que debemos inicializar en el método onCreate: r1=(RadioButton)findViewById(R.id.r1); r2=(RadioButton)findViewById(R.id.r2); Las variables r1 y r2 son de la clase RadioButton y son necesarios en el método operar para verificar cual de los dos RadioButton están seleccionados. La clase RadioButton tiene un método llamado isChecked que retorna true si dicho elemento está seleccionado: public void operar(View view) { String valor1=et1.getText().toString(); String valor2=et2.getText().toString(); int nro1=Integer.parseInt(valor1); int nro2=Integer.parseInt(valor2); if (r1.isChecked()==true) { int suma=nro1+nro2; String resu=String.valueOf(suma); tv3.setText(resu); } else if (r2.isChecked()==true) { int resta=nro1-nro2; String resu=String.valueOf(resta); tv3.setText(resu); } } 5 - Control CheckBox El objetivo de este concepto es practicar lo visto hasta ahora e incorporar el control visual CheckBox Problema: Realizar la carga de dos números en controles de tipo EditText. Mostrar un mensaje que solicite la carga de los valores. Disponer dos controles de tipo CheckBox para seleccionar si queremos sumar y/o restar dichos valores. Finalmente mediante un control de tipo Button efectuamos la operación respectiva. Mostramos el o los resultados en un TextView. Lo nuevo en este problema es la inserción de dos objetos de la clase CheckBox que se encuentra en la pestaña "Form Widgets": Luego la interfaz gráfica final para este problema y los nombres de los controles los podemos ver en la ventana "Outline": No olvidemos inicializar la propiedad OnClick del objeto button1 con el valor "operar" (es el nombre del método a ejecutarse cuando se presione el botón y lo implementa la clase que hacemos) Código fuente: package com.androiya.proyecto004; import android.app.Activity; import android.os.Bundle; import android.view.Menu; import android.view.View; import android.widget.CheckBox; import android.widget.EditText; import android.widget.TextView; public class MainActivity extends Activity { private EditText et1,et2; private TextView tv3; private CheckBox checkBox1,checkBox2; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); et1=(EditText)findViewById(R.id.et1); et2=(EditText)findViewById(R.id.et2); tv3=(TextView)findViewById(R.id.tv3); checkBox1=(CheckBox)findViewById(R.id.checkBox1); checkBox2=(CheckBox)findViewById(R.id.checkBox2); } @Override public boolean onCreateOptionsMenu(Menu menu) { // Inflate the menu; this adds items to the action bar if it is present. getMenuInflater().inflate(R.menu.activity_main, menu); return true; } //Este método se ejecutará cuando se presione el botón public void operar(View view) { String valor1=et1.getText().toString(); String valor2=et2.getText().toString(); int nro1=Integer.parseInt(valor1); int nro2=Integer.parseInt(valor2); String resu=""; if (checkBox1.isChecked()==true) { int suma=nro1+nro2; resu="La suma es: "+ suma; } if (checkBox2.isChecked()==true) { int resta=nro1-nro2; resu=resu + " La resta es: "+ resta; } tv3.setText(resu); } } Definimos dos objetos de la clase CheckBox como atributos de la clase: private CheckBox checkBox1,checkBox2; En el método onCreate los inicializamos con los objetos definidos en el archivo XML: checkBox1=(CheckBox)findViewById(R.id.checkBox1); checkBox2=(CheckBox)findViewById(R.id.checkBox2); En el método operar debemos definir dos if a la misma altura ya que los dos controles de tipo CheckBox pueden estar seleccionados simultaneamente. Definimos una variable de tipo String y la inicializamos con cadena vacía para el caso en que los dos CheckBox no estén seleccionados: String resu=""; if (checkBox1.isChecked()==true) { int suma=nro1+nro2; resu="La suma es: "+ suma; } if (checkBox2.isChecked()==true) { int resta=nro1-nro2; resu=resu + " La resta es: "+ resta; } tv3.setText(resu); 6 - Control Spinner El objetivo de este concepto es practicar lo visto hasta ahora e incorporar el control visual Spinner El control Spinner muestra una lista de String y nos permite seleccionar uno de ellos. Cuando se lo selecciona se abre y muestra todos sus elementos para permitir seleccionar uno de ellos. Problema: Realizar la carga de dos números en controles de tipo EditText. Mostrar un mensaje que solicite la carga de los valores. Disponer un control de tipo Spinner que permita seleccionar si queremos sumar, restar, multiplicar o dividir dichos valores. Finalmente mediante un control de tipo Button efectuamos la operación respectiva. Mostramos el resultado en un TextView. Lo nuevo en este problema es la inserción de un control de tipo Spinner que se encuentra en la pestaña "Form Widgets": Definimos la propiedad id con el valor spinner1 (valor por defecto). En la siguiente imagen en la ventana "Outline" de Eclipse podemos observar los objetos dispuestos en el formulario, sus Id, sus textos y de que clase son cada uno: No olvidemos inicializar la propiedad OnClick del objeto button1 con el valor "operar" (dicho nombre es el método que debemos implementar) Código fuente: package com.javaya.proyecto005; import android.app.Activity; import android.os.Bundle; import android.view.Menu; import android.view.View; import android.widget.ArrayAdapter; import android.widget.EditText; import android.widget.Spinner; import android.widget.TextView; public class MainActivity extends Activity { private Spinner spinner1; private EditText et1,et2; private TextView tv3; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); et1=(EditText)findViewById(R.id.et1); et2=(EditText)findViewById(R.id.et2); tv3=(TextView)findViewById(R.id.tv3); spinner1 = (Spinner) findViewById(R.id.spinner1); String []opciones={"sumar","restar","multiplicar","dividir"}; ArrayAdapter<String> adapter = new ArrayAdapter<String>(this,android.R.layout.simple_spinner_item, opciones); spinner1.setAdapter(adapter); } @Override public boolean onCreateOptionsMenu(Menu menu) { // Inflate the menu; this adds items to the action bar if it is present. getMenuInflater().inflate(R.menu.activity_main, menu); return true; } //Este método se ejecutará cuando se presione el botón public void operar(View view) { String valor1=et1.getText().toString(); String valor2=et2.getText().toString(); int nro1=Integer.parseInt(valor1); int nro2=Integer.parseInt(valor2); String selec=spinner1.getSelectedItem().toString(); if (selec.equals("sumar") { int suma=nro1+nro2; String resu=String.valueOf(suma); tv3.setText(resu); } else if (selec.equals("restar") { int resta=nro1-nro2; String resu=String.valueOf(resta); tv3.setText(resu); } else if (selec.equals("multiplicar") { int multi=nro1*nro2; String resu=String.valueOf(multi); tv3.setText(resu); } else if (selec.equals("dividir") { int divi=nro1/nro2; String resu=String.valueOf(divi); tv3.setText(resu); } } } Definimos un objeto de la clase Spinner: private Spinner spinner1; En el método onCreate obtenemos la referencia al control visual declarado en el archivo XML: spinner1=(Spinner)findViewById(R.id.spinner1); Definimos un vector con la lista de String que mostrará el Spinner: String []opciones={"sumar","restar","multiplicar","dividir"}; Definimos y creamos un objeto de la clase ArrayAdapter: ArrayAdapter<String> adapter = new ArrayAdapter<String>(this,android.R.layout.simple_spinner_item, opciones); Al constructor le pasamos como primer parámetro la referencia de nuestro Activity (this), el segundo parámetro indica el tipo de Spinner, pudiendo ser las constantes: android.R.layout.simple_spinner_item android.R.layout.simple_spinner_dropdown_item El tercer parámetro es la referencia del vector que se mostrará: Luego llamamos al método setAdapter de la clase Spinner pasando la referencia del objeto de la clase ArrayAdapter que acabamos de crear: spinner1.setAdapter(adapter); En el método operar que se ejecuta cuando presionamos el botón procedemos a extraer el contenido seleccionado del control Spinner: String selec=spinner1.getSelectedItem().toString(); Luego mediante una serie de if anidados verificamos si debemos sumar, restar, multiplicar o dividir: if (selec.equals("sumar") { int suma=nro1+nro2; String resu=String.valueOf(suma); tv3.setText(resu); } else if (selec.equals("restar") { int resta=nro1-nro2; String resu=String.valueOf(resta); tv3.setText(resu); } else if (selec.equals("multiplicar") { int multi=nro1*nro2; String resu=String.valueOf(multi); tv3.setText(resu); } else if (selec.equals("dividir") { int divi=nro1/nro2; String resu=String.valueOf(divi); tv3.setText(resu); } 7 - Control ListView El control ListView a diferencia del Spinner que se cierra luego de seleccionar un elemento permanecen visibles varios elementos (se lo utiliza cuando hay que mostrar muchos elementos) Si la lista no entra en el espacio que hemos fijado para el ListView nos permite hacer scroll de los mismos. El control ListView se encuentra en la pestaña "Compositive". Problema: Disponer un ListView con los nombres de paises de sudamérica. Cuando se seleccione un país mostrar en un TextView la cantidad de habitantes del país seleccionado. La interfaz visual a implementar es la siguiente (primero disponemos un TextView (llamado tv1) y un ListView (llamado listView1)): Código fuente: package com.javaya.proyecto006; import android.app.Activity; import android.os.Bundle; import android.view.Menu; import android.view.View; import android.widget.AdapterView; import android.widget.AdapterView.OnItemClickListener; import android.widget.ArrayAdapter; import android.widget.ListView; import android.widget.TextView; public class MainActivity extends Activity { private String[] paises = { "Argentina", "Chile", "Paraguay", "Bolivia", "Peru", "Ecuador", "Brasil", "Colombia", "Venezuela", "Uruguay" }; private String[] habitantes = { "40000000", "17000000", "6500000", "10000000", "30000000", "14000000", "183000000", "44000000", "29000000", "3500000" }; private TextView tv1; private ListView lv1; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); tv1=(TextView)findViewById(R.id.tv1); lv1 =(ListView)findViewById(R.id.listView1); ArrayAdapter <String> adapter = new ArrayAdapter<String>(this,android.R.layout.simple_list_item_1, paises); lv1.setAdapter(adapter); lv1.setOnItemClickListener(new OnItemClickListener() { @Override public void onItemClick(AdapterView<?> parent, View v, int posicion, long id) { tv1.setText("Población de "+ lv1.getItemAtPosition(posicion) + " es "+ habitantes); } }); } @Override public boolean onCreateOptionsMenu(Menu menu) { // Inflate the menu; this adds items to the action bar if it is present. getMenuInflater().inflate(R.menu.activity_main, menu); return true; } } Primero definimos dos vectores paralelos donde almacenamos en uno los nombres de paises y en el otro almacenamos la cantidad de habitantes de dichos paises: private String[] paises={"Argentina","Chile","Paraguay","Bolivia","Peru", "Ecuador","Brasil","Colombia","Venezuela","Uruguay"}; private String[] habitantes={"40000000","17000000","6500000","10000000","30000000", "14000000","183000000","44000000","29000000","3500000"}; Definimos un objeto de tipo TextView y otro de tipo ListView donde almacenaremos las referencias a los objetos que definimos en el archivo XML: private TextView tv1; private ListView lv1; En el método onCreate obtenemos la referencia a los dos objetos: tv1=(TextView)findViewById(R.id.tv1); lv1 =(ListView)findViewById(R.id.listView1); Creamos un objeto de la clase ArrayAdapter de forma similar a como lo hicimos cuando vimos la clase Spinner: ArrayAdapter<String> adapter = new ArrayAdapter<String>(this,android.R.layout.simple_list_item_1, paises); lv1.setAdapter(adapter); Llamamos al método setOnItemClicListener de la clase ListView y le pasamos como parámetro una clase anónima que implementa la interfaz OnItemClickListener (dicha interfaz define el método onItemClick que se dispara cuando seleccionamos un elemento del ListView): lv1.setOnItemClickListener(new OnItemClickListener() { @Override public void onItemClick(AdapterView<?> parent, View v, int posicion, long id) { tv1.setText("Población de "+ lv1.getItemAtPosition(posicion) + " es "+ habitantes); } }); Dentro del método onItemClick modificamos el contenido del TextView con el nombre del país y la cantidad de habitantes de dicho país. Este método recibe en el tercer parámetro la posición del item seleccionado del ListView. Cuando ejecutamos el proyecto podemos ver una interfaz en el emulador similar a esta: 8 - Control ImageButton Hemos visto la creación de objetos de la clase Button, ahora veremos otra clase muy similar a la anterior llamada ImageButton que tiene la misma filosofía de manejo con la diferencia que puede mostrar una imagen en su superficie. Problema: Disponer un objeto de la clase ImageButton que muestre una imagen de un teléfono. Cuando se presione mostrar en un control TextView el mensaje "Llamando". Primero crearemos un proyecto llamado proyecto007 y luego debemos buscar una imagen en formato png que represente un telefono de 50*50 píxeles. Nombre del archivo: telefono.png Ahora copiamos el archivo a la carpeta de recursos de nuestro proyecto : resdrawable-mdpi Desde el Eclipse en la ventana "Package Explorer" navegamos hasta la carpeta res y entramos al directorio drawable-mdpi y vemos que todavía no está el archivo que acabamos de copiar. Para que se actualice el proyecto presionamos el botón derecho del mouse sobre esta carpeta y seleccionamos la opción "Refresh": Vemos que se actualizó el contenido de la carpeta y aparece la imagen que copiamos previamente. Ahora insertaremos el objeto de la clase ImageButton en el formulario de nuestra aplicación. La clase ImageButton se encuentra en la pestaña "Image & Media": Aparece un diálogo de donde seleccionamos el archivo telefono. Luego de esto podemos ver que la superficie del objeto de la clase ImageButton muestra la imagen que almacenamos previamente en la carpeta de res. Si queremos cambiar el archivo a mostrar debemos modificar la propiedad src (aparece nuevamente el diálogo que nos permite seleccionar la imagen) Inicializamos la propiedad ID con el nombre bi1 Agreguemos un TextView a nuestra aplicación y configuremos sus propiedades ID (con tv1) y text. Luego la interfaz visual debe ser similar a: Código fuente: package com.javaya.proyecto007; import android.app.Activity; import android.os.Bundle; import android.view.Menu; import android.view.View; import android.widget.TextView; public class MainActivity extends Activity { private TextView tv1; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); tv1=(TextView)findViewById(R.id.tv1); } @Override public boolean onCreateOptionsMenu(Menu menu) { // Inflate the menu; this adds items to the action bar if it is present. getMenuInflater().inflate(R.menu.activity_main, menu); return true; } //Este método se ejecutará cuando se presione el ImageButton public void llamar(View view) { tv1.setText("Llamando"; } } Definimos el atributo de tipo TextView: TextView tv1; Enlazamos el control definido en el archivo XML y la variable de java: tv1=(TextView)findViewById(R.id.tv1); Implementamos el método que se ejecutará cuando se presione el el objeto de la clase ImageButton: public void llamar(View view) { tv1.setText("Llamando"; } No olvidemos inicializar la propiedad OnClick del objeto ib1 con el nombre del método "llamar" (recordemos que esto lo hacemos accediendo a la propiedad On Click en la ventana de "Properties" Comentarios extras de este control. Cuando copiamos el archivo lo hicimos a la carpeta: drawable-mdpi Pero vimos que hay otras carpetas con nombres similares: drawable-ldpi drawable-hdpi El objetivo de estas otras carpetas es guardar las mismas imágenes pero con una resolución mayor si la guardamos en drawable-hdpi y con una resolución menor al guardarla en drawable-ldpi. Esto se hace si queremos que nuestra aplicación sea más flexible si se ejecuta en un celular, en un tablet, en un televisor etc. Debemos tener en cuenta estos tamaños: En la carpeta res/drawable-mdpi/ (guardamos la imagen con el tamaño original) En la carpeta res/drawable-ldpi/ (guardamos la imagen con el tamaño del 75% con respecto al de la carpeta drawable-mdpi) En la carpeta res/drawable-hdpi/ (guardamos la imagen con el tamaño del 150% con respecto al de la carpeta drawable-mdpi) 9 - Lanzar un segundo "Activity" Hasta ahora todos los programas han tenido una sola ventana (Activity) Es muy común que una aplicación tenga más de una ventana. Para implementar esto en Android debemos plantear una segunda clase que también herede de la clase Activity (tengamos en cuenta que cuando utilizamos ADT automáticamente cuando creamos un proyecto nos crea el archivo XML y java de la primer Activity) Vamos a ver en este concepto los pasos que debemos dar para crear otro Activity y como activarlo desde el Activity principal. Problema: Confeccionar un programa que muestre en la ventana principal un botón que al ser presionado muestre otra ventana (Activity) mostrando un TextView con el nombre del programador de la aplicación y un botón para cerrar la ventana o actividad. 1 - Primero creamos un nuevo proyecto que lo llamaremos proyecto008 y en la ventana principal creamos la siguiente interfaz. Es decir que nosotros queremos que cuando se presione el botón "Acerca De" nos abra otra ventana (Activity) y nos muestre el nombre del programador. 2 - Ahora tenemos que crear el segundo Activity. Crearemos primero el archivo XML. Presionamos el botón derecho sobre la carpeta layout y seleccionaremos la opción New -> Android XML File Aquí tenemos que definir el nombre del archivo XML (debe estar en minúsculas), lo llamaremos acercade: Implementamos ahora la interfaz visual de esta segunda ventana (Activity) disponiendo un objeto de la clase TextView donde mostramos el nombre del autor de este programa y un Button para cerrar la ventana. 3 - Tenemos ahora que crear el archivo Java donde dispondremos la funcionalidad de la segunda ventana (Activity) Creamos una nueva clase al proyecto desde el menú contextual(presionamos el botón derecho del mouse sobre el paquete com.androidya.proyecto008): Al nombre de la clase la llamamos AcercaDe y debemos especificar que hereda de la clase Activity (podemos presionar el botón Browse que está en la misma fila de SuperClass y buscamos la clase Activity para que disponga el nombre del paquete donde se encuentra): El código que nos genera es: package com.javaya.proyecto008;import android.app.Activity;public class AcercaDe extends Activity {} Debemos sobreescribir el método onCreate donde enlazamos esta clase con el archivo XML que diseñamos. Si no recordamos cual es la sintaxis exacta de este método podemos también generarlo automáticamente con la ayuda de nuestro editor, elegimos Source -> Override/Implement methods: Buscamos el método onCreate y presionamos el botón Ok, ahora ya tenemos la clase con el método onCreate: package com.javaya.proyecto008;import android.app.Activity;import android.os.Bundle;public class AcercaDe extends Activity {@Overrideprotected void onCreate(Bundle savedInstanceState) {// TODO Auto-generated method stubsuper.onCreate(savedInstanceState);}} Ahora solo falta llamar al método setContentView para enlazar el archivo XML: package com.javaya.proyecto008;import android.app.Activity;import android.os.Bundle;public class AcercaDe extends Activity {@Overrideprotected void onCreate(Bundle savedInstanceState) {// TODO Auto-generated method stubsuper.onCreate(savedInstanceState);setContentView(R.layout.acercade);}} Como podemos ver la clase AcercaDe hereda de la clase Activity e implementa el método onCreate para enlazar el archivo XML que creamos anteriormente. 4 - Otro paso fundamental es registrar el Activity en el archivo "AndroidManifest.xml" que se encuentra en la raiz principal del proyecto. Seleccionamos el archivo y activamos la pestaña : "Application", presionamos el botón "add" y seleccionamos "Activity": http://www.javaya.com.ar/androidya/imagentema/foto042.jpg Por último seleccionamos en "Application Nodes" la actividad creada y definimos la propiedad Name con el nombre de la clase que la implementa (en nuestro caso se llama AcercaDe): http://www.javaya.com.ar/androidya/imagentema/foto043.jpg 5 - Ahora implementaremos la funcionalidad en la actividad (Activity) principal para que se active la segunda ventana. Inicializamos la propiedad OnClick del objeto de la clase Button con el valor "lanzar", este es el método que se ejecutará cuando se presione. El código fuente de la actividad principal queda: package com.javaya.proyecto008;import android.app.Activity;import android.content.Intent;import android.os.Bundle;import android.view.Menu;import android.view.View;public class MainActivity extends Activity { @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); } @Override public boolean onCreateOptionsMenu(Menu menu) { // Inflate the menu; this adds items to the action bar if it is present. getMenuInflater().inflate(R.menu.activity_main, menu); return true; } public void lanzar(View view) { Intent i = new Intent(this, AcercaDe.class ); startActivity(i); } } En el método lanzar creamos un objeto de la clase Intent y le pasamos como parámetros la referencia del objeto de esta clase (this) y la referencia del otro Activity (AcercaDe.class) Llamamos posteriormente al método startActivity pasando el objeto de la clase Intent (con esto ya tenemos en pantalla la ventana del segundo Activity: public void lanzar(View view) { Intent i = new Intent(this, AcercaDe.class ); startActivity(i); } Si ejecutamos el programa podemos ver que cuando presionamos el botón "Acerca De" aparece la segunda ventana donde se muestra el TextView con el valor "Autor de este programa: Diego" y un botón con el texto "Finalizar" (si presionamos este botón no sucede nada, esto debido a que no hemos asociado ningún evento a dicho botón) 6 - Debemos codificar el evento OnClick de la segunda actividad. Seleccionemos el botón "Finalizar" y definamos en la propiedad OnClick el nombre de método que se ejecutará al presionarse el botón (en nuestro caso lo llamaremos cerrar" : El código fuente de la actividad AcercaDe queda: package com.javaya.proyecto008;import android.app.Activity;import android.os.Bundle;import android.view.View;public class AcercaDe extends Activity { /** Called when the activity is first created. */ @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.acercade); } public void cerrar(View view) { finish(); } } Cuando se presiona el botón finalizar llamando al método finish() que tiene por objetivo liberar el espacio de memoria de esta actividad y pedir que se active la actividad anterior. Ahora nuestro programa está funcionando completamente: Primer Activity: Segundo Activity:

Bienvenidos a mi segunda entrega del tutorial para android espero que les guste, si te perdiste la primer entrega te dejo el link, http://www.taringa.net/posts/ciencia-educacion/16951329/Programacion-android.html 1 - Almacenamiento de datos en un archivo de texto en la memoria interna. Otra posibilidad de almacenar datos en nuestro dispositivo Android es el empleo de un archivo de texto que se guardará en el almacenamiento interno del equipo (la otro posibilidad es almacenarlo en una tarjeta SD Card) Problema: Confeccionar un programa que permita almacenar notas en un control EditText y cuando se presione un botón almacenar los datos del EditText en un archivo de texto llamado "notas.txt". Cada vez que se ingrese al programa verificar si existe el archivo de textos "notas.txt" proceder a su lectura y almacenamiento de datos en el EditText. Crear un proyecto en Eclipse de tipo "Android Project" y definir como nombre: proyecto013 y localizarlo en el paquete com.androidya.proyecto013. La interfaz visual, los controles y sus ID son los siguientes: El código fuente de la aplicación: package com.javaya.proyecto013;import java.io.BufferedReader;import java.io.IOException;import java.io.InputStreamReader;import java.io.OutputStreamWriter;import android.app.Activity;import android.os.Bundle;import android.view.Menu;import android.view.View;import android.widget.EditText;import android.widget.Toast;public class MainActivity extends Activity { private EditText et1; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); et1 = (EditText) findViewById(R.id.et1); String[] archivos = fileList(); if (existe(archivos, "notas.txt")) try { InputStreamReader archivo = new InputStreamReader( openFileInput("notas.txt")); BufferedReader br = new BufferedReader(archivo); String linea = br.readLine(); String todo = ""; while (linea != null) { todo = todo + linea + "n"; linea = br.readLine(); } br.close(); archivo.close(); et1.setText(todo); } catch (IOException e) { } } @Override public boolean onCreateOptionsMenu(Menu menu) { // Inflate the menu; this adds items to the action bar if it is present. getMenuInflater().inflate(R.menu.activity_main, menu); return true; } private boolean existe(String[] archivos, String archbusca) { for (int f = 0; f < archivos.length; f++) if (archbusca.equals(archivos)) return true; return false; } public void grabar(View v) { try { OutputStreamWriter archivo = new OutputStreamWriter(openFileOutput( "notas.txt", Activity.MODE_PRIVATE)); archivo.write(et1.getText().toString()); archivo.flush(); archivo.close(); } catch (IOException e) { } Toast t = Toast.makeText(this, "Los datos fueron grabados", Toast.LENGTH_SHORT); t.show(); finish(); }} Veamos primero como grabamos datos en un archivo de texto. Esto se hace en el método grabar que se ejecuta cuando presionamos el botón "grabar" (recordemos de inicializar la propiedad "OnClick" del botón): public void grabar(View v) { try { OutputStreamWriter archivo = new OutputStreamWriter(openFileOutput("notas.txt",Activity.MODE_PRIVATE)); Creamos un objeto de la clase OutputStreamWriter y al constructor de dicha clase le enviamos el dato que retorna el método openFileOutput propio de la clase Activity que le pasamos como parámetro el nombre del archivo de texto y el modo de apertura. Seguidamente si el archivo se creó correctamente procedemos a llamar al método write y le pasamos el String a grabar, en este caso extraemos los datos del EditText: archivo.write(et1.getText().toString()); Luego de grabar con el método write llamamos al método flush para que vuelque todos los datos que pueden haber quedado en el buffer y procedemos al cerrado del archivo: archivo.flush(); archivo.close(); Todo esto está cerrado en un try/catch para verificar si sucede algún error en la apertura del archivo. Finalmente mostramos un mensaje temporal en pantalla utilizando la clase Toast: Toast t=Toast.makeText(this,"Los datos fueron grabados", Toast.LENGTH_SHORT); t.show(); finish(); Para crear un objeto de la clase Toast llamamos al método makeText de la clase Toast y le pasamos la referencia del Activity actual, el String a mostrar y el tiempo de duración del mensaje. Con el objeto devuelto por el método makeText procedemos a llamar seguidamente al método show para que se muestre el mensaje. Es común llamar al método show de la clase Toast en una sola línea como esta: Toast.makeText(this,"Los datos fueron grabados", Toast.LENGTH_SHORT).show(); El método onCreate tiene por objetivo verificar si existe el archivo de texto, proceder a su lectura y mostrar su contenido en el EditText. Primero obtenemos la lista de todos los archivos creados por la Activity. En nuestro ejemplo puede ser cero o uno: String []archivos=fileList(); Llamamos a un método que verifica si en el vector de tipo String existe el archivo "notas.txt": if (existe(archivos,"notas.txt")) En el caso que me retorne true procedemos a crear un objeto de la clase InputStreamReader y al constructor de dicha clase le pasamos el dato devuelto por el método openFileInput: InputStreamReader archivo=new InputStreamReader(openFileInput("notas.txt")); Creamos un objeto de la clase BufferedReader y le pasamos al constructor la referencia del objeto de la clase InputStreamReader: BufferedReader br=new BufferedReader(archivo); Leemos la primer línea del archivo de texto: String linea=br.readLine(); Inicializamos un String vacío: String todo=""; Mientras el método readLine de la clase BufferedReader devuelva un String: while (linea!=null) { Lo concatenamos al String junto a un salto de línea: todo=todo+linea+"n"; Leemos la próxima línea: linea=br.readLine(); } Llamamos al método close de la clase BufferedReader y al del InputStreamReader: br.close(); archivo.close(); Cargamos el EditText con el contenido del String que contiene todos los datos del archivo de texto: et1.setText(todo); El método existe llega un vector de tipo String y otro String a buscar. Dentro de un for verificamos el String a buscar con cada uno de los String del vector, si lo encontramos retornamos true. Si recorre todo el for sin encontrarlo fuera del for retornamos false: private boolean existe(String[] archivos,String archbusca) { for(int f=0;f<archivos.length;f++) if (archbusca.equals(archivos)) return true; return false; } 2- Almacenamiento de datos en un archivo de texto localizado en una tarjeta SD En el Concepto anterior VIMOS Como Crear y leer sin archivo de texto en la memoria interna del Equipo Android. En algunas Situaciones Podria Ser Útil Almacenar los Datos En Una Tarjeta SD, ESTO debido a Do Mayor capacidad o la facilidad de compartir los Archivos con Otras Personas entregando la Tarjeta SD. Problema: Sin confeccionar Programa Que permita ingresar el Nombre de la ONU archivo y el Contenido. Permitir grabar los Datos ingresados al presionar sin Button.Enajenante ONU Segundo Button Que permita Recuperar los Datos del archivo de texto. Hacer ¡Que los Archivos sí graben En Una Tarjeta SD. La Interfaz visual a implementar es la siguiente: http://www.javaya.com.ar/androidya/imagentema/foto056.jpg El Primer Paso es Modificar el archivo AndroidManifest.xml párr permitir el Acceso a la Tarjeta SD from our application ESTO lo HACEMOS desde el editor visual del archivo AndroidManifest.xml: http://www.javaya.com.ar/androidya/imagentema/foto057.jpg Debemos presionar El Botón "Añadir" select "Usos Permision" y LUEGO en nombre select "android.permission.WRITE_EXTERNAL_STORAGE". El Codigo fuente es: paquete com.javaya.proyecto014;java.io.BufferedReader importación;importar java.io.File;importar java.io.FileInputStream;importar java.io.FileOutputStream;java.io.IOException importación;java.io.InputStreamReader importación;importar java.io.OutputStreamWriter;importar android.app.Activity;android.os.Bundle importación;importar android.os.Environment;importar android.view.Menu;importar android.view.View;importar android.widget.EditText;importar android.widget.Toast;MainActivity public class Actividad { EditarTexto et1; EditarTexto et2; @ Override protected void onCreate (Bundle savedInstanceState) { super.onCreate (savedInstanceState); setContentView (R.layout.activity_main); et1 = (EditarTexto) findViewById (R.id.editText1); et2 = (EditarTexto) findViewById (R.id.editText2); } @ Override onCreateOptionsMenu public boolean (menu Menu) { / / Inflar el menú, lo que añade elementos a la barra de acción, si está presente. . getMenuInflater () inflar (R.menu.activity_main, menú); return true; } public void grabar (View v) { Cadena nomarchivo = et1.getText () toString ().; Cadena contenido = et2.getText () toString ().; try { Archivo Tarjeta = Environment.getExternalStorageDirectory (); File = new Archivo (tarjeta.getAbsolutePath (), nomarchivo); OutputStreamWriter osw = new OutputStreamWriter ( nueva FileOutputStream (archivo)); osw.write (Contenido); osw.flush (); osw.close (); Toast.makeText (this, "Los Datos were Grabados correctamente", . Toast.LENGTH_SHORT) mostrar (); et1.setText (""); et2.setText (""); } Catch (IOException ioe) { } } public void Recuperar (View v) { Cadena nomarchivo = et1.getText () toString ().; Archivo Tarjeta = Environment.getExternalStorageDirectory (); File = new Archivo (tarjeta.getAbsolutePath (), nomarchivo); try { FileInputStream Fin = nueva FileInputStream (archivo); InputStreamReader archivo = new InputStreamReader (fin); BufferedReader br = new BufferedReader (archivo); Cadena linea = br.readLine (); Cadena del todo = ""; while (linea! = null) { TODO TODO = + linea + ""; linea = br.readLine (); } br.close (); archivo.close (); et2.setText (del todo); } Catch (IOException e) { } }} El Método párr grabar los Datos En Un archivo de texto localizado en Una Tarjeta SD Comienza obteniendo el Directorio raiz de la Tarjeta a Través del Método getExternalStorageDirectory (), el Mismo Retorna sin Objeto de la Clase del archivo. public void grabar (View v) { Cadena nomarchivo = et1.getText () toString ().; Cadena contenido = et2.getText () toString ().; intentar { Archivo Tarjeta = Environment.getExternalStorageDirectory (); Creamos Un Nuevo Objeto de la Clase del archivo indicando el camino de la Unidad SD y el Nombre del archivo de Crear: File = new Archivo (tarjeta.getAbsolutePath (), nomarchivo); Por ÚLTIMO similares al Acceso de la ONU archivo interno Creamos sin Objeto de la Clase OutputStreamWriter: OutputStreamWriter osw = new OutputStreamWriter (nueva FileOutputStream (archivo)); Grabamos el Contenido del EditarTexto: osw.write (Contenido); Cerramos el archivo: osw.flush (); osw.close (); Toast.makeText (this, "Los Datos were Grabados correctamente", Toast.LENGTH_SHORT) mostrar ().; et1.setText (""); et2.setText (""); } catch (IOException OIE) { } } Para la Lectura del archivo NuevaMente obtenemos la Referencia de la Tarjeta SD párrafo Obtener el sendero de la Unidad de Almacenamiento, el resto del Algoritmo es parecido al de Visto ONU de la estafa archivo interno: public void Recuperar (View v) { Cadena nomarchivo = et1.getText () toString ().; Archivo Tarjeta = Environment.getExternalStorageDirectory (); File = new Archivo (tarjeta.getAbsolutePath (), nomarchivo); try { FileInputStream Fin = nueva FileInputStream (archivo); InputStreamReader archivo = new InputStreamReader (fin); BufferedReader br = new BufferedReader (archivo); Cadena linea = br.readLine (); Cadena del todo = ""; while (linea! = null) { TODO TODO = + linea + " n"; linea = br.readLine (); } br.close (); archivo.close (); et2.setText (del todo); } Catch (IOException e) { } } 3- Almacenamiento en una base de datos SQLite Hemos visto hasta ahora dos modos de almacenar datos en forma permanente (archivos de texto y la clase SharedPreferences), ahora veremos otra herramienta nativa de Android para almacenar datos en una base de datos llamada SQLite. SQLite es una base de datos Open Source, es muy popular en muchos dispositivos pequeños, como Android. Las ventajas que presenta utilizar SQLite es que no requiere configuración, no tiene un servidor de base de datos ejecutándose en un proceso separado y es relativamente simple su empleo. Problema: Confeccionar un programa que permita almacenar los datos de votantes de una elección. Crear la tabla votantes y definir los campos dni (documento de identidad), nombre del votante, colegio donde vota y número de mesa donde vota. El programa debe permitir: 1 - Carga de personas.2 - Consulta por el dni (para saber donde vota)3 - Borrado de personas4 - Modificación de datos. Primero implementamos una interfaz visual similar a esta: http://www.javaya.com.ar/androidya/imagentema/foto058.jpg Lo primero que haremos es crear una clase que herede de SQLiteOpenHelper. Esta clase nos permite crear la base de datos y actualizar la estructura de tablas y datos iniciales. Debemos implementar el constructor y sobreescribir los métodos onCreate y onUpgrade. El método onCreate se le llama cuando la base de datos se crea por primera vez. Aquí es donde se define la estructura de las tablas y se cargan eventualmente los datos iniciales En el método onUpgrade se llama cuando la base de datos debe ser actualizada. Tiene por objetivo eliminar tablas, añadir tablas, o hacer cualquier otra cosa que necesita para actualizarse. En nuestro problema implementaremos una nueva clase llamada AdminSQLiteOpenHelper que herede de la clase SQLiteOpenHelper: package com.javaya.proyecto015;import android.content.Context;import android.database.sqlite.SQLiteDatabase;import android.database.sqlite.SQLiteDatabase.CursorFactory;import android.database.sqlite.SQLiteOpenHelper;public class AdminSQLiteOpenHelper extends SQLiteOpenHelper { public AdminSQLiteOpenHelper(Context context, String nombre, CursorFactory factory, int version) { super(context, nombre, factory, version); } @Override public void onCreate(SQLiteDatabase db) { db.execSQL("create table votantes(dni integer primary key, nombre text, colegio text, nromesa integer)"); } @Override public void onUpgrade(SQLiteDatabase db, int versionAnte, int versionNue) { db.execSQL("drop table if exists votantes"); db.execSQL("create table votantes(dni integer primary key, nombre text, colegio text, nromesa integer)"); } } En el constructor solo llamamos al constructor de la clase padre pasando los datos que llegan en los parámetros: public AdminSQLiteOpenHelper(Context context, String nombre, CursorFactory factory, int version) {super(context, nombre, factory, version);} En el método onCreate procedemos a crear la tabla votantes con los cuatro campos respectivos y definiendo el campo dni como primary key: public void onCreate(SQLiteDatabase db) {db.execSQL("create table votantes(dni integer primary key, nombre text, colegio text, nromesa integer)");} En el método onUpgrade procedemos a borrar la tabla votantes y crear nuevamente la tabla (en este caso con la misma estructura pero podría ser otra en un caso más real: public void onUpgrade(SQLiteDatabase db, int versionAnte, int versionNue) {db.execSQL("drop table if exists votantes");db.execSQL("create table votantes(dni integer primary key, nombre text, colegio text, nromesa integer)");} Ahora veamos la otra clase que implementará las altas, bajas, modificaciones y consultas: package com.javaya.proyecto015;import android.app.Activity;import android.content.ContentValues;import android.database.Cursor;import android.database.sqlite.SQLiteDatabase;import android.os.Bundle;import android.view.Menu;import android.view.View;import android.widget.EditText;import android.widget.Toast;public class MainActivity extends Activity { private EditText et1, et2, et3, et4; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); setContentView(R.layout.activity_main); et1 = (EditText) findViewById(R.id.editText1); et2 = (EditText) findViewById(R.id.editText2); et3 = (EditText) findViewById(R.id.editText3); et4 = (EditText) findViewById(R.id.editText4); } @Override public boolean onCreateOptionsMenu(Menu menu) { // Inflate the menu; this adds items to the action bar if it is present. getMenuInflater().inflate(R.menu.activity_main, menu); return true; } public void alta(View v) { AdminSQLiteOpenHelper admin = new AdminSQLiteOpenHelper(this, "administracion", null, 1); SQLiteDatabase bd = admin.getWritableDatabase(); String dni = et1.getText().toString(); String nombre = et2.getText().toString(); String colegio = et3.getText().toString(); String nromesa = et4.getText().toString(); ContentValues registro = new ContentValues(); registro.put("dni", dni); registro.put("nombre", nombre); registro.put("colegio", colegio); registro.put("nromesa", nromesa); bd.insert("votantes", null, registro); bd.close(); et1.setText(""); et2.setText(""); et3.setText(""); et4.setText(""); Toast.makeText(this, "Se cargaron los datos de la persona", Toast.LENGTH_SHORT).show(); } public void consulta(View v) { AdminSQLiteOpenHelper admin = new AdminSQLiteOpenHelper(this, "administracion", null, 1); SQLiteDatabase bd = admin.getWritableDatabase(); String dni = et1.getText().toString(); Cursor fila = bd.rawQuery( "select nombre,colegio,nromesa from votantes where dni=" + dni, null); if (fila.moveToFirst()) { et2.setText(fila.getString(0)); et3.setText(fila.getString(1)); et4.setText(fila.getString(2)); } else Toast.makeText(this, "No existe una persona con dicho dni", Toast.LENGTH_SHORT).show(); bd.close(); } public void baja(View v) { AdminSQLiteOpenHelper admin = new AdminSQLiteOpenHelper(this, "administracion", null, 1); SQLiteDatabase bd = admin.getWritableDatabase(); String dni = et1.getText().toString(); int cant = bd.delete("votantes", "dni=" + dni, null); bd.close(); et1.setText(""); et2.setText(""); et3.setText(""); et4.setText(""); if (cant == 1) Toast.makeText(this, "Se borró la persona con dicho documento", Toast.LENGTH_SHORT).show(); else Toast.makeText(this, "No existe una persona con dicho documento", Toast.LENGTH_SHORT).show(); } public void modificacion(View v) { AdminSQLiteOpenHelper admin = new AdminSQLiteOpenHelper(this, "administracion", null, 1); SQLiteDatabase bd = admin.getWritableDatabase(); String dni = et1.getText().toString(); String nombre = et2.getText().toString(); String colegio = et3.getText().toString(); String nromesa = et4.getText().toString(); ContentValues registro = new ContentValues(); registro.put("nombre", nombre); registro.put("colegio", colegio); registro.put("nromesa", nromesa); int cant = bd.update("votantes", registro, "dni=" + dni, null); bd.close(); if (cant == 1) Toast.makeText(this, "se modificaron los datos", Toast.LENGTH_SHORT) .show(); else Toast.makeText(this, "no existe una persona con dicho documento", Toast.LENGTH_SHORT).show(); } } 1 - Alta de datos. Cuando se presiona el botón alta se ejecuta el método "alta" recordemos inicializar la propiedad "OnClick" del botón desde la ventana de visualización del archivo XML. Lo primero que hacemos en este método es crear un objeto de la clase que planteamos anteriormente y le pasamos al constructor this (referencia del Activity actual), "administracion" (es el nombre de la base de datos que crearemos en el caso que no exista) luego pasamos null y un uno indicando que es la primer versión de la base de datos (en caso que cambiemos la estructura o agreguemos tablas por ejemplo podemos pasar un dos en lugar de un uno para que se ejecute el método onUpgrade donde indicamos la nuestra estructura de la base de datos) Luego de crear un objeto de la clase AdminSqLiteOpenHelper procedemos a crear un objeto de la clase SQLiteDataBase llamando al método getWritableDatabase (la base de datos se abre en modo lectura y escritura). Creamos un objeto de la clase ContentValues y mediante el método put inicializamos todos tos campos a cargar. Seguidamente llamamos al método insert de la clase SQLiteDatabase pasando en el primer parámetro el nombre de la tabla, como segundo parámetro un null y por último el objeto de la clase ContentValues ya inicializado (este método es el que provoca que se inserte una nueva fila en la tabla votantes en la base de datos llamada administracion) Borramos seguidamente los EditText y mostramos un mensaje para que conozca el operador que el alta de datos se efectuó en forma correcta: public void alta(View v) { AdminSQLiteOpenHelper admin=new AdminSQLiteOpenHelper(this, "administracion", null, 1); SQLiteDatabase bd=admin.getWritableDatabase(); String dni=et1.getText().toString(); String nombre=et2.getText().toString(); String colegio=et3.getText().toString(); String nromesa=et4.getText().toString(); ContentValues registro=new ContentValues(); registro.put("dni",dni ); registro.put("nombre",nombre ); registro.put("colegio",colegio ); registro.put("nromesa",nromesa ); bd.insert("votantes", null, registro); bd.close(); et1.setText(""); et2.setText(""); et3.setText(""); et4.setText(""); Toast.makeText(this, "Se cargaron los datos de la persona", Toast.LENGTH_SHORT).show(); } 2 - Consulta de datos. Cuando se presiona el botón "Consulta por DNI" se ejecuta el método consulta: public void consulta(View v) { AdminSQLiteOpenHelper admin=new AdminSQLiteOpenHelper(this, "administracion", null, 1); SQLiteDatabase bd=admin.getWritableDatabase(); String dni=et1.getText().toString(); Cursor fila=bd.rawQuery("select nombre,colegio,nromesa from votantes where dni="+dni+"",null); if (fila.moveToFirst()) { et2.setText(fila.getString(0)); et3.setText(fila.getString(1)); et4.setText(fila.getString(2)); } else Toast.makeText(this, "No existe una persona con dicho dni", Toast.LENGTH_SHORT).show(); bd.close(); } En el método consulta lo primero que hacemos es crear un objeto de la clase AdminSQLiteOpenHelper y obtener una referencia de la base de datos llamando al método getWritableDatabase. Seguidamente definimos una variable de la clase Cursor y la inicializamos con el valor devuelto por el método llamado rawQuery. La clase Cursos almacena en este caso una fila o cero filas (una en caso que hayamos ingresado un dni existente en la tabla votantes), llamamos al método moveToFirst() de la clase Cursos y retorna true en caso de existir una persona con el dni ingresado, en caso contrario retorna cero. Para recuperar los datos propiamente dichos que queremos consultar llamamos al método getString y le pasamos la posición del campo a recuperar (comienza a numerarse en cero, en este ejemplo la columna cero representa el campo nombre, la columna 1 representa el campo colegio y la columna 2 representa el campo nromesa) 3 - Baja o borrado de datos. Para borrar uno o más registros la clase SQLiteDatabase tiene un método que le pasamos en el primer parámetro el nombre de la tabla y en el segundo la condición que debe cumplirse para que se borre la fila de la tabla. El método delete retorna un entero que indica la cantidad de registros borrados: public void baja(View v) { AdminSQLiteOpenHelper admin=new AdminSQLiteOpenHelper(this, "administracion", null, 1); SQLiteDatabase bd=admin.getWritableDatabase(); String dni=et1.getText().toString(); int cant=bd.delete("votantes", "dni="+dni+"",null); bd.close(); et1.setText(""); et2.setText(""); et3.setText(""); et4.setText(""); if (cant==1) Toast.makeText(this, "Se borró la persona con dicho documento", Toast.LENGTH_SHORT).show(); else Toast.makeText(this, "No existe una persona con dicho documento", Toast.LENGTH_SHORT).show(); } 4 - Modificación de datos. En la modificación de datos debemos crear un objeto de la clase ContentValues y mediante el método put almacenar los valores para cada campo que será modificado. Luego se llama al método update de la clase SQLiteDatabase pasando el nombre de la tabla, el objeto de la clase ContentValues y la condición del where (el cuanto parámetro en este ejemplo no se lo emplea) public void modificacion(View v) { AdminSQLiteOpenHelper admin=new AdminSQLiteOpenHelper(this, "administracion", null, 1); SQLiteDatabase bd=admin.getWritableDatabase(); String dni=et1.getText().toString(); String nombre=et2.getText().toString(); String colegio=et3.getText().toString(); String nromesa=et4.getText().toString(); ContentValues registro=new ContentValues(); registro.put("nombre",nombre); registro.put("colegio",colegio); registro.put("nromesa",nromesa); int cant = bd.update("votantes", registro, "dni="+dni, null); bd.close(); if (cant==1) Toast.makeText(this, "se modificaron los datos", Toast.LENGTH_SHORT).show(); else Toast.makeText(this, "no existe una persona con dicho documento", Toast.LENGTH_SHORT).show(); } 4- Instalación del programa Android en un dispositivo real Normalmente uno cuando desarrolla aplicaciones en Android hace toda la programación, depuración y pruebas en un dispositivo virtual en la pc. Ahora vamos a ver los pasos para probar la aplicación en un dispositivo Android real. La primera forma que veremos de probar nuestra aplicación es copiar el archivo con extensión APK a nuestro dispositivo. Primero en el ícono de configuración de nuestro teléfono o tablet android seleccionamos la opción "Aplicaciones" -> y marcamos la opción "Origen desconocido (Permitir la instalación de aplicaciones no pertenecientes al mercado)"Desde nuestro equipo de escritorio enviamos un mail a nuestro celular adjuntando el archivo con extensión apk que se encuentra en el directorio bin de nuestro proyecto (por ejemplo adjuntemos el archivo proyecto015.apk)Abramos el mail desde nuestro celular y seleccionemos el archivo adjunto. Confirmamos que queremos instalarlo.http://www.javaya.com.ar/androidya/imagentema/foto058a.jpg Ya podemos probar nuestra aplicación: http://www.javaya.com.ar/androidya/imagentema/foto058b.jpg

Cuando la computadora no enciende la bios siempre tiene algo que decirnos sobre el estado del sistema y lo hace por medio de pitidos. Mira aquí tenemos algunos: Ningún pitido: No hay suministro eléctrico (vamos que el cable está sin enchufar, el cable en sí falla, o la caja de suministro eléctrico está deteriorada, la cuestión es que no llega corriente) o también puede ser que el “Speaker”, lo que emite los pitidos, falle (lo podréis comprobar si a continuación funciona correctamente). Tono continuo: Error en el suministro eléctrico (llega mal la corriente, o la caja de suministro esta fastidiada, no hay más que cambiarla). Tonos cortos constantes: La placa madre está defectuosa, es decir, está rota, es de lo peor que nos puede ocurrir. Un tono largo: Error de memoria RAM, lo normal es que esté mal puesta o que esté fastidiada. Un tono largo y otro corto: Error el la placa base o en ROM Basic. Esto suele ocurrir mucho en placas base viejas, la gente las suele tirar. Un tono largo y dos cortos: Error en la tarjeta gráfica. Puede que el puerto falle, por lo que no habría más que cambiarla de puerto, pero también puede ser que la tarjeta gráfica sea defectuosa. Dos tonos largos y uno corto: Error en la sincronización de las imágenes. Seguramente problema de la gráfica. Dos tonos cortos: Error de la paridad de la memoria. Esto ocurre sobretodo en ordenadores viejos que llevaban la memoria de dos módulos en dos módulos. Esto significaría que uno de los módulos falla, o que no disponemos de un número par de módulos de memoria. Tres tonos cortos: Esto nos indica que hay un error en los primeros 64Kb de la memoria RAM. Cuatro tonos cortos: Error en el temporizador o contador. Cinco tonos cortos: Esto nos indica que el procesador o la tarjeta gráfica se encuentran bloqueados. Suele ocurrir con el sobrecalentamiento. Seis tonos cortos: Error en el teclado. Si ocurre esto yo probaría con otro teclado. Si aun así no funciona se trata del puerto receptor del teclado. Siete tonos cortos: Modo virtual de procesador AT activo. Ocho tonos cortos: Error en la escritura de la video RAM. Nueve tonos cortos: Error en la cuenta de la BIOS RAM. Muchas veces nos suenan muchos de estos pitidos por cosas que no entendemos pero luego sigue funcionando con normalidad. En ese caso sería problema del detector de errores o de esa especie de escaneo que nos hace al encender el ordenador. Tonos de la BIOS AMI Pitidos fáciles de identificar, su interfaz gráfico ha sido mejorado y los parámetros son más parecidos a los de AWARD. Ningún pitido. Esto significa varias cosas. Primeramente nos aseguramos de que el speaker esté bien conectado, luego revisamos el cable de alimentación. En caso de estar todo bien y la configuración de swichers y jumpers también l sea cambiaremos la placa por defectuosa. Ese fallo se debe en la mayoría de las veces por fallos de corriente. Un pitido. Este pitido indica que todo esta correcto. En caso de no dar imagen revisaremos la tarjeta grafica y la memoria RAM. Dos pitidos. Es un problema de memoria en tarjeta de video o en la RAM. Si vemos imagen nos aparecerá un mensaje de error. Si es así cambiaremos la memoria RAM de posición en los zócalos que ocupa ya que existe un problema de paridad, o en los primeros 64Kbytes de memoria. Si el problema persiste cambiaremos la placa. Tres pitidos. Lo mismo que cuando suenan dos pitidos. Cuatro pitidos. Lo mismo que ocurre con dos y tres pitidos. En este caso además puede ser un error en el reloj del sistema Cinco pitidos. La placa base no ha detectado memoria RAM, o no es compatible procedemos a cambiarla de posición o a cambiarla por otra. En muchos casos la marca de la RAM influye mucho. Seis pitidos. La controladora de teclado estropeada, hay que cambiar de placa. Siete pitidos. No se ha podido detectar el procesador o no funciona. Lo cambiamos o revisamos la configuración. Ocho pitidos. No se ha detectado tarjeta de video o no funciona. Cambiamos de slot la tarjeta o revisamos al memoria de video. Nueve pitidos. El código de la BIOS está corrupto, procedemos a flasearla si podemos, o a reemplazar el chip. Diez pitidos. La BIOS no puede leer / escribir los datos almacenados en la CMOS. Intentamos borrar estos datos puenteando el jumper “Clean CMOS” o quitando la pila, e intentamos salvar los valores de nuevo en la CMOS. Si el problema persiste tendremos que cambiar la placa ya que este chip viene siempre soldado. Once pitidos. La memoria caché del sistema (640Kbytes en la placa) esta dañada o no pude acceder a ella . Podemos reactivar la caché mediante la combinación Control + Alt + Shift + I Tonos de la BIOS AWARD Si poseemos esta BIOS ya nos vale agudizar el oído. En la mayoría de los pitidos se les acompaña un mensaje de error. Tono ininterrumpido. Fallo en el suministro eléctrico. Revisamos las conexiones y la fuente de alimentación. Tonos cortos constantes. Sobrecarga eléctrica, chips defectuosos, placa mal... 1 largo. Si aparece esto en la pantalla “RAM Refresh Failure”, significa que los diferentes componentes encargados del refresco de la memoria RAM fallan o no están presentes. Cambiar de banco la memoria y comprobar los jumpers de buses. 1 largo y 1 corto. El código de la BIOS esta corrupto o defectuoso, probaremos a flasear o reemplazamos el chip de la BIOS sino podemos cambiamos de placa. 1 largo y dos cortos. No da señal de imagen, se trata de que nuestra tarjeta de vídeo esta estropeada, probaremos a pincharla en otro slot o probaremos otra tarjeta gráfica. 1 largo y 2 cortos. Si aparece por pantalla este mensaje: “No video card found”, este error solo es aplicable a placas base con tarjetas de vídeo integradas. Fallo en la tarjeta gráfica, probaremos a desabilitarla y pincharemos una nueva en cualquier slot libre o cambiaremos la placa madre. 1 largo y 3 cortos. Si aparece este mensaje por pantalla “No monitor connected” Idem que el anterior. 1 largo y varios cortos. Mensaje de error. “Video related failure”. Lo mismo que antes. Cada fabricante implanta un código de error según el tipo de tarjeta de video y los parámetros de cada BIOS 2 largos y 1 corto. Fallo en la sincronización de las imágenes. Cargaremos por defecto los valores de la BIOS e intentaremos reiniciar. Si persiste nuestra tarjeta gráfica o placa madre están estropeadas. 2 cortos. Vemos en la pantalla este error: “Parity Error”. Se trata de un error en la configuración de la BIOS al no soportar la paridad de memoria, la deshabilitamos en al BIOS. 3 cortos. Vemos en la pantalla este error. Base 64 Kb “Memory Failure”, significa que la BIOS al intentar leer los primeros 64Kbytes de memoria RAM dieron error. Cambiamos la RAM instalada por otra. 4 cortos. Mensaje de error; “Timer not operational”. El reloj de la propia placa base esta estropeado, no hay mas solución que cambiar la placa. No confundir con “CMOS cheksum error” una cosa es la pila y otra el contador o reloj de la placa base. 5 cortos. Mensaje por pantalla “Processor Error” significa que la CPU ha generado un error porque el procesador o la memoria de vídeo están bloqueados. 6 cortos. Mensaje de error: “8042 - Gate A20 Failure”, muy mítico este error. El controlador o procesador del teclado (8042) puede estar en mal estado. La BIOS no puede conmutar en modo protegido. Este error se suele dar cuando se conecta/desconecta el teclado con el ordenador encendido. 7 cortos. Mensaje de error: “Processor Exception / Interrupt Error” Descripción. La CPU ha generado una interrupción excepcional o el modo virtual del procesador está activo. Procesador a punto de morirse. 8 cortos. Mensaje de error: “Display Memory Read / Write error”. La tarjeta de video esta estropeada, procedemos a cambiarla. 9 cortos. Mensaje de error: “ROM Checksum Error”; el valor del checksum (conteo de la memoria) de la RAM no coincide con el valor guardado en la BIOS. Reseteamos los valores de la CMOS y volvemos a aconfigurar y si persiste tendremos la RAM o la BIOS estropeadas. 10 cortos. Si vemos por pantalla esto; “CMOS Shutdown Register / Read/Write Error”: el registro de la CMOS RAM falla a la hora de la desconexión. En otras palabras que no puede escribir en la CMOS cuando salimos de configurar la BIOS. 11cortos. Mensaje de error: “Cache Error / External Cache Bad” la memoria caché (L1o L2) del procesador están fallando. También se aplica a la cache de la placa. 1 pitido largo + 8 pitidos cortos. Error en la verificación de tarjeta de video, esta está defectuosa, procedemos a cambiarla 1 pitido largo + 3 pitidos cortos. Fallo en la comprobación de la RAM (Reemplazar la memoria) posiblemente porque los ciclos de reloj de esa memoria no se corresponden con los de la placa o no son compatibles ( memoria de marca o no ). Tonos de la BIOS Phoenix La duración de los pitidos se mide de uno a cuatro. Esta BIOS es propiedad desde hace dos años de AWARD y estaba muy presente en equipos portátiles. 1-2-2-3: error del código de verificación de la ROM. En otras palabras BIOS corrupta 1-3-1-1: fallo en el testeo del refresco de la memoria DRAM. Revisamos que la memoria RAM este bien instalada y su configuración de BUS sea correcta. 1-3-1-3: error en el test de del controlador del teclado. Procedemos a conectarlo bien, si persiste cambiaremos la placa ya que la controladora de teclado esta mal. 1-3-4-1: error en una dirección de memoria. Evidentemente el testeo de la RAM ha fallado tendremos que reemplazarla o revisaremos si estaba bien instalada. 1-3-4-3: error en una dirección del área de memoria baja. Idem 2-1-2-3: error en la ROM del sistema .La BIOS esta corrupta o no se ha podido acceder a ella( leer / escribir).Tratamos de flasearla, o de sustituir el chip de la BIOS por otro idéntico. 2-2-3-1: problemas con interrupciones de sistema. Entramos en la BIOS la procedemos a configurar correctamente. Errores en pantalla Otras veces no oímos ningún pitido y si nos parece en la pantalla alguno de estos errores. Estos errores no dependen del tipo de BIOS. Y son comunes a todos ellos. *BIOS ROM checksun error – system halted: el código de control de la BIOS es incorrecto, lo que indica que puede estar corrupta. En caso de reiniciar y repetir el mensaje, tendremos que reemplazar al BIOS. *CMOS battery faled: la pila de la placa base que alimenta la memoria CMOS ha dejado de suministrar corriente. Es necesario cambiar la pila inmediatamente. *CMOS checksum error – Defaults loaded: el código de control de la CMOS no es correcto, por lo que se procede a cargar los parámetros de la BIOS por defecto. Este error se produce por que la información almacenada en la CMOS es incorrecta, lo que puede indicar que la pila está empezando a fallar. *Display switch is set incorrectly: el tipo de pantalla especificada en la BIOS es incorrecta. Esto puede ocurrir si hemos seleccionado la existencia de un adaptador monocromo cuando tenemos uno en color, o al contrario. Bastará con poner bien este parámetro para solucionar el problema *Floppy disk(s) Fail ( code 40/38/48 dependiendo de la antigüedad de la bios): Disquetera mal conectada, verificamos todos los cables de conexión. *Hard disk install failure: la BIOS no es capaz de inicializar o encontrar el disco duro de manera correcta. Debemos estar seguros de que todos de que todos los discos se encuentren bien conectados y correctamente configurados. *Keyboard error or no keyboard present: no es posible inicializar el teclado. Puede ser debido a que n se encuentre conectado, este estropeado e incluso porque mantenemos pulsada alguna tecla durante el proceso de arranque. *Keyboard error is locked out – Unlock the key: este mensaje solo aparece en muy pocas BIOS, cuando alguna tecla ha quedado presionada. *Memory Test Fail: el chequeo de memoria RAM ha fallado debido probablemente, a errores en los módulos de memoria. En caso de que nos aparezca este mensaje, hemos de tener mucha precaución con el equipo, se puede volver inestable y tener perdidas de datos. Solución, comprobar que banco de memoria esta mal, y ustituirlo inmediatamente. *Override enabled – Defaults loaded: si el sistema no puede iniciarse con los valores almacenados en la CMOS, la BIOS puede optar por sustituir estos por otros genéricos diseñados para que todo funcione de manera estable, aunque sin obtener las mayores prestaciones. *Primary master hard diskfail: el proceso de arranque ha detectado un fallo al iniciar el disco colocado como maestro en el controlador IDE primario. Para solucionar comprobaremos las conexiones del disco y la configuración de la BIOS. GRACIAS POR SUS COMENTARIOS Y PUNTOS

En este videotutorial aprenderán de una manera muy sencilla a realizar altas, bajas y consultas utilizando Visual Basic, crear la base de datos con Mysql workbeanch y realizar operaciones sobre la misma. Espero que lo disfruten saludos link: http://www.youtube.com/watch?v=g-nHzpMfaE8&feature=youtu.be

La gerente de Microsoft Julie Larson-Green rechazó de forma enfática en la conferencia que Windows 8 sea más de lo mismo con un mejor envoltorio . No se trata de una nueva capa colocada sobre las anteriores versiones, sino de un nuevo sistema operativo completo, aseguró la ejecutiva. Esta nueva edición tendrá un cambio radical respecto al hardware, ya que el sistema no solo admite la familia de chips x86 de Intel y AMD, sino también la arquitectura ARM que se encuentra en las tabletas como el iPad o Motorola Xoom, un segmento de equipos que ganaron su espacio ante el retroceso que tuvieron en el mercado las computadoras portátiles y de escritorio. link: http://www.youtube.com/watch?v=p92QfWOw88I link: http://www.youtube.com/watch?v=oOEVp05gqKg

Más de la mitad de los usuarios de Facebook son mujeres El país con más miembros es Estados Unidos El grupo de edad donde más se utiliza Facebook está en la gente entre 18 y 25 años El país sudamericano con mayor participación dentro de la Red Social es Colombia, seguido de Chile y Argentina Argentina es la nación sudamericana que experimentó un mayor crecimiento en número de usuarios dentro del último año Menos del 1% de los miembros de Facebook en Sudamérica tiene más de 65 años México es la mayor potencia de habla hispana dentro de Facebook Casi el 16% de los argentinos en Facebook es menor de 18 años Sólo el 3% de los usuarios de Facebook en Argentina están por sobre los 55 años El sitio de Facebook está disponible en más de 70 idiomas Más de un millón de desarrolladores y programadores trabajan en páginas y aplicaciones para Facebook El 70% de los usuarios de Facebook se interesa mensualmente en alguna plataforma diferente de aplicaciones 80 mil sitios web tienen disponible la opción Facebook Connect La mitad de los sitios más visitados a nivel mundial utilizan Facebook Connect Cien millones de usuarios acceden a Facebook desde sus teléfonos móviles 200 operadoras de telefonía móvil tienen disponible aplicaciones para que sus clientes accedan a Facebook Más de 400 millones de usuarios activos La mitad entra diariamente al sitio Cada día más de 35 millones de usuarios actualizan su estado Diariamente se realizan 60 millones de actualizaciones de estado Cada usuario tiene en promedio 130 amigos Los usuarios pasan 55 minutos al día en Facebook Cada usuario realiza en promedio 25 comentarios al mes Los usuarios pulsan sobre algún “Me gusta” al menos 9 veces mensualmente Cada miembro de Facebook recibe 8 peticiones de amistad por mes Estados Unidos es el país con más usuarios de Facebook (111 millones) El 70% de los usuarios vive fuera de los Estados Unidos Cada mes se crean tres millones y medio de eventos Existen más de 3 millones de páginas activas en Facebook La mitad de ellas pertenecen a algún tipo de negocio 20 millones de usuarios se hacen fans de alguna página diariamente El usuario común recibe invitaciones a 3 eventos por mes Sumando los fans de cada página, en Facebook existen 5,3 billones de fanáticos (una persona puede ser fan de varias páginas a la vez)