Entrada destacada

Solucion error AjaxControlToolkit requires ASP.NET Ajax 4.0 scripts

Ajax Control Toolkit en ASP.NET Ajax Library Detalles de la Versión :(AspNetAjaxLibraryBeta0911.zip application, 6490K, uploaded Nov 18 ...

Mostrando entradas con la etiqueta informática. Mostrar todas las entradas
Mostrando entradas con la etiqueta informática. Mostrar todas las entradas

viernes, 5 de febrero de 2016

Android Dialogs - Como crear un ProgressDialog

Empezaremos nuestro primer ejemplo en desarrollo Android con el ProgressDialog, que es una barra de progreso que se irá incrementando de acuerdo a nuestra necesidad.

Como ya tenemos todo preparado desde el artículo anterior “Crear un nuevo Proyecto en Android Studio”, vamos a nuestro archivo MainActivity.java e importamos estas dos librerías con el siguiente código que colocaremos debajo de

package com.dialogos.ejemplo.ejemplodialogos;
import android.app.ProgressDialog;
import android.os.Handler;

Ahora vamos al final del código y antes del último cierre de llaves ”}” creamos el método privado mostrarBarraProgreso

private void mostrarBarraProgreso(){
    
}

Fuera de nuestro método definiremos dos variables:

private ProgressDialog barraProgreso;
private Handler handler;

Dentro del método crearemos nuestra barra de progreso que recibirá la instancia de la actividad, le asignaremos un titulo, un mensaje, le daremos un estilo, su valor actual de progreso, un valor máximo al que llegará y lo mostraremos por pantalla:

private void mostrarBarraProgreso(){
    barraProgreso = new ProgressDialog(MainActivity.this);
    barraProgreso.setTitle("Buscando...");
    barraProgreso.setMessage("Progreso...");
    barraProgreso.setProgressStyle(barraProgreso.STYLE_HORIZONTAL);
    barraProgreso.setProgress(0);
    barraProgreso.setMax(10);
    barraProgreso.show();
}

Ahora crearemos un Thread o Hilo que nos ayudará a gestionar la evolución de la barra de progreso. El Thread recibe como parámetro un Runnable que tiene un método run(). Al escribir new Runnable y dar "Enter", Android Studio agrega el resto.

new Thread(new Runnable() {
    @Override
    public void run() {

    }
}).start();

También vamos a crear un objeto de tipo Handler para poder manejar la post ejecución del Thread.

handler = new Handler();

Con todo nuestro código ya debe verse así:

private void mostrarBarraProgreso(){
    barraProgreso = new ProgressDialog(MainActivity.this);
    barraProgreso.setTitle("Buscando...");
    barraProgreso.setMessage("Progreso...");
    barraProgreso.setProgressStyle(barraProgreso.STYLE_HORIZONTAL);
    barraProgreso.setProgress(0);
    barraProgreso.setMax(10);
    barraProgreso.show();

    handler = new Handler();


    new Thread(new Runnable() {
        @Override
        public void run() {

        }
    }).start();
}

Dentro del metodo run() agregamos la lógica para incrementar nuestra barra de progreso con un While que se mantendrá mientras el progreso de la barra sea menor al máximo que definimos que es 10. Haremos que el Thread duerma cada 1 segundo con Thread.sleep(1000) para evitar que la barra avance demasiado rápido y cuando llegue al máximo la ocultaremos de pantalla. Todo lo anterior lo envolvemos en un control de errores try catch.

El código para todo esto es:

try {
    while (barraProgreso.getProgress() <= barraProgreso.getMax()) {
        Thread.sleep(1000);

        handler.post(new Runnable() {
            @Override
            public void run() {
                barraProgreso.incrementProgressBy(1);
            }
        });

        if(barraProgreso.getProgress() == barraProgreso.getMax()){
            barraProgreso.dismiss();
        }
    }
}catch (InterruptedException er){
    er.printStackTrace();
}

El barraProgreso.incrementProgressBy(1) permite incrementar la barra en 1 y el barraProgreso.dismiss() la oculta.

y por ultimo solo queda llamar a nuestro método mostrarBarraProgreso lo cual haremos desde el onCreate de nuestro MainActivity quedando todo nuestro archivo MainActivity.java así:

package com.dialogos.ejemplo.ejemplodialogos;

import android.app.ProgressDialog;
import android.os.Bundle;
import android.os.Handler;
import android.support.design.widget.FloatingActionButton;
import android.support.design.widget.Snackbar;
import android.support.v7.app.AppCompatActivity;
import android.support.v7.widget.Toolbar;
import android.view.View;
import android.view.Menu;
import android.view.MenuItem;

public class MainActivity extends AppCompatActivity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
        Toolbar toolbar = (Toolbar) findViewById(R.id.toolbar);
        setSupportActionBar(toolbar);

        FloatingActionButton fab = (FloatingActionButton) findViewById(R.id.fab);
        fab.setOnClickListener(new View.OnClickListener() {
            @Override
            public void onClick(View view) {
                Snackbar.make(view, "Replace with your own action", Snackbar.LENGTH_LONG)
                        .setAction("Action", null).show();
            }
        });

        mostrarBarraProgreso();
    }

    @Override
    public boolean onCreateOptionsMenu(Menu menu) {
        // Inflate the menu; this adds items to the action bar if it is present.
        getMenuInflater().inflate(R.menu.menu_main, menu);
        return true;
    }

    @Override
    public boolean onOptionsItemSelected(MenuItem item) {
        // Handle action bar item clicks here. The action bar will
        // automatically handle clicks on the Home/Up button, so long
        // as you specify a parent activity in AndroidManifest.xml.
        int id = item.getItemId();

        //noinspection SimplifiableIfStatement
        if (id == R.id.action_settings) {
            return true;
        }

        return super.onOptionsItemSelected(item);
    }

    private ProgressDialog barraProgreso;
    private Handler handler;

    private void mostrarBarraProgreso(){
        barraProgreso = new ProgressDialog(MainActivity.this);
        barraProgreso.setTitle("Buscando...");
        barraProgreso.setMessage("Progreso...");
        barraProgreso.setProgressStyle(barraProgreso.STYLE_HORIZONTAL);
        barraProgreso.setProgress(0);
        barraProgreso.setMax(10);
        barraProgreso.show();

        handler = new Handler();

        new Thread(new Runnable() {
            @Override
            public void run() {
                try {
                    while (barraProgreso.getProgress() <= barraProgreso.getMax()) {
                        Thread.sleep(1000);

                        handler.post(new Runnable() {
                            @Override
                            public void run() {
                                barraProgreso.incrementProgressBy(1);
                            }
                        });

                        if(barraProgreso.getProgress() == barraProgreso.getMax()){
                            barraProgreso.dismiss();
                        }
                    }
                }catch (InterruptedException er){
                    er.printStackTrace();
                }
            }
        }).start();
    }
}

Ahora solo queda probar, para lo cual vamos a la barra de menú en Run->Run ‘app’ o en el triangulo verde del tool bar.

Seleccionamos nuestro dispositivo creado en el artículo anterior “Crear un nuevo Proyecto en Android Studio”, en mi caso el Nexus 5 API 17 y clic en OK

Ahora un poco de paciencia ya que se demora en levantar el emulador e instalar nuestra aplicación y toma varios minutos. Cuando se encuentre listo veremos algo como esto:

Desbloqueamos la pantalla con el mouse arrastrando el candado hacia afuera (obvio que ya lo sabían pero nunca está de más decirlo). Si solo ven una pantalla en blanco, vuelvan a ejecutar la aplicación en Run->Run ‘app’ pero no cierren la ventana del emulador así ahora todo irá mas y veremos nuestro dialogo con la barra de progreso:

Bueno, esto es todo por hoy, en la próxima veremos más ejemplos con otros Dialogs.

Toby

jueves, 4 de febrero de 2016

Crear un nuevo Proyecto en Android Studio

A continuación quiero mostrarles un poco de programación en Android con el Android Studio el cual ya debemos tener instalado y configurado, además quiero salirme del típico ejemplo de “¡Hola Mundo!” o “Hello World!”, así que voy a realizar un ejemplo con diálogos. Los Android Dialogs son pequeñas ventanas que pueden interactuar con el usuario para mostrar o solicitar algún tipo de información.

Quiero aclarar que me centraré solo en el ejemplo y evitaré entrar en la teoría, ya que existe mucha documentación en la Red y no quiero alargarme ni aburrirlos antes de tiempo, así que hoy solo vamos a crear el proyecto y dejar todo listo para los siguientes días.

Empecemos. Luego de iniciar Android Studio damos clic en “Start a new Android Studio project”. Si ya lo teníamos abierto, desde el menú vamos a File->New->New Project.

Ingresamos el Application name y Company Domain, el Project location lo dejamos tal cual y damos clic en Next y en la siguiente ventana dejamos tal cual y Next.

Acá seleccionamos Blank Activity y Next

En Activity dejamos los valores que nos da por defecto y damos clic en Finish.

Dependiendo de los recursos que tengamos en nuestra maquina de desarrollo va a ser el tiempo que demore el proceso en estar listo, así que paciencia.

Una vez listo tendremos lo siguiente:

Vamos a aprovechar de hacer clic sobre el “Hello World!” y lo suprimimos. Ahora para finalizar vamos a crear nuestro dispositivo virtual que es en donde vamos a probar nuestros desarrollos. Damos clic en el icono AVD Manager del Tool bar

Damos clic en Create Virtual Device

Seleccionamos Nexus 5 y damos clic en Next

Ahora debemos seleccionar la API 17. Si no la tienen pueden instalarla dando clic en “Show downloadable system images”. Después damos clic en Next

Acá dejamos todo igual, pero si necesitamos ajustar valores como por ejemplo la RAM que usaremos en el dispositivo, damos clic en “Show Advanced Settings”. Y damos clic en Finish

Con esto ya tendríamos todo listo para los ejemplos que realizaremos más adelante. Nos vemos.

Toby

miércoles, 17 de diciembre de 2008

Los Sistemas Expertos

Los Sistemas Expertos, son sistemas informáticos que simulan el proceso de aprendizaje, de memorización, de razonamiento, de comunicación y de acción de un experto humano en cualquier rama de la ciencia. Estas características le permiten almacenar datos y conocimiento, sacar conclusiones lógicas, tomar decisiones, aprender de la experiencia y los datos existentes, comunicarse con expertos humanos, explicar el por qué de las decisiones tomadas y realizar acciones como consecuencia de todo lo anterior.

¿Qué condiciones deben cumplirse para que sea adecuado emplear un sistema experto para resolver un problema?

Las condiciones que deben cumplirse son:

Ø Falta de especialistas en la empresa u organización.
Ø Que la información que exista se encuentre desordenada.
Ø Falta de tiempo para capacitar a las personas o trabajadores de la empresa.
Ø Cuando los expertos humanos en una determinada materia son escasos.
Ø En situaciones complejas, donde la subjetividad humana puede llevar a conclusiones erróneas.
Ø Cuando es muy elevado el volumen de datos que ha de considerarse para obtener una conclusión.
Ø Que los expertos dispongan de conocimientos complejos en un área muy delimitada, donde no existan algoritmos ya establecidos (o donde los existentes no puedan solucionar algunos problemas).
Ø Que encontremos teorías que resulten prácticamente imposibles de analizar todos los casos teóricamente imaginables mediante algoritmos y en un espacio de tiempo relativamente corto y razonable.
Ø Que la estructuración e implementación del conocimiento del experto requiera una gran cantidad de trabajo.
Ø Cuando el conocimiento sea válido durante un largo espacio de tiempo y vaya a ser utilizado por el mayor número de personas.
Ø Cuando se desee evitar fallos en labores rutinarias complejas.
Ø Cuando se quiera ampliar de forma más rápida los conocimientos de los especialistas.
Ø Cuando se desee diagnosticar los fallos con mayor rapidez y conseguir tareas de planificación más completas y consistentes.
Ø Cuando se desee que personas con poca experiencia pueden resolver problemas que requieren un "conocimiento formal especializado".


¿Cuáles son las principales limitaciones de los PC para utilizar un sistema experto?

Las principales limitaciones que presentan los PC para utilizar un sistema experto son el hardware disponible como:

Ø La cantidad de memoria que tenga el PC.
Ø La capacidad y velocidad del procesador.
Ø El tamaño del disco duro para la capacidad de almacenamiento para la base del conocimiento.


¿Cómo se crea una base de conocimientos?

Para poder crear una base de conocimientos, primero se debe recopilar toda la información trascendente que poseen los especialistas de la organización, luego ordenarla y transferirla a la base de conocimientos.
El experto debe comprobar constantemente si su conocimiento ha sido transmitido de la forma más conveniente.
El ingeniero del conocimiento es responsable de una implementación correcta, pero no de la exactitud del conocimiento. La responsabilidad de esta exactitud recae en el experto.
Para obtener el conocimiento de los expertos se puede realizar por medio de entrevistas, reuniones, formulario, etc.


¿Cómo se comprueba y justifica un sistema experto?

Para poder comprobar y validar un sistema experto se debe consultar a los especialistas que contribuyeron con la información para la creación del sistema experto y con los usuarios para saber si el sistema cumple y satisface las necesidades para las cuales fue creado.


¿Cómo se asegura la validez de un sistema experto?

Para asegurar la validez de un sistema experto se debe mantener siempre actualizada su base de conocimientos con nueva información que se vaya incorporando al área del conocimiento en la cual se esta trabajando. Además, debe seguir cumpliendo y satisfaciendo los objetivos para los cuales fue creado.

Entradas populares