-
Notifications
You must be signed in to change notification settings - Fork 0
/
Android - Conceptos fundamentales - Udemy Business.txt
277 lines (171 loc) · 19.6 KB
/
Android - Conceptos fundamentales - Udemy Business.txt
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
Activity = Pantalla en Android
Package Name = Forma en la que Google reconoce e identifica a una aplicación en la playstore
El formato del package name es: com.{nombre_compañia}.{nombre_proyecto}
SDK = Kit de desarrollo de software.
Minimum SDK = La versión minima de Android en la que se podrá correr nuestra aplicación
De acuerdo a la versión que escojamos vamos a soportar una porción mayor o menor de dispositivos Android en el mercado. Logicamente el trade off acá es que mientras mas antigua la versión mayor soporte de dispositivos pero menor cantidad de capacidades para nuestra app.
Para comenzar a crear una app desde cero con Android Studio es tan simple como:
1- Abrirlo y seleccionar new project
2- Elegir el template apropiado a la app que vamos a construir. Si ninguno sirve elegimos el "empty activity" para arrancar desde cero.
3- Ponemos nombre al proyecto y al paquete (como se verá en la marketplace), elegimos el minimum SDK y creamos.
4- Listo tenemos nuestra maqueta de aplicación vacia lista para comenzar a llenarla.
5- Desde el SDK Manager vamos a realizar algunas configuraciones antes de arrancar. Chequear que el ultimo "Android SDK" (sección SDK Platforms) lo tengamos "Installed" y sino hacerlo seleccionando los ultimos (o los que nos interesen) y luego presionando "apply"
6- Luego vamos a la sección "SDK Tools" e instalamos: Android SDK Build-Tools, Android Emulator, Android SDK Platform-Tools, Android SDK Tools (para Marzo 2023 obsoleto) y Intel x86 Emulator Accelerator (HAXM installer)
----------------------------------------------
¿Que vemos con la aplicación creada?
1- A la izquierda todo el directorio completo de nuestro proyecto
2- Abiertos para modificar o solo leer dos archivos: el MainActiviy.kt que es el archivo donde vamos a programar toda la logica de nuestra aplicación y el activity_main.xml que es donde vamos a encontrar como se va a ver nuestra pantalla.
3- Partes del directorio importantes al arrancar: carpeta "java" que es donde estará nuestro codigo y carpeta "res" que es donde estarán nuestros recursos. Por ejemplo nuestras pantallas estarán dentro de la sub carpeta "layout" de la carpeta "res", allí es donde se aloja el file activity_main.xml que mencioné en el punto 2
----------------------------------------------
¿Como creamos un emulador de celular android donde probar nuestras aplicaciones?
1- Buscamos en el menu del proyecto abierto el logo del AVD Manager (Android Virtual Device Manager) y lo seleccionamos. Ahora se llama solo "Device Manager" y tiene dentro una division entre "Virtual" o "Physical"
2. Dentro del "DM" voy a seleccionar la opción de "Create Device" y allí puedo simular un "phone", "tv" "wear OS", "tablet" y "automotive"
3- Escojo la category y el nombre del dispositivo que deseo simular. Ejemplo Pixel 2
4- Luego decido que System Image (SI) de Android quiero que tenga ese dispositivo. Si no lo tengo debo instalarlo desde la misma pantalla. Ejemplo: Android 11 R (El que tengo en mi Xiaomi 9T Pro) o el Android 9 Pie que fue muy popular y es el que voy a estar usando en esta ocasión.
5- En la siguiente pantalla puedo decidir si al comenzar el emulador va a comenzar de forma vertical u horizontal.
6- Le doy finish y eso me va a generar mi primer emulador. Puedo crear todos los que desee para testear mi app en distintos devices pero teniendo en cuenta que cada emulador pesa demasiado, por lo que si puedo trabajar con 1 solo mejor aún.
7- Dandole "Play" desde el "DM" vamos a encender el device creado. Tmb se puede dar play dsd el manu principal seleccionando el device en el desplegable y luego presionando el boton de "run app" (logo de Play tradicional) que se ubica a su derecha.
----------------------------------------------
¿Como emulamos nuestro programa en un dispositivo real?
1- En nuestro device simulado vamos a configuraciones (ruedita en opciones) y allí buscamos "acerca del teléfono" que en el emulador es "acerca del dispositivo emulado"
2- una vez aquí debemos buscar "número de compilación" (En Xiaomi se llama "Versión MIUI" y está en "Acerca del telefono")y empezar a darle click y nos va a aparecer un tipo contador que dice que estamos a "3, 2, 1, un paso de ser programador" y "ya eres programador".
3- Una vez vimos ese mensaje... Vamos para atras y dentro de "Sistema" presionamos sobre "Avanzado" donde vamos a encontrar una nueva opción que dice "Opciones para programadores", presionamos... (En Xiaomi debería estar debajo de "Acerca del telefono" o en su defecto lo buscamos con la lupita y lo encontraremos.)
4- Allí debemos garantizar que estén activadas las siguientes opciones: El "Activado", "Permanecer Activo", "Depuración por USB" o "Wireless debugging" (Es la que nos va a permitir que la computadora nos identifique el celular que acabamos de configurar). Clave tener también activado el permiso "Instalar vía USB" mas allá de que el emparejamiento sea Wi Fi para que Android Studio pueda instalar la .apk en nuestro device.
5- Activado todo lo anterior (fundamentalmente la opcion de "Depuración por USB") ya vamos a encontrar en "Logcat" (Una de las opcinoes del panel inferior de Android Studio la posibilidad de cambiar de dispositivos, incluyendo a los celulares reales).
6- Vamos entonces al DM, alli ponemos incorporar un nuevo device, esta vez "physical" y seguimos en el celular fisico la siguiente ruta: Developer Options -> Wireless debugging -> Pair using QR code -> Escaneamos el QR de Android Studio y lo tendremos cargado para probar app en un dispositivo real Android mientras estén unidas a la misma red wifi. Para ello debemos apretar el boton de "run app" señalando al device fisico apareado.
----------------------------------------------
Importante: Para armar los repos de un proyecto Android con Kotlin debemos arrancarlos desde la carpeta padre que es la que lleva el nombre del proyecto. En este caso "Hello World". Dentro de ella va a estar la carpeta "app" que es la que nos muestra android studio y el archivo .gitignore por ejemplo.
------------------------------------------------
En Android Studio / Kotlin cada "Activity" (pantalla) de nuestra app va a tener dos archivos:
1- Un {MainActivity}.kt --> File Kotlin que tiene nuestra logica del programa
2- Un {activity_mian}.xml --> File Xml que tiene el contenido de nuestro programa.
Todo lo que vemos en una pantalla de Android se lo conoce como "views":
1- Image views -> Las imagenes
2- Text views -> Los textos en pantalla
El archivo de nuestras views es el file .xml, que al abrirlo lo veremos como una imagen de nuestra pantalla. Y no veremos el codigo ni lo podremos editar salvo que toquemos en "Split" sobre el margen superior derecho de la pantalla.
Podemos editar el diseño a traves del codigo (buena práctica) o si lo preferimos a traves de su interface visual (Buenisima posibilidad que brinda Android Studio pero no Intellij IDEA por ejemplo)
Por ejemplo dentro de la etiqueta <TextView... vamos a encontrar el valor android:text("lalala") -> Allí es donde debemos poner el texto que vemos en nuestra aplicación. Dentro de <TextView... vamos a encontrar muchas otras etiquetas del tipo android:{atributo} que nos permitirán dejar el diseño como nosotros deseamos. Por ejemplo:
android:textSize="24sp"...
Desde aquí se hace todo el diseño. Podemos armar el texto del cuerpo de la app (la sugerencia de que va por ejemplo se llama "android:hint") en la sección <EditText...
Podemos armar botones de nuestras pantallas con la etiqueta <Button...
(Ver para entender mas detalles del diseño de nuestra "Activity" el file "activity_main.xml")
---------------------------------------------
Cuando desarrollamos aplicaciones Android en Android Studio... Los archivos .xml reemplazan a los archivos HTML y CSS del diseño web tradicional. ¿Es una afirmación verdadera o falsa a tu criterio?
En cierto modo, la afirmación es verdadera, ya que en el desarrollo de aplicaciones Android en Android Studio, los archivos .xml se utilizan para definir la estructura y el diseño de la interfaz de usuario, de manera similar a cómo se utilizan HTML y CSS en el diseño web tradicional.
Sin embargo, hay algunas diferencias significativas entre los archivos .xml y HTML/CSS. En Android, los archivos .xml se utilizan principalmente para definir la jerarquía de vistas y widgets que se utilizarán en la interfaz de usuario, mientras que en HTML se utilizan etiquetas para definir la estructura y el contenido de una página web.
Además, mientras que CSS se utiliza para aplicar estilos y diseños a elementos específicos de una página web, en Android Studio, se utilizan archivos .xml separados para definir los estilos y diseños de la interfaz de usuario.
En resumen, aunque hay similitudes entre el uso de archivos .xml en Android Studio y HTML/CSS en el diseño web, cada plataforma tiene sus propias convenciones y diferencias significativas en cuanto a su uso.
--------------------------------------------
LinearLayout (Segunda etiqueta del proyecto solo por debajo de la etiqueta principal <?xml ...) con android:orientation="vertical" de .xml (para Android Studio) sería el equivalente a una ordenación del "display: block" en CSS para desarrollo web desktop.
match_parent: Ocupa todo el espacio disponible del ancho o el largo nuestra Activity. wrap_content ajusta el ancho o largo a lo ocupado por el contenido. Sino también podemos setear el espacio en pixeles dependientes (del tamaño del dispositivo) que se plantean como por ej: android:layout_width="2000dp"
En internet se puede buscar por ejemplo, ¿Que tipo de View en Android Studio se puede usar para un boton de confirmación?
Los margins & padding se pueden manipular de forma conjunta o de forma separada igual que en CSS.
16dp depending pixels es como un valor de espaciamiento por default en Android.
Todas las labels que comienzan con android:{type} se van a visualizar en la app productiva. Si quiero testear en modo desarrollo como se visualiza algo puedo hacerlo usando alguna tools:{type}. En el caso por ejemplo de la respuesta que da la app sobre la edad que tendrías como perro sería tools:text="Tu edad canina es de 120 años"
-------------------------------------------
Para desarrollar la logica de "Mi edad canina" debemos identificar cada "view" en mi XML con un "id" para luego poder escuchar los eventos que ocurren sobre el desde nuestro archivo kotlin y manejar nuestra aplicación como deseemos.
Metodo onCreate de MainActivity:
En este método se ejecuta automáticamente cuando esta activity se crea, es decir, cuando abrimos la
aplicación, se crea esta pantalla y automáticamente se ejecuta.
Este metodo lo que hace es que establece que determinado layout (en este caso "activity_main") es el que va a pertenecer a esta Activity y por lo tanto el que va a mostarnos en pantalla de nuestro device Android
-------------------------------------------
Uso de los "Log":
1- Puedo visualizarlos en el logcat
2- Debo crearlos usando el objeto "Log" con el metodo que corresponda "d" de debug, etc.
3- Sirve para ir siguiente por logcat los eventos que ocurren en nuestro programa y detectar posibles errores.
4- Usos de cada categoria (metodos de Log):
"debug" y "verbose": Para transmitir información o comentarios de actividad
"info" y "warm": Para transmitir alertas que pueden llegar a romper nuestra app
"error": Para transmitir errores que rompen nuestra app
5- Se llaman como Log.v, Log.d, Log.i, Log.w, Log.e
------------------------------------------
Una opción para mostrarles mensajes por pantalla al usuario frente a un error son los "Toast":
Ej:
Toast.makeText(this, "Debes insertar tu edad",Toast.LENGTH_SHORT).show()
Argumentos de un Toast:
Contexto: A que Activity hacen referencia -> Poniendo this (sin comillas) hacemos que refieran a la activity en la cual estamos escribiendo el codigo. Por ej: MainActivity
Texto: El mensaje a mostrar
Duración: Solo 2 opciones: LENGTH_SHORT o LENGTH_LONG
-----------------------------------------
Buenas practicas con Strings:
1- Debemos guardar todas las Strings en ../res/values/strings.xml para luego invocarlas en activity_main.xml como hicimos con las imagenes. Es decir, dentro del valor de android.text="@string/{nombre_string_guardado}"
2- De esta forma evitamos el "hardcodeo" de variables que es considerado una mala practica.
3- Los Log´s y las tools no son necesarios guardar como strings en strings.xml. Solo los strings que le vamos a mostrar al usuario.
-----------------------------------------
Podemos hacer que Android Studio no interprete como errores el Español sin instalar un diccionario.
1- Boton derecho sobre carpeta "res"
2- New -> Android Resource Directory
3- Directory name = "values-es" para español o "values-pt" para portugués.
4- Presionamos "Ok". Parece que nada ha cambiado pero...
5- Con el boton derecho sobre "res" buscamos "Open in" -> "Explorer" para ver que se creo la carpeta "values-es".
6- Luego con click derecho en "values" creamos un "new" -> "Values Resource File"
7- Le ponemos de nombre "string.xml" y en directory name ponemos "values-es"
8- Ya nos muestra la sección de Project una carpeta "strings" dentro de "values" y dentro de ella dos archivos llamados igualmente como "strings.xml"
9- Al tener dos archivos de strings, dependiendo de que idioma tengamos configurado en el celular nos no lo va a mostrar en español o en ingles.
10- Si cambiamos de idioma también va a cambiar lo que nos muestra el celular.
----------------------------------------
findViewById nos sirve para el objetivo de linkear una view con logica Kotlin. Pero sin embargo es un proceso pesado. Que puede enlentecer nuestra aplicación si la misma es muy grande. Para estos casos existe otra forma de hacerlo que se llama "Data Binding". ¿Por que?
1- findViewById carga las views en la logica Kotlin en tiempo de ejecución. Es decir, con el programa en marcha.
2- dataBinding carga las views en tiempo de compilación. Es decir, antes de comenzar a ejecutar nuestro programa.
El data binding es algo nuevo de Android. Por lo que muchas aplicaciones aún están utilizando el findViewByID.
Por eso es importante conocer ambos.
¿Que es Gradle? Es el mecanismo que utiliza Android para compilar nuestro codigo y llevarlo a un lenguaje que el celular pueda entender.
1- Buscamos la carpeta "Gradle Scripts" que está por fuera de "app".
2- Dentro de ella buscamos "build.gradle (Module:app)" y lo abrimos.
3- Y en dicho archivo vamos a agregar:
. Debajo del ultimo aplly: apply plugin: 'kotlin-kapt'
. Dentro de android {} y debajo de buildTypes {}:
dataBinding {
enabled = true
}
4- Nos va a pedir autorizacion para sincronizar dataBinding con el proyecto. Lo cual tenemos que aprobar.
5- Vamos a nuestro layout, activity_main.xml, y reemplazamos el "LinealLayout..." por un data binding layout ayudandonos con las sugerencias (Alt+Enter) de Android Studio.
6- Nos encierra todo el xml dentro de <layout... y nos crea una sección de <data... por el momento vacia. Todo lo que hicimos lo encierra en una segunda sección de igual jerarquia que <data... llamada <LinearLayout...
7- Al realizar esto pasos se genero un archivo que se llama "activityMainBinding". El mismo vamos a tener que usarlo ahora dentro de "MainActivity.kt"
Así:
// Sumo el data binding que incorporé previamente en build.gradle:
val binding = ActivityMainBinding.inflate(layoutInflater) // Inflar en Android: Formar un layout en memoria.
setContentView(binding.root)
// Variables para escuchar los eventos en el layout creadas mediante binding:
val ageEdit = binding.ageEdit // linkeo mi variable con una view del XML
val resultText = binding.resultText
val button = binding.button
Hay dos formas de añadir DataBinding al archivo build.gradle:
dataBinding {
enabled = true
}
Pero recientemente Android sacó en su documentación una nueva forma:
buildFeatures {
dataBinding true
}
Ambas formas funcionan correctamente y no debería haber problemas por usar una o la otra, pero es bueno que lo sepas por si te topas con cualquiera de ellas sepas que son para lo mismo.
--------------------------------------
Cargar icono a nuestra aplicacion.
La carpeta mipmap es la carpeta donde van los iconos de nuestra aplicación.
app -> res -> mipmap -> ic_launcher / ic_launcher_round / ic_launcher_foreground
En ic_launcher vamos a encontrar nuestros iconos cargados. Y digo nuestros porque debemos cargar varias versiones con distintas resoluciones para de esta forma soportar distintos dispositivos.
En ic_launcher_round lo mismo pero los iconos redondeados en distintas resoluciones tambien.
Por default, cualquier proyecto android trae la imagen del robot de android. Pero yo puedo cargar y procesar en distintas resoluciones y formas la imagen que quiera.
1- Boton derecho sobre "mipmap" y selecciono "New" -> "Image Asset"
2- Se abré una sección para cargar la foto que queramos desde "Asset type" y crear multiples versiones.
-------------------------------------
¿Que es el android manifest?
Archivo xml que está ubicado dentro de ../app/manifest y que se llama AndroidManifest.xml
Es un resumen de nuesta app.
Podemos encontrar el nombre, el icono, el icono redondo y también cada una de nuestras activitys.
En este caso, solo tenemos una activity que se llama MainActivity pero la mayoria de las apps tienen mas de una activity. Dentro de la etiqueta de activity en nuestra main nos vamos a encontrar con una etiqueta de <intent-filter... que nos va a indicar que esta activity es la principal o MAIN y es la que se debe ejecutar al iniciar la operacion (LAUNCHER)
Otra cosa fundamental es que los permisos que va a requerir nuestra aplicación los tenemos que declarar aquí en el manifest.
---------------------------------------
Tipos de layout de diseño en Android:
Tenemos 4 tipos:
FrameLayout: Diseñado para mostrar unicamente un "View" a la vez. Si ponemos mas de uno van a tapar a los que estaban primero. (Es el menos utilizado en la industria)
LinearLayout Vertical (Usé en "Mi edad canina"): Al agregar un view se agrega en la parte superior de la pantalla y los proximos que agregamos van abajo del anterior de forma vertical
LinearLayout Horizontal: Lo mismo que el anterior pero se ordenan horizontalmente y si ya no hay espacio van a quedar sesgados.
RelativeLayout: Podemos poner las views que queramos y donde queramos. Nosotros establecemos la ubicación de nuestras Views. Es el mas versatil.
1 activity puede tener 1 o muchos layout. Pero tenemos que tratar de tener la menor cantidad posible. Dado que a mas layout mas recursos consumimos de los devices. Por ejemplo, si tenemos que insertar un LinearLayout Horizontal dentro de una LinearLayout Vertical es preferible armar lo mismo en un RelativeLayout.
Existe un 5 tipo de Layout que es el ConstraintLayout (Nuevo en Android):
Podemos hacer un diseño de forma visual arrastrando los distintos tipos de views que queremos a nuestro layout seleccionando en el margen superior derecho de nuestro archivo "activity_main.xml" la opción de "Design".
En los casos de los 4 primeros layout podemos también hacerlos por diseño, en lugar de por codigo. Pero no es recomendable. En el caso del ConstraintLayout solo se puede hacer por diseño. Ya no por codigo.
Es un tipo de layout mas versatil que el RelativeLayout incluso pero se recomienda usarlo con entre 5 y 10 views. Mas de 10 views debemos ir al relative.
----------------------------------------
Fin de nuestra primera app interactiva llamada "Mi edad canina"