Controles Básicos de Android Studio
1.1. Definición
El SDK de Android proporciona tres tipos de botones: el clásico (Button), el de tipo on/off (ToggleButton), y el que puede contener una imagen (ImageButton). En la imagen siguiente se aprecia el aspecto por defecto de estos tres controles.
Pero ¿Que son los controles?
Realmente son objetos que disponen de sus propias propiedades y métodos, y cuya utilidad es la de facilitarnos el desarrollo de nuestras aplicaciones. Bueno, este intento de definición puede haber quedado bien, pero para que lo tengáis más claro, tener en cuenta que en cualquier aplicación con la que trabajamos estamos rodeados de controles. Quien no ha visto en multitud de programas los botones ACEPTAR y CANCELAR, un cuadro para introducir texto, una lista con datos, etc.. Pues todos ellos son controles y no tendremos que preocuparnos por crearlos para nuestras aplicaciones sino que ya vienen con el paquete de VB, lo único que tendremos que hacer es modificar sus propiedades: tamaño, color, etc.. para incorporarlos en nuestras aplicaciones y asociarles el código necesario para que se comporten como esperamos al ejecutar la aplicación.
Este tutorial muestra los pasos para crear un número diferente de controles TextView en su aplicación Android. Primero, aprenda a cómo añadir controles de texto básicos a sus archivos layout y lo que son algunos de sus atributos más útiles. Después aprenda cómo ajustar los contenidos de los controles de texto en dos formas diferentes. Finalmente, discutiremos algunas de las otras características disponibles para los controles TextView en Android. Android SDK incluye un control de texto static sencillo para usar dentro de sus layouts: TextView (android.widget.TextView). Un buen ejemplo del uso de los controles TextView sería mostrar etiquetas textuales para otros controles como: "Enter a Date:", o "Enter a Password:".
1.2. Controles EdiText, Button, TextView
1.2.1. Control EditText
El control EditText es el componente de edición de texto que proporciona la plataforma Android. Permite la introducción y edición de texto por parte del usuario, por lo que en tiempo de diseño la propiedad más interesante a establecer, además de su posición/tamaño y formato, es el texto a mostrar, atributo android:text. Por supuesto si no queremos que el cuadro de texto aparezca inicializado con ningún texto, no es necesario incluir esta propiedad en el layout XML. Lo que sí deberemos establecer será la propiedad android:inputType. Esta propiedad indica el tipo de contenido que se va a introducir en el cuadro de texto, como por ejemplo una dirección de correo electrónico (textEmailAddress), un número genérico (number), un número de teléfono (phone), una dirección web (textUri), o un texto genérico (text). El valor que establezcamos para esta propiedad tendrá además efecto en el tipo de teclado que mostrará Android para editar dicho campo. Así, por ejemplo, si hemos indicado “text” mostrará el teclado completo alfanumérico, si hemos indicado “phone” mostrará el teclado numérico del teléfono, etc.
Ejemplo:
<EditText android:id="@+id/TxtBasico" android:layout_width="match_parent" android:layout_height="wrap_content" android:inputType="text" />
Al igual que ocurría con los botones, donde podíamos indicar una imagen que acompañara al texto del mismo, con los controles de texto podemos hacer lo mismo. Las propiedades drawableLeft o drawableRight nos permite especificar una imagen, a izquierda o derecha, que permanecerá fija en el cuadro de texto.
Otra opción adicional será indicar un texto de ayuda o descripción (hint), que aparecerá en el cuadro de texto mientras el usuario no haya escrito nada (en cuanto se escribe algo este texto desaparece). Para esto utilizaremos las propiedades android:hint para indicar el texto y android:textColorHint para indicar su color. Veamos un ejemplo utilizando las propiedades anteriores:
<EditText android:id="@+id/TxtImagenHint" android:layout_width="match_parent" android:drawableLeft="@drawable/ic_usuario" android:layout_height="wrap_content" android:hint="@string/usuario" android:inputType="text" /> android:textColorHint="#CFCFCF"
Un detalle que puede haber pasado desapercibido. ¿Os habéis fijado en que hemos tenido que hacer un toString() sobre el resultado de getText()? La explicación para esto es que el método getText() no devuelve directamente una cadena de caracteres (String) sino un objeto de tipo Editable, que a su vez implementa la interfaz Spannable. Y esto nos lleva a la característica más interesante del control EditText, y es que no sólo nos permite editar texto plano sino también texto enriquecido o con formato. Veamos cómo y qué opciones tenemos disponibles, y para empezar comentemos algunas cosas sobre los objetos Spannable.
1.2.2. Control Button
Un control de tipo Button es el botón más básico que podemos utilizar y normalmente contiene un simple texto. En el ejemplo siguiente definimos un botón con el texto “Click” asignando su propiedad android:text. Además de esta propiedad podríamos utilizar muchas otras como el color de fondo (android:background), estilo de fuente (android:typeface), color de fuente (android:textcolor), tamaño de fuente (android:textSize), etc.
Ejemplo:
Ejemplo:
<Button android:id="@+id/BtnBotonSimple" android:text="@string/click" android:layout_width="wrap_content" android:layout_height="wrap_content" />
Personalizar el aspecto un botón
En las imágenes mostradas durante este apartado hemos visto el aspecto que presentan por defecto los diferentes tipos de botones disponibles. Pero, ¿y si quisiéramos personalizar su aspecto más allá de cambiar un poco el tipo o el color de la letra o el fondo?
Para cambiar la forma de un botón podríamos simplemente asignar una imagen a la propiedad android:background, pero esta solución no nos serviría de mucho porque siempre se mostraría la misma imagen incluso con el botón pulsado, dando poca sensación de elemento “clickable“.
La solución perfecta pasaría por tanto por definir diferentes imágenes de fondo dependiendo del estado del botón. Pues bien, Android nos da total libertad para hacer esto mediante el uso de selectores. Un selector se define mediante un fichero XML localizado en la carpeta /res/drawable, y en él se pueden establecer los diferentes valores de una propiedad determinada de un control dependiendo de su estado.
Por ejemplo, si quisiéramos dar un aspecto diferente a nuestro botón ToggleButton, para que sea de color azul y con esquinas redondeadas, podríamos diseñar las imágenes necesarias para los estados “pulsado” (en el ejemplo toggle_on.9.png) y “no pulsado” (en el ejemplo toggle_off.9.png) y crear un selector como el siguiente:
<selector xmlns:android="http://schemas.android.com/apk/res/android"> <item android:state_checked="false" android:drawable="@drawable/toggle_off" /> <item android:state_checked="true" android:drawable="@drawable/toggle_on" /> </selector>
En el código anterior vemos cómo se asigna a cada posible estado del botón una imagen (un elemento drawable) determinada. Así, por ejemplo, para el estado “pulsado” (state_checked=”true”) se asigna la imagen toggle_on.
Este selector lo guardamos por ejemplo en un fichero llamado toggle_style.xml y lo colocamos como un recurso más en nuestra carpeta de recursos /res/drawable. Hecho esto, tan sólo bastaría hacer referencia a este nuevo recurso que hemos creado en la propiedad android:background del botón:
<ToggleButton android:id="@+id/BtnPersonalizado"android:textOn="@string/on"android:layout_width="wrap_content"android:textOff="@string/off"android:background="@drawable/toggle_style" />android:layout_height="wrap_content"
1.2.3. Control TextView
El control TextView es otro de los clásicos en la programación de GUIs, las etiquetas de texto, y se utiliza para mostrar un determinado texto al usuario. Al igual que en el caso de los botones, el texto del control se establece mediante la propiedad android:text. A parte de esta propiedad, la naturaleza del control hace que las más interesantes sean las que establecen el formato del texto mostrado, que al igual que en el caso de los botones son las siguientes: android:background (color de fondo), android:textColor (color del texto), android:textSize (tamaño de la fuente) y android:typeface (estilo del texto: negrita, cursiva, …).
Ejemplo:
<TextView android:id="@+id/LblEtiqueta" android:layout_width="match_parent" android:layout_height="wrap_content" android:text="@string/escribe_algo" android:background="#ff1ca5ff" android:typeface="monospace"/>
De igual forma, también podemos manipular estas propiedades desde nuestro código. Como ejemplo, en el siguiente fragmento recuperamos el texto de una etiqueta con getText(), y posteriormente le concatenamos unos números, actualizamos su contenido mediante setText() y le cambiamos su color de fondo con setBackgroundColor().
final TextView lblEtiqueta = (TextView)findViewById(R.id.LblEtiqueta);
String texto = lblEtiqueta.getText().toString();
texto += "123";
lblEtiqueta.setBackgroundColor(Color.BLUE);
lblEtiqueta.setText(texto);
1.2.3. Control imageview
El control ImageView permite mostrar imágenes en la aplicación. La propiedad más interesante es android:src, que permite indicar la imagen a mostrar. Nuevamente, lo normal será indicar como origen de la imagen el identificador de un recurso de nuestra carpeta /res/drawable, por ejemplo android:src=”@drawable/unaimagen”. Además de esta propiedad, existen algunas otras útiles en algunas ocasiones como las destinadas a establecer el tamaño máximo que puede ocupar la imagen, android:maxWidth y android:maxHeight, o para indicar cómo debe adaptarse la imagen al tamaño del control, android:scaleType (5=CENTER, 6=CENTER_CROP, 7=CENTER_INSIDE, …). Además, como ya comentamos para el caso de los controles ImageButton, al tratarse de un control de tipo imagen deberíamos establecer siempre la propiedad android:contentDescription para ofrecer una breve descripción textual de la imagen, algo que hará nuestra aplicación mucho más accesible.
Ejemplo:
<ImageView android:id="@+id/ImgFoto" android:layout_width="wrap_content" android:layout_height="wrap_content" android:src="@drawable/ic_launcher" android:contentDescription="@string/imagen_ejemplo" />
Si en vez de establecer la imagen a mostrar en el propio layout XML de la actividad quisiéramos establecerla mediante código utilizaríamos el método setImageResorce(…), pasándole el ID del recurso a utilizar como contenido de la imagen.
ImageView img= (ImageView)findViewById(R.id.ImgFoto); img.setImageResource(R.drawable.ic_launcher);
Texto con formato en controles TextView y EditTextHemos visto cómo crear un objeto Editable y añadir marcas de formato al texto que contiene, pero todo esto no tendría ningún sentido si no pudiéramos visualizarlo. Como ya podéis imaginar, los controles TextView y EditText nos van a permitir hacer esto. Veamos qué ocurre si asignamos a nuestro control EditText el objeto Editable que hemos creado antes:
1
| txtTexto.setText(str); |
Tras ejecutar este código, para lo que hemos insertado un botón “SetText” en la aplicación de ejemplo, veremos como efectivamente en el cuadro de texto aparece el mensaje con el formato esperado:
En la aplicación de ejemplo también he incluido un botón adicional “Negrita” que se encargará de convertir a estilo negrita un fragmento de texto previamente seleccionado en el cuadro de texto. Mi intención con esto es presentar los métodos disponibles para determinar el comienzo y el fin de una selección en un control de este tipo. Para ello utilizaremos los métodos getSelectionStart() y getSelectionEnd(), que nos devolverán el índice del primer y último carácter seleccionado en el texto. Sabiendo esto, ya sólo nos queda utilizar el método setSpan() que ya conocemos para convertir la selección a negrita.
1
2
3
4
5
6
7
8
9
| Spannable texto = txtTexto.getText();int ini = txtTexto.getSelectionStart();int fin = txtTexto.getSelectionEnd();texto.setSpan( new StyleSpan(android.graphics.Typeface.BOLD), ini, fin, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE); |
Bien, ya hemos visto cómo asignar texto con y sin formato a un cuadro de texto, pero ¿qué ocurre a la hora de recuperar texto con formato desde el control? Ya vimos que la función getText() devuelve un objeto de tipo Editable y que sobre éste podíamos hacer un toString(). Pero con esta solución estamos perdiendo todo el formato del texto, por lo que no podríamos por ejemplo salvarlo a una base de datos.
La solución a esto último pasa obviamente por recuperar directamente el objeto Editable y serializarlo de algún modo, mejor aún si es en un formato estandar. Pues bien, en Android este trabajo ya nos viene hecho de fábrica a través de la clase Html [API], que dispone de métodos para convertir cualquier objeto Spanneden su representación HTML equivalente. Veamos cómo. Recuperemos el texto de la ventana anterior y utilicemos el método Html.toHtml(Spannable) para convertirlo a formato HTML:
1
2
| //Obtiene el texto del control con etiquetas de formato HTMLString aux2 = Html.toHtml(txtTexto.getText()); |
Haciendo esto, obtendríamos una cadena de texto como la siguiente, que ya podríamos por ejemplo almacenar en una base de datos o publicar en cualquier web sin perder el formato de texto establecido:
1
| <p>Esto es un <b>simulacro</b>.</p> |
La operación contraria también es posible, es decir, cargar un cuadro de texto de Android (EditText) o una etiqueta (TextView) a partir de un fragmento de texto en formato HTML. Para ello podemos utilizar el método Html.fromHtml(String) de la siguiente forma:
1
2
3
4
| //Asigna texto con formato HTMLtxtTexto.setText( Html.fromHtml("<p>Esto es un <b>simulacro</b>.</p>"), BufferType.SPANNABLE); |
Desgraciadamente, aunque es de agradecer que este trabajo venga hecho de casa, hay que decir que tan sólo funciona de forma completa con las opciones de formato más básicas, como negritas, cursivas, subrayado o colores de texto, quedando no soportadas otras sorprendentemente básicas como el tamaño del texto, que aunque sí es correctamente traducido por el método toHtml(), es descartado por el método contrario fromHtml().
Etiquetas Flotantes (Floating Labels)
Como contenido extra de este capítulo vamos a hablar de un nuevo control publicado recientemente por Google dentro de la nueva librería de diseño (Design Support Library) que nos ayuda a implementar uno de los componentes relacionados con los cuadros de texto que se mencionan en las especificaciones de Material Design. Se trata de las etiquetas flotantes, que no es más que un hint (más arriba vimos lo que era esto) que, en vez de desaparecer, se desplaza automáticamente a la parte superior del cuadro de texto cuando el usuario pulsa sobre él.
El componente en cuestión se llama TextInputLayout, y es muy sencillo de utilizar. Lo primero que haremos será añadir la librería de diseño a nuestro proyecto (en el artículo anterior sobre botonesexplicamos con más detalle cómo hacerlo) añadiendo su referencia al fichero build.gradle:
1
2
3
4
| dependencies { //... compile 'com.android.support:design:22.2.0'} |
Tras esto, simplemente tendremos que añadir un nuevo EditText con hint a nuestra interfaz, pero esta vez dentro de un contenedor de tipo TextInputLayout:
1
2
3
4
5
6
7
8
9
10
11
| <android.support.design.widget.TextInputLayout android:id="@+id/TiLayout" android:layout_width="match_parent" android:layout_height="wrap_content" > <EditText android:id="@+id/TxtInput" android:layout_width="match_parent" android:layout_height="wrap_content" android:hint="Escribe un número par" /></android.support.design.widget.TextInputLayout> |
Como podéis ver no hacemos nada especial, ni asignamos ninguna propiedad nueva, simplemente incluimos el cuadro de texto dentro del nuevo componente TextInputLayout.
Si ejecutamos en este momento la aplicación podremos ver cómo aparece la etiqueta flotante con tan sólo pulsar sobre el cuadro de texto.
Con esto ya tendríamos la funcionalidad básica de las etiquetas flotantes, pero el control ofrece también la posibilidad de mostrar errores (muy útiles por ejemplo para mostrar errores de validación) bajo el cuadro de texto. Para ello podemos utilizar los métodos setErrorEnabled(true) y setError(). El primero de ellos reservará espacio debajo del cuadro de texto para mostrar los errores. El segundo nos servirá para indicar el texto del error o para eliminarlo (pasando null como parámetro). A modo de ejemplo, he añadido un nuevo botón a la aplicación (btnComprobar) donde comprobaré si lo introducido por el usuario es o nó un número par, mostrando el error correpsondiente cuando aplique:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
| txtInputLayout = (TextInputLayout)findViewById(R.id.TiLayout);txtInputLayout.setErrorEnabled(true);txtInput = (EditText)findViewById(R.id.TxtInput);btnComprobar = (Button)findViewById(R.id.BtnInputLayout);btnComprobar.setOnClickListener(new View.OnClickListener() { @Override public void onClick(View view) { String num = txtInput.getText().toString(); if(num.isEmpty() || Integer.parseInt(num)%2 != 0) txtInputLayout.setError("Error: No es un número par!"); else txtInputLayout.setError(null); }}); |
Si volvemos a ejecutar ahora la aplicación de ejemplo e introducimos un número impar, veremos cómo el mensaje de error aparece correctamente bajo el cuadro de texto:
1.3.1. Ejemplo 01
inal Button btnBoton1 = (Button)findViewById(R.id.BtnBoton1);
btnBoton1.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View arg0)
{
lblMensaje.setText("Botón 1 pulsado!");
}
});
En el caso de un botón de tipo ToggleButton suele ser de utilidad conocer en qué estado ha quedado elbotón tras ser pulsado, para lo que podemos utilizar su método isChecked(). En el siguiente ejemplo se comprueba el estado del botón tras ser pulsado y se realizan acciones distintas según el resultado.
final ToggleButton btnBoton2 = (ToggleButton)findViewById(R.id.BtnBoton2);
btnBoton2.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View arg0)
{
if(btnBoton2.isChecked())
lblMensaje.setText("Botón 2: ON");
else
lblMensaje.setText("Botón 2: OFF");
}
});
1.3.1. Ejemplo 02<?xml version="1.0" encoding="utf-8"?>
<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
android:layout_width="fill_parent"
android:layout_height="fill_parent"
android:orientation="horizontal">
<EditText android:id="@+id/edit_message"
android:layout_weight="1"
android:layout_width="0dp"
android:layout_height="wrap_content"
android:hint="@string/edit_message" />
<Button android:id="@+id/button_send"
android:layout_width="wrap_content"
android:layout_height="wrap_content"
android:text="@string/button_send"
android:onClick="sendMessage" />
</LinearLayout>
public class ActividadBotones extends AppCompatActivity {
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.actividad_botones);
Button boton = (Button) findViewById(R.id.button);
boton.setText("Ordenar");
}
}
<?xml version="1.0" encoding="utf-8"?> <RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android" xmlns:app="http://schemas.android.com/apk/res-auto" xmlns:tools="http://schemas.android.com/tools" android:layout_width="match_parent" android:layout_height="match_parent" android:paddingBottom="@dimen/activity_vertical_margin" android:paddingLeft="@dimen/activity_horizontal_margin" android:paddingRight="@dimen/activity_horizontal_margin" android:paddingTop="@dimen/activity_vertical_margin" tools:context="com.herprogramacion.botones.ActividadBotones"> <Button android:id="@+id/button" android:layout_width="wrap_content" android:layout_height="wrap_content" android:layout_centerHorizontal="true" android:layout_centerVertical="true" app:backgroundTint="@color/colorPrimary" android:text="@string/texto_agregar" /> </RelativeLayout>
Los controles básicos de Android nos pemitirán diseñar aplicaciones simples de manera rápida. Este grupo de controles básicos está compuesto por los TextView, EditText, CheckBox, RadioButton, Button, ToggleButton, ImageButton e ImageView. A continuación los describiremos brevemente y comentaremos los parámetros principales más importantes de cada uno.
TextView
Este control es uno de los más usados y más sencillos de utilizar, ya que su única función es la mostrar texto en pantalla. Sus parámetros principales son:
android:text; Permite establecer un texto determinado, el cual se mostrará en pantalla.
android:background; Permite establecer el color de fondo del textview.
android:textColor; Permite establecer el color del texto. Deben especificarse en hexadecimal.
android:textSize; Permite establecer el tamaño del texto. Se recomienda utilizar la unidad de medida sp.
android:textface; Permite establecer el estilo del texto; negrita (bold) o cursiva (italic).
La manera de añadir texto a un textview mediante código es con el método setText().
EditText
Este control es la típica caja de texto que se emplea para la introducción de datos por teclado. Para la captura de dichos datos se utiliza el método getText(), mientras que para establecer texto puede utilizarse el método setText(). Podemos destacar dos parámetros de EditText; android:text, que es el parametro de diseño que permite establecer texto (aunque no suele utilizarse mucho) y android:hint, que sirve para establecer un texto semitransparente dentro de la caja de texto que desaparece cuando se hace clic con el ratón dentro de ella.
CheckBox
Los checkboxes son casillas que se pueden marcar o desmarcar y que se utilizan para indicar que se ha seleccionado o deseleccionado una opción. Por lo tanto un checkbox tiene dos estados; true cuando está marcado y false cuando no lo está. Para saber el estado en que se encuentra un checkbox se utiliza el método booleano isChecked(). Con el método setChecked(boolean) se puede establecer cualquiera de los dos estados mediante código.
El evento más importante de un checkbox es onCheckedChanged(Compound checkview, boolean isChecked), y permite capturar el momento en que éste cambia de estado. Compound checkview hace referencia al checkbox en sí.
RadioButton
Los RadioButton tienen un funcionamiento similar a los checkboxes, sin embargo su principal diferencia es que se agrupan en los llamados RadioGroups y que en un mismo grupo sólo puede haber un RadioButton seleccionado. El resto se desmarcan automáticamente. Con el parámetro android:text podemos asignar texto a cada uno de los RadioButtons.
El evento más importante de un RadioButton es onCheckedChanged(RadioGroup group, int checkedId), y permite capturar el momento en que se produce un cambio de selección en un RadioGroup. Este tipo de control básico tiene varios métodos que se pueden usar en la parte del código, como por ejemplo clearCheck(), que establece que no haya ningún RadioButton seleccionado por defecto.
Button
Este control es un simple botón. Su evento más importante es onClick(View v) el cual se ejecuta cuando se pulsa sobre el botón.
ToggleButton
Este control es igual de simple que Button. La diferencia es que este control tiene dos estados posibles, encendido y apagado, por lo que funciona como si fuera un interruptor. Al igual que Button, tiene el método onClick(View v) para capturar el evento de pulsación sobre él. Para saber en qué estado se encuentra el ToggleButton se utiliza el método booleano isChecked().
ImageButton
Tiene la misma funcionalidad que Button. La diferencia respecto a éste es que se le puede asignar una imagen cubriendo la superficie del ImageButton. Para ello es necesario utilizar el parámetro android:src en el área de diseño. Para inciar un recurso de imagen se suele utilizar la ruta /res/drawable, donde hay almacenadas imagenes predefinidas de Android.
ImageView
Este control no es más que una imagen establecida en una view. No tiene funcionalidad ninguna, salvo que dicho control se relacione con otro y en cuanto se capture un evento concreto se quiera cambiar la imagen del ImageView. Para establecer la imagen se utiliza el parámetro android:src en el área de diseño.
3. SUMMAY
The basic Android controls allow us to design simple applications quickly. This group of basic controls is made up of TextView, EditText, CheckBox, RadioButton, Button, ToggleButton, ImageButton and ImageView. Then we will describe them briefly and we will comment on the most important main parameters of each one.
TextView
This control is one of the most used and simplest to use, since its only function is to display text on the screen. Its main parameters are:
android: text; It allows to establish a certain text, which will be displayed on the screen.
android: background; Allows you to set the background color of the textview.
android: textColor; Allows you to set the color of the text. They must be specified in hexadecimal.
android: textSize; Allows you to set the text size. It is recommended to use the unit of measure sp.
android: textface; It allows to establish the style of the text; bold (bold) or cursive (italic).
The way to add text to a textview using code is with the setText () method.
EditText
This control is the typical text box used to enter data by keyboard. To capture such data, the getText () method is used, while the setText () method can be used to set text. We can highlight two EditText parameters; android: text, which is the design parameter that allows you to set text (although it is not often used much) and android: hint, which is used to set a semi-transparent text inside the text box that disappears when you click with the mouse inside she.
Check box
Checkboxes are boxes that can be marked or unchecked and used to indicate that an option has been selected or deselected. Therefore a checkbox has two states; true when marked and false when it is not. To know the state in which a checkbox is found, the Boolean method isChecked () is used. With the setChecked (boolean) method, you can set any of the two states using code.
The most important event of a checkbox is onCheckedChanged (Compound checkview, boolean isChecked), and allows you to capture the moment it changes state. Compound checkview refers to the checkbox itself.
RadioButton
The RadioButtons have a similar operation to the checkboxes, however their main difference is that they are grouped in the so-called RadioGroups and that in the same group there can only be one RadioButton selected. The rest are automatically unmarked. With the android: text parameter we can assign text to each of the RadioButtons.
The most important event of a RadioButton is onCheckedChanged (RadioGroup group, int checkedId), and it allows to capture the moment in which a selection change occurs in a RadioGroup. This type of basic control has several methods that can be used in the code part, such as clearCheck (), which states that there is no RadioButton selected by default.
Button
This control is a simple button. Its most important event is onClick (View v) which is executed when you click on the button.
ToggleButton
This control is just as simple as Button. The difference is that this control has two possible states, on and off, so it works as if it were a switch. Like Button, it has the onClick method (View v) to capture the click event on it. To find out what state the ToggleButton is in, the Boolean method isChecked () is used.
ImageButton
It has the same functionality as Button. The difference with this is that you can assign an image covering the surface of the ImageButton. For this it is necessary to use the android: src parameter in the design area. To start an image resource, the path / res / drawable is usually used, where there are stored predefined images of Android.
ImageView
This control is nothing more than an image set in a view. It does not have any functionality, unless that control is related to another and as soon as a specific event is captured, you want to change the ImageView image. To set the image, the android: src parameter is used in the design.
4. RECOMENDACIONES- Poner mucha atención en este contenido porque los Controles como Edith Text, Button, TextView es la base primordial para desarrollar aplicaciones móviles en Android Studio.
- Tener cuidado al momento de utilizar los controles y seguir detalladamente la sintaxis en los ejemplos planteados.
- Poseer una investigación más insondable sobre Controles básicos de Android Studio debido a que existe más controles que son esenciales y útiles al momento de desarrollar una App.
- Para los novatos en desarrollo de aplicaciones Móviles en Android Studio se recomienda buscar prototipos y conocer tendidamente en qué casos se utilizar estos controles.
5. CONCLUSIONES
- Los controles básicos nos permiten diseñar aplicaciones simples de manera rápida.
- Todos los controles básicos mencionados son esenciales y de suma importancia para el diseño de una aplicación Móvil.
- Los controles de entrada son los componentes interactivos de la interfaz de usuario de tu app. Android ofrece una gran variedad de controles que puedes usar en tu IU.
- Los controles nos permiten facilitar el proceso de diseñado al programador y da una mejor vista a los usuarios finales.
6. APRECIACIÓN DEL EQUIPO
Para nosotros fue muy esencial aprender sobre los controles
básico de Android Studio controles como EdiText, Button, TextView conocer de
estos controles básicos son indispensables debido que es la base fundamental para
el diseño y desarrollo de una aplicación Móvil.
Al mismo tiempo también hicimos una investigación más
detallada sobre cada control complementando con prototipos e innovando más
sobre otros controles que se utilizan en el diseño de una app como CheckBox, RadioButton,
ToggleButton, ImageButton y ImageView en realidad existe más controles, pero
estas son las más utilizadas.
Los controles nos permiten diseñar aplicaciones simples de manera rápida
ayudando no solo al desarrollador sino también a los usuarios finales. Existe
algunos controles que pueden ser sustituidos por otros eso depende de cada
desarrollador, pero tengamos en cuenta que los controles básicos (EdiText, Button,
TextView) no deben faltar en una aplicación debido a su importancia y la función
indisoluble que cumplen.
Tuvimos muchas interrogantes al momento de desarrollar este blogger, pero
según el avance y la complejitud de nuestra investigación lo resolvimos
satisfactoriamente, los ejemplos nos ayudaron a estandarizar nuestras dudas y
toda la teoría desarrollada en este block lo llevamos a la práctica utilizando
Android Studio es ahí donde aprendimos la verdadera importancia de los
controles básicos.
7. GLOSARIO DE TÉRMINOSVIEW
El objeto más importante cuando estamos montando una interfaz gráfica. De él extenderán la mayoría de componentes que utilicemos. Básicamente consiste en un área de la pantalla que admitirá determinadas funcionalidades
WIDGET
Elemento que puede añadirse al escritorio de nuestro dispositivo Android, ofreciéndonos información y determinadas funcionalidades (según lo que el desarrollador lleve a cabo).
WIPE
Su traducción es Barrido. Básicamente se trata de un formateo o borrado general de todos los datos de tu teléfono con el fin de dejarlo tal y como estaba nada más sacarlo de la caja.
Atención: un wipe no te borra el contenido de la SD pero si que te borra las aplicaciones instaladas.
XDA
XDA-developers es una comunidad de desarrolladores de software para dispositivos móviles de más de 4 millones de usuarios de todo el mundo creada en 2003.
TETHERING
Se denomina anclaje a red o tethering al proceso por el cual un dispositivo móvil con conexión a Internet actúa como pasarela para ofrecer acceso inalámbrico a la red a otros dispositivos, cualesquiera que estos sean, asumiendo dicho dispositivo móvil un papel similar al de un módem o enrutador
HSPA
Acceso de Paquete de Alta Velocidad es una tecnología para teléfonos móviles que mejora la velocidad a la que usted puede enviar y recibir información en su dispositivo móvil. La tecnología HSPA se utiliza en redes 3G.
GPRS
General Packet Radio Service o servicio general de paquetes vía radio creado en la década de los 80 es una extensión del Sistema Global para Comunicaciones Móviles para la transmisión de datos mediante conmutación de paquetes
CYANOGEN
Es el nombre de un sistema operativo de código abierto para dispositivos móviles basados en Android.
ANDROID:TEXTCOLOR
Permite establecer el color del texto. Deben especificarse en hexadecimal.
ANDROID:TEXTSIZE
Permite establecer el tamaño del texto. Se recomienda utilizar la unidad de medida sp.
ANDROID:TEXTFACE
Permite establecer el estilo del texto; negrita (bold) o cursiva (italic).
La manera de añadir texto a un textview mediante código es con el método setText().
Comentarios
Publicar un comentario