Espera un momento ...
¿Te gustaría llevar mi curso de Laravel, gratis?
Sólo debes ingresar tus datos:
Lo que aprenderás con este curso
- Aprenderás a crear tus propias aplicaciones Android nativas
- Conocerás qué es y como funciona una API
- Trabajarás de forma organizada usando Android Studio
- Mejorarás tus conocimientos de Java y Kotlin
- Conocerás cómo implementar JSON Web Tokens (en Laravel y Android)
Este curso está dedicado a
Personas interesadas en aprender a desarrrollar aplicaciones móviles
Programadores que desean iniciar su camino en el desarrollo de aplicaciones Android nativas
Desarrolladores que desean aprender cómo comunicar un proyecto Laravel con Android a través de una API
Requisitos
Es importante tener muchas ganas de aprender
Se recomienda tener conocimientos básicos de algún lenguaje de programación
Contenido del curso
1 Bienvenida y recomendaciones 02:57
Este es un video introductorio al curso, donde te doy algunas sugerencias para que puedas aprovechar mejor el curso.
2 Mockups (planteamiento inicial) 10:56
Veamos qué secciones va a contener nuestra aplicación, tanto en su versión web como móvil.
+1 recurso asociado a esta clase
3 Laravel: Configuración local 10:00
Empecemos instalando lo necesario, y creando un proyecto Laravel nuevo, con su correspondiente base de datos y VirtualHost.
+2 recursos asociados a esta clase
4 Laravel: Qué versión usar 06:26
Cada vez tenemos versiones Laravel más recientes. Qué versión debemos usar para seguir el curso, y consejos para aprender Laravel.
+2 recursos asociados a esta clase
5 Migraciones y Autenticación 05:35
En esta lección vemos qué son y cómo ejecutar migraciones para alterar nuestro esquema de base de datos. También implementamos nuestro sistema de autenticación.
6 Diseño base para nuestra app web 02:06
Vamos a descargar la plantilla Argon Dashboard, para posteriormente integrar esta plantilla sobre nuestro proyecto Laravel.
+1 recurso asociado a esta clase
7 Vistas, rutas y controladores 07:29
¿Cuál es el flujo que sigue el servidor cuando resuelve una petición?
+1 recurso asociado a esta clase
8 Integrar plantilla Argon (Login) 31:13
Empecemos a integrar sobre nuestro proyecto la plantilla Argon que hemos descargado anteriormente.
9 Formulario de registro y menú superior 08:56
Continuamos integrando la plantilla Argon Dashbord sobre nuestro proyecto.
+1 recurso asociado a esta clase
10 Múltiples directivas yield y section 10:53
En esta lección actualizamos el título, subtítulo y footer de nuestra página.
11 Layout general para las vistas de Panel 14:12
Definamos un layout para que sea usado como base por las vistas correspondientes a nuestro dashboard.
12 Directiva include y menú lateral 15:20
Veamos cómo declarar el menú lateral izquierdo en una vista independiente, y cómo modificar el color e íconos de las opciones.
13 Dropdown menu 20:45
Veamos cómo organizar adecuadamente el menú que se muestra como dropdown. Así mismo inicializamos un repositorio de Git, y terminamos de integrar la plantilla base.
+1 recurso asociado a esta clase
14 Especialidades 28:53
Definamos nuestro primer modelo, migración y controlador; además de configurar las rutas para nuestro CRUD de especialidades. También vemos cómo hacer uso del middleware auth.
15 Validaciones de lado del cliente y servidor 09:11
Veamos cómo validar de lado del cliente y de lado del servidor, haciendo uso de las "validation rules" de Laravel y personalizando los mensajes de error.
16 Verbo PUT (editar especialidades) 13:57
Veamos cómo definir rutas con distintos verbos HTTP y cómo asociar un formulario con uno de estos verbos al realizar una actualización de datos.
17 Verbo DELETE (eliminar especialidades) 07:05
Repasemos las distintas rutas que tenemos creadas, respecto a la gestión de especialidades, e implementemos la eliminación de datos para esta entidad.
18 Flashed Session Data (notificaciones) 10:26
Veamos cómo podemos pasar una variable cuando usamos un redirect. El funcionamiento es distinto a pasar datos directamente sobre una vista.
19 Doctor Resource 17:50
Veamos cómo definir rutas y métodos de controlador de una manera más rápida y abreviada.
20 Seeders, Model factories y Faker 14:27
Veamos cómo poblar nuestra base de datos con datos ficticios, pero que parecen ser reales. Así mismo, como automatizar este proceso, para no detenernos a escribir personalmente tales datos.
21 Query Scopes 10:47
Veamos cómo simplificar nuestras consultas Eloquent definiendo Scopes en nuestros modelos (en este caso dentro de nuestra clase User).
+1 recurso asociado a esta clase
22 Mass assignment y edit 22:31
Anteriormente vimos cómo registrar datos usando el método save. Ahora veamos cómo registrar usando mass assignments (creación basada en arreglos asociativos). Finalmente avanzamos con nuestra vista de edición.
23 Métodos update y destroy 08:33
Veamos cómo actualizar los datos de un médico (opcionalmente también su contraseña), y así mismo, cómo eliminar médicos.
24 Patient Resource 09:55
A modo de repaso, implementemos rápidamente la gestión de pacientes en nuestra aplicación (listado, paginación, registro, edición, y eliminación).
25 Menú por rol 10:49
Nuestro menú constante lo vamos a reemplazar por un menú cuyas opciones dependen del rol del usuario.
También vemos una introducción a la importancia de los Middlewares.
26 Proteger rutas usando Middlewares 07:40
Veamos cómo definir y registrar nuestro propio middleware, haciendo uso de un "grupo de rutas".
27 Organizando controladores en carpetas 04:24
En esta lección ubicamos nuestros controladores en carpetas, para conseguir un mayor orden.
28 Ruta y vista (diseño inicial) 15:32
Empecemos añadiendo un enlace correspondiente en el menú, que lleve a una nueva ruta, resuelta por una vista que empezaremos ya a diseñar.
29 Modelado y lógica para guardar 25:06
En esta lección definimos un modelo y una migración, y empezamos a guardar información con relación al horario. Dependiendo de la situación se actualizan o crean registros nuevos.
+1 recurso asociado a esta clase
30 Repositorio en Github (Proyecto Laravel) 05:35
En esta lección vemos la importancia de usar Git, y cómo crear nuestro repositorio, a fin de publicar nuestros avances en Github.
+2 recursos asociados a esta clase
31 Mostrar horario (Carbon y método map) 15:30
Veamos cómo mostrar los horarios de un médico sobre nuestra vista. De esta manera vamos a poder confirmar también, si el registro ocurre satisfactoriamente o no. Hacemos un cambio de formato en las horas, usando Carbon. Así mismo usamos el método map para actualizar los valores de los elementos de una colección.
+1 recurso asociado a esta clase
32 Consistencia en las horas 15:09
Veamos cómo validar los intervalos de horas, en los horarios de los médicos, sin usar las validation rules de Laravel.
33 Formulario: Registrar cita médica 11:50
Empecemos definiendo una ruta y una vista para el registro de citas, además de añadir el enlace correspondiente en el menú lateral.
34 Relación muchos a muchos 13:39
Veamos cómo definir una relación Many to Many (o muchos a muchos) entre Especialidades y Médicos. Para esto definimos las relaciones entre modelos en las clases correspondientes, y creamos una tabla intermedia.
35 Selección múltiple en un <select> 11:57
Veamos cómo habilitar una selección mútliple sobre una lista desplegable, a fin de poder asociar más de 1 especialidad al mismo médico. Para esto usaremos una biblioteca llamada bootstrap-select.
36 Gestionando relaciones Many to Many 15:42
Veamos cómo podemos definir relaciones entre modelos, cuando el tipo de relación es muchos a muchos. Así mismo, cómo pasar un arreglo PHP a Javascript.
37 Médicos según especialidad 14:56
En esta lección creamos un endpoint (ruta) para que devuelva la lista de médicos (en formato JSON) asociados a una especialidad determinada.
+2 recursos asociados a esta clase
38 Select dinámico y límites al DatePicker 13:32
Veamos cómo cargar la lista de médicos en el select correspondiente, según la especialidad escogida. Por otro lado, veamos cómo limitar las fechas para la reserva de citas (valor mínimo y máximo).
39 Horas de atención por intervalos 30:58
Veamos cómo obtener la lista de intervalos disponibles para atención, para un médico, en un día determinado.
40 Radio Buttons y Alert dinámicamente 22:43
En esta lección mostramos las horas disponibles para atención, y así mismo un alerta, cuando no hay espacios disponibles según el horario del médico.
41 Registro de cita médica (Web) 01:04:32
¡Ánimos! Esta es una de las clases más extensas del curso, pero no te rindas hasta llegar al final. Definimos el método store en nuestro AppointmentController, para registrar citas médicas. Vemos qué son y cómo definir Factory States. Organizamos nuestros Seeders. Trabajamos con el helper old. Revisamos la diferencia entre mostrar data dinámicamente con JS, y mostrar data desde un inicio, inyectando variables sobre la vista.
42 Repaso y Service Providers 40:40
En esta lección vemos cuál es la diferencia entre validaciones de lado del cliente y validaciones de lado del servidor. Vemos qué son y cómo usar servicios y service providers. Finalmente saltamos validaciones de lado del cliente, para demostrar que las validaciones en el backend no se pueden obviar.
+1 recurso asociado a esta clase
43 Bloquear horas según reserva de citas 08:17
Si un paciente reserva una cita para una hora determinada, entonces esa hora no debe estar disponible para otros pacientes. Es lo que implementamos en esta lección.
44 Validación de horas (evitar colisión) 16:18
En la lección anterior vimos cómo detectar qué horas estaban ocupadas, a fin de no listarlas al momento de registrar una cita. ¿Pero qué ocurre si más de 1 paciente está registrando una cita y ambos seleccionan el mismo intervalo? Veamos cómo validar adecuadamente de lado del servidor.
45 Campo status y relaciones entre modelos 24:54
En esta lección vemos cómo añadir columnas nuevas a través de migraciones (sin perder la data que ya se tiene). Vemos cómo establecer relaciones entre modelos (en este caso con relación a Appointment). Y también definimos una vista para listar las citas de un paciente determinado.
46 Lógica para los estados y siguientes pasos 16:36
¿Cuáles son los estados de una cita y qué es lo que ocurre al cambiar de un estado a otro? Revisemos de forma general la situación de nuestro proyecto, para definir lo próximo a desarrollar.
47 Citas organizadas en tabs 19:45
Veamos cómo organizar las citas según su estado, usando un elemento de Bootstrap 4. También cómo separar las tablas en vistas independientes.
48 Cancelación de citas médicas 33:41
En esta lección implementamos la cancelación de citas, tanto para citas que recientemente fueron registradas, como para aquellas que ya habían sido confirmadas por un médico o administrador. En este último caso, se deberá indicar el motivo de la cancelación.
49 Detalles de cancelación 19:47
En esta lección vemos cómo mostrar condicionalmente los detalles de una cita cancelada. También vemos cómo renombrar una columna a través de una nueva migración, sin perder nuestros datos ya registrados.
50 Login como página de inicio 03:32
En esta lección vemos cómo redirigir al login desde nuestra ruta principal. También empezamos a analizar cómo se mostrarán las citas a los médicos, a diferencia de los pacientes.
51 Consultas según el rol de usuario 17:31
Veamos cómo listar las citas para los médicos, a diferencia de los pacientes. Así mismo, cómo podemos usar íconos en vez de texto para los botones, y añadir unos tooltips.
52 Include según el rol de usuario 05:33
Veamos cómo separar las opciones del menú, según cada rol, en vistas independientes.
53 Detalles de citas para el rol administrador 09:47
Veamos cómo mostrar los detalles de citas médicas al administrador, sin afectar lo que ya tenemos definido para médicos y pacientes. También movemos las vistas de nuestras tablas a una carpeta para conseguir un mayor orden.
54 Confirmar cita 15:35
En esta lección implementamos el botón Confirmar cita, y actualizamos textos y botones en función al rol de usuario.
55 Introducción a los reportes gráficos 09:10
Veamos brevemente qué alternativas tenemos, y algunas sugerencias a tener en cuenta cuando trabajamos con bibliotecas JS.
56 Highcharts line (gráfico de líneas) 26:25
En esta lección incluimos un primer reporte gráfico sobre nuestra app web. Comentamos qué alternativas tenemos para enviar datos al gráfico, y optamos por una de ellas, usando la directiva @json (que ofrece Blade).
57 Highcharts column (gráfico de barras) 41:05
En esta lección agregamos un reporte gráfico más, basado en columnas. Revisamos cómo es que podemos generar un JSON con un formato determinado a partir de arreglos en PHP (basados en índices, y asociativos).
58 Seeder de Appointments 19:17
En esta lección vemos cómo poblar nuestra tabla de citas médicas, de manera automatizada, usando Faker para generar datos aleatorios.
59 Formato adecuado para la respuesta JSON 11:59
Veamos cómo dar formato a la respuesta JSON que devuelve el servidor, para que se pueda usar directamente sobre nuestro gráfico de barras (usando Javascript).
60 Filtro: Actualizar según rango de fechas 27:37
En esta lección vemos cómo solicitar datos al servidor en función a un rango de fechas, y cómo actualizar la gráfica de Highcharts acorde a ello (sin la necesidad de recargar toda la página).
61 Instalar Android Studio 02:45
Veamos brevemente como iniciar con la descarga e instalación de Android Studio.
62 Creando un proyecto nuevo 09:45
Consideraciones a tener en cuenta al momento de crear un proyecto Android nuevo.
63 Estructura de carpetas 04:44
Veamos cómo se organizan las carpetas y qué contienen, en un proyecto Android nuevo.
64 AVD Manager 06:05
Veamos cómo crear e iniciar un primer dispositivo virtual, a fin de ejecutar allí nuestro proyecto.
65 Diseñando una primera vista 31:52
En esta lección vemos los conceptos más básicos acerca de las vistas y layouts en Android. Diferencia entre View y ViewGroup. Añadimos elementos y atributos en nuestro XML, para definir un primer diseño, para nuestro Activity de Login.
66 RegisterActivity y fondo gradiente 21:19
En esta lección modificamos el diseño de nuestra vista de Login, añadiendo un recurso drawable que es usado como fondo. También definimos un activity para el registro, y vemos cómo podemos iniciar un activity a partir de otro.
67 Diseño de MenuActivity 19:10
En esta lección añadimos un activity representando al menú de nuestra aplicación. Vemos cómo cargar íconos a nuestro proyecto, cómo definir estilos xml (con atributos en común), cómo modificar el nombre de nuestra aplicación, la importancia del package name, y atajos de teclado útiles en Android Studio.
68 Diseño de CreateAppointment 15:46
En esta lección empezamos estableciendo un diseño base para nuestro CreateAppointActivity. Incluimos un CardView, un Spinner, definimos un RadioGroup y sus correspondientes RadioButtons, y analizamos los pasos a seguir en la interfaz para la creación de una cita médica.
69 Pasos en el registro de Citas 14:22
En esta lección añadimos un CardView por cada paso en el registro de citas, y vemos cómo alternar entre ellos (es decir, cómo modificar la visibilidad de elementos desde programación). También vemos cómo agregar un Scroll (importante cuando la lista de elementos crece mucho).
70 Cómo poblar un Spinner (asignar opciones) 07:30
Veamos cómo poblar un Spinner, asignando opciones a través de un Adapter. De momento las opciones son constantes, pero posteriormente se reemplazará con información obtenida del servidor.
71 Introducción a Kotlin 10:20
Veamos una breve introducción a Kotlin como lenguaje de programación: cómo surge, quién lo desarrolla, y las ventajas que ofrece.
72 Primer proyecto Kotlin 14:37
¿Qué tal si empezamos viendo las diferencias entre Java y Kotlin a través de un programa de "Hola mundo"?
73 Data Classes 26:39
¿Cómo comparamos 2 objetos en Java y cómo convertimos objetos en cadena? Podemos definir métodos para ello. Veamos cómo hacerlo. Y veamos cómo es automático ello en Kotlin.
74 Operators 18:29
Veamos cómo podemos usar operadores básicos en Kotlin, y luego cómo podemos definir nuestros propios operadores; por ejemplo, de incremento/decremento y de comparación, entre objetos. También vemos brevemente qué son las extension functions, que es el tema de la lección siguiente.
75 Extension Functions & Properties 11:32
Veamos qué son y cómo definir Extension Functions y Extension Properties, a través de ejemplos.
76 Infix functions 02:55
Cuando una función tiene un único parámetro podemos declarar esta función como una infix function, y entonces se podrá llamar usando una notación infija.
77 Getters & Setters 12:15
Veamos cómo definir nuestros propios getters y setters para los atributos de una clase.
78 Expression, Statement & Block 05:13
Veamos cuáles son la diferencias entre una expresión, una sentencia y un bloque de código.
79 If (como statement y como expression) 10:48
Veamos ejemplos de las distintas maneras de usar la condición IF en Kotlin.
80 When 10:26
En esta lección vemos cómo hacer uso de When en Kotlin. El bloque When se considera como una versión avanzada de lo que es Switch en Java.
81 Null safety 14:42
En esta lección vemos cómo funciona la seguridad ante nulos de Kotlin.
82 When - Parte 2 07:52
En esta lección vemos un poco más acerca de las distintas formas en que podemos usar when.
83 For, Ranges & forEach 12:44
Veamos ejemplos de cómo usar un bucle for, en conjunto con rangos de valores (y sus correspondientes índices). También vemos cómo usar forEach a partir de un Array.
84 Functional Programming 25:22
Veamos una comparación entre la clásica programación imperativa y el paradigma de la programación funcional, además de algunos ejemplos de cómo usar Functional Programming en Kotlin.
85 DatePickerDialog 14:39
Veamos cómo mostrar un DatePickerDialog para permitir a un usuario seleccionar una fecha, cuando haga clic sobre un EditText.
86 Animate layout changes 02:10
Veamos cómo podemos animar cambios en un layout agregando únicamente un atributo, sin código adicional.
87 Agregar RadioButtons dinámicamente 05:07
Veamos cómo agregar RadioButtons dinámicamente (desde código) sobre un RadioGroup.
88 Múltiples RadioButtons y cómo eliminarlos 02:56
Continuando lo visto en la lección anterior, ahora procedemos a mostrar varios RadioButtons dinámicamente, y también vemos cómo eliminarlos, para evitar que se acumulen.
89 RadioButtons en columnas 17:43
En esta lección vemos cómo mostrar programáticamente RadioButtons en 2 columnas (usando 2 LinearLayout con orientación vertical para lograr separar estos 2 grupos). Vemos una limitación que presentan los RadioGroups y optamos por escribir una solución a medida.
90 Fecha: formato, valor mínimo y máximo 14:02
Veamos cómo validar la fecha ingresada a través del DatePickerDialog. Así mismo, cómo agregar un 0 adelante del día o mes, si éstos se corresponden con 1 sólo dígito. Esto último lo logramos definiendo una extension function (que por cierto es declarada de manera muy concisa).
91 RecyclerView 13:44
¿Qué es un RecyclerView? Carguemos esta dependencia a nuestro proyecto y añadamos un primer RecyclerView sobre un nuevo Activity, que usaremos para listar citas médicas.
92 Item View XML & DataSet 22:18
En esta lección diseñamos una primera versión de nuestro item view, para representar a cada elemento que estará presente en nuestro RecyclerView. También definimos un DataSet con datos constantes, que nos será útil para poblar nuestro RecyclerView.
93 ViewHolder (Create & Bind) 09:33
En esta lección definimos nuestra clase ViewHolder, y vemos cómo asociar datos a cada uno de los item view que va a contener nuestro RecyclerView (definiendo los métodos respectivos al interior del Adapter).
+1 recurso asociado a esta clase
94 With, y otros detalles 12:07
En esta lección refactorizamos un poco el código de nuestro Adapter, definimos String resources, y así mismo hacemos algunos cambios sobre el diseño.
95 Back button 07:59
Veamos cómo agregar fácilmente un botón de retroceso en la parte superior de nuestras pantallas, para volver a la anterior. No es necesario agregar un botón explícitamente en la UI.
96 Finalizar un Activity tras iniciar otro 01:58
En esta lección vemos cómo cerrar nuestro Activity actual, tras iniciar un nuevo Activity.
97 Cómo tener una única instancia (Activity) 05:51
Veamos cómo modificar el Launch Mode de nuestros activities de Registro y Login, para evitar que se creen muchas instancias, y en cambio usemos las que ya existan.
98 Persistencia de datos para el Login 06:51
Veamos cómo funciona la persistencia de datos en Android, y cómo vamos a implementar un inicio de sesión en nuestra aplicación.
99 Shared Preferences, tal como son 10:56
Veamos cómo usar Shared Preferences en Android (leer y escribir), tal como están disponibles por defecto. Luego de comprender su funcionamiento, en la lección siguiente vamos a hacer lo mismo de manera más concisa.
100 Shared Preferences, usando Kotlin 23:33
Veamos cómo simplificar el uso de SharedPreferences aprovechando las características de Kotlin como lenguaje. En esta lección analizamos 2 formas de cómo se puede sintetizar el uso de preferencias, y luego aplicamos una de tales propuestas.
+1 recurso asociado a esta clase
101 Repositorio en Github (Proyecto Android) 02:46
En esta lección vemos cómo crear un repositorio Git, cómo crear nuestro primer commit, y así mismo, subir nuestro proyecto a un repositorio remoto en Github.
+2 recursos asociados a esta clase
102 Snackbar by lazy 11:12
Veamos qué es y cómo hacer uso de un Snackbar. Definimos una lógica para que cerrar nuestra app requiera de doble tap. También vemos en qué consiste la "inicialización perezosa" o "inicialización tardía" haciendo uso de by lazy.
103 Alert Dialog 08:43
Veamos cómo crear un diálogo de alerta (AlertDialog) usando su correspondiente clase Builder. Así mismo, cómo asociar listeners a los botones que presenta.
104 Paso previo, mensaje de error y checked 08:02
Si un usuario presiona el botón de back mientras registra una cita y se encuentra en el paso 2, debe volver al paso 1. Eso lo implementamos en esta lección. Así mismo, validamos que se ingrese una descripción en el paso 1 y se escoja un tipo de cita, para poder continuar al paso 2.
105 Mostrar datos, para Confirmar cita 35:32
En esta lección añadimos un tercer CardView, mostrando un resumen de lo ingresado en los 2 primeros pasos, y un botón de confirmación. Organizamos estos pasos en archivos XML independientes. Corregimos un detalle respecto a pre-seleccionar una opción dentro de un RadioGroup. Y así mismo vemos cómo acceder al texto de las opciones seleccionadas en un Spinner, EditText, RadioGroup y RadioButton.
106 Validar selección de fecha y hora 12:19
En esta lección validamos que se haya ingresado una fecha en el paso 2, y así mismo seleccionado una hora. En el caso de la fecha, mostramos y ocultamos un ícono de error según corresponda. En el caso de la hora, mostramos un Snackbar.
107 Off-topic: Cómo crear y compartir un Gif 03:08
Veamos cómo crear fácilmente un Gif grabando una parte de nuestra pantalla, y cómo subir este archivo en un servicio público para poder compartirlo a través de su correspondiente URL. Esto es útil como reemplazo a grabar videos muy cortos.
+1 recurso asociado a esta clase
108 Registro en Digital Ocean 08:00
Veamos qué es Digital Ocean y qué es un droplet. Así mismo, iniciemos con nuestro registro.
+2 recursos asociados a esta clase
109 Conexión vía SSH 02:29
Veamos cómo conectarnos al droplet que creamos en la lección anterior. Lo primero que hacemos al conectarnos es cambiar la contraseña que obtuvimos por defecto.
110 Instalación de paquetes y dependencias 17:52
En esta lección configuramos MySQL, phpMyAdmin, Composer, Git, y descargamos las dependencias de nuestro proyecto Laravel, además de configurar nuestras credenciales en el archivo .env
111 Corregir conexión MySQL 02:39
Tras instalar MySQL en la lección anterior somos capaces de conectarnos desde consola, pero no a través de nuestro proyecto Laravel. En esta lección corregimos ese detalle respecto al usuario root.
112 Comandos Git: log, status, push, pull 05:54
En esta lección vemos cómo subir cambios que tenemos localmente hacia nuestro VPS en Digital Ocean.
113 Laravel log 07:24
Si tenemos errores en nuestro sitio online, de igual forma podemos ver mensajes de error específicos consultando los archivos log de Laravel. Es correcto también replicar el error localmente para solucionarlo.
114 Encoding, Encryption & Hashing 13:16
En esta lección vemos qué son los siguientes conceptos, a fin de entender sus diferencias: codificación (encoding), encriptación (encryption), hashing y ofuscación (obfuscation).
+1 recurso asociado a esta clase
115 JWT: Flujo de autenticación 08:09
Veamos cómo funciona una autenticación basada en JSON Web Tokens, desde una perspectiva general.
116 Cómo se genera y valida un JWT (5 pasos) 19:21
En esta lección vemos los pasos que sigue el servidor para generar un JWT, y para encargarse de su validación, representando de esta forma la autenticación de un usuario desde una aplicación cliente.
117 JWT Laravel Package 06:50
En esta lección revisamos el paquete LaraJWT, que usaremos para generar JSON Web Tokens desde nuestro proyecto Laravel.
+1 recurso asociado a esta clase
118 Guard JWT 05:44
Veamos brevemente qué son los Guards en Laravel, y cómo configurar el Guard api para que use el driver jwt que nos provee el paquete antes instalado.
119 API Routes & Middleware 14:56
En esta lección vemos cómo organizar y proteger las rutas de nuestra API en el archivo de rutas correspondiente. Además de revisar el archivo RouteServiceProvider y comprender su propósito.
120 API Login vía JWT 11:54
En esta lección vemos cómo implementar una API con inicio de sesión, haciendo uso de Json Web Tokens.
121 API Logout 05:52
Veamos cómo finalizar con una sesión de usuario a través de nuestra API.
122 Especialidades, médicos por especialidad y horas 10:27
En esta lección preparamos nuestras primeras rutas para ser consumidas por nuestra aplicación Android: lista de especialidades, lista de médicos por especialidad, y horas disponibles según fecha y médico escogidos.
123 Introducción a Retrofit 04:44
Veamos qué es Retrofit y su importancia para nuestro proyecto.
124 Organización en Paquetes, y ApiService 11:18
En esta lección organizamos nuestras clases existentes en paquetes, según el propósito de cada una. También añadimos Retrofit a nuestro proyecto, creamos nuestro ApiService, y empezamos a revisar cómo vamos a consumir datos de nuestra API.
125 Primer llamado a la API 19:04
Veamos cómo hacer una consulta a nuestra API desde Android. Gracias a Retrofit recibimos la información JSON mapeada a objetos. En este caso, obtenemos la lista de especialidades y las mostramos en su Spinner correspondiente.
126 Spinner dependiente (médicos) 14:57
Veamos cómo cargar un Spinner en función al valor de otro. En este caso, cada vez que se escoge una especialidad, la lista de médicos vuelve a cargar, y muestra a los médicos asociados con dicha especialidad.
127 Horas según médico y fecha 22:22
En esta lección hacemos una 3ra consulta al servidor (a través de nuestra API), para obtener las horas de atención disponibles, de un médico para una fecha en particular.
128 Formato de fecha (Mes que inicia en 0 o 1) 05:02
En esta lección corregimos un detalle con relación a las fechas. Sucede que las clases DatePickerDialog y Calendar consideran a Enero como el mes 0, mientras que para los usuarios y para MySQL es considerado Enero como mes 1.
129 Mostrar horas y mensajes asociados 16:59
En esta lección mostramos las horas de atención disponibles para el médico y fecha seleccionados. Así mismo agregamos mensajes para cuando no hay horas disponibles, o para cuando el usuario no ha seleccionado aún los campos requeridos para iniciar la búsqueda.
130 Inicio de sesión vía API y JSON Web Token 21:03
En esta lección implementamos nuestro inicio de sesión, validando las credenciales a través del servidor, y obteniendo como respuesta un JSON Web Token e información del usuario, en caso de éxito.
131 Cierre de sesión y Authorization Header 17:00
En esta lección hacemos una petición POST a nuestro servidor, para invalidar el JWT del usuario y así finalizar su sesión en nuestra app. Vemos cómo enviar Headers en nuestro request. Y así mismo agregamos una validación en nuestro login, además de un mensaje de bienvenida.
132 Citas médicas: modelo y formato JSON 27:28
En esta lección creamos un modelo correspondiente a las citas médicas (Appointment), adecuamos el formato de la respuesta JSON que da el servidor, y obtenemos y listamos las citas médicas en nuestra aplicación.
133 Item appointment XML 16:29
En esta lección agregamos más elementos sobre la vista que representa a cada cita médica. Con un botón, mostramos u ocultamos detalles adicionales de cada cita. El ícono del botón cambia, dependiendo de si se debe expandir o contraer tales detalles.
134 AutoTransition para los CardView 03:42
En esta lección vemos por qué la propiedad animateLayoutChanges no funcionó en la lección anterior y cómo podemos conseguir el mismo efecto usando 1 línea de código.
135 Store Appointment (Refactorización) 27:23
En esta lección refactorizamos el código que usamos para el registro de citas médicas en la versión web, a fin de poder reutilizar la lógica también al implementar nuestra API.
136 Registro de cita médica (Android) 24:07
En esta lección añadimos un método más a nuestro Api Service, a fin de poder registrar citas médicas a través de nuestra app Android. Así mismo, asociamos un Header a esta petición POST, indicando que se espera una respuesta en formato JSON.
137 Refactorización: Registro web y vía API 24:57
En esta lección identificamos la lógica que existe en común para el registro de pacientes, tanto desde la versión web como a través de la API (que se usará desde nuestra aplicación móvil). Vemos cómo definir un Trait y cómo organizar las reglas y mensajes de validación.
138 Registro desde Android 16:58
En esta lección completamos el proceso de registro a través de nuestra aplicación móvil. Tras registrarse, el usuario queda con su sesión activa sobre la aplicación Android, tal como ocurre en la versión web.
139 Introducción a Firebase Cloud Messaging 06:19
En esta introducción revisamos de manera general el servicio FCM, y cómo lo usaremos para el envío de notificaciones a dispositivos clientes.
140 Proyecto Firebase y configuración inicial 08:44
En esta lección creamos un nuevo proyecto en nuestra consola de Firebase, y añadimos algunas nuevas dependencias a nuestro proyecto Android con relación a Firebase.
+1 recurso asociado a esta clase
141 FCM y una primera notificación 27:40
Tras agregar Firebase a nuestro proyecto en la lección anterior, ahora agregamos la dependencia específica para FCM. Revisamos qué tipos de mensajes existen, configuramos una clase FCMService para recibir allí los mensajes, y recibimos una primera notificación enviada desde la consola de Firebase.
+1 recurso asociado a esta clase
142 Token de dispositivo (Firebase) 31:34
En esta lección vemos cómo obtener el token que Firebase asigna a cada dispositivo, y así mismo creamos una ruta nueva para guardar el token asociado a cada usuario, a través de nuestra API.
143 Notificación a todos, desde web 26:06
En esta lección modificamos la página de inicio de nuestro panel, definiendo un formulario y un gráfico de barras con los días de la semana. Este formulario permite al administrador enviar una notificación a todos los usuarios que tienen un dispositivo Android asociado (a través de un token Firebase). En la parte final, enviamos una notificación a la app móvil, de 2 formas (cuando está en foreground y en background).
144 Notificación al Cancelar / Confirmar 16:15
Ahora, cuando una cita médica sea cancelada o confirmada por un médico o administrador, el paciente se enterará a través de una notificación inmediata a su dispositivo móvil.
145 Generar notificación Android (foreground) 06:09
Antes mencionamos que si nuestra app se encuentra en foreground, no se genera una notificación Android directamente, más bien recibimos el mensaje desde FCM y tenemos el control para decidir qué hacer. Si deseamos generar una notificación Android, lo podemos hacer también. Es justo lo que hacemos en esta lección.
146 Enfoque a seguir para los recordatorios 05:45
Veamos 3 alternativas que podemos seguir para implementar los recordatorios. Al final decidimos por una, e iniciamos la implementación en la lección siguiente.
147 Task scheduling 25:35
En esta lección vemos cómo es posible programar tareas recurrentes haciendo uso de Laravel. También vemos cómo podemos definir nuestro propio comando artisan. Definimos un comando para detectar citas próximas a ser atendidas, dentro de 24 horas y en la hora siguiente.
148 Enviar notificaciones usando Cron 21:54
En esta lección vemos cómo programar la ejecución tareas en producción, de manera recurrente. En este caso lo que programamos es la ejecución del comando artisan que creamos en la lección anterior. Usamos esto para notificar a los pacientes de próximas citas, 24 horas antes y 1 hora antes de la fecha y hora confirmadas.
149 Cómo compartir nuestra app 01:08
En esta lección vemos cómo generar un unsigned apk (sin firma), para que lo podamos compartir con nuestros conocidos y nos ayuden a probar la app.
150 Resumen y lecciones adicionales 09:19
Hagamos un breve conteo de los temas más importantes que hemos revisado a lo largo del curso.
151 Gráfico: citas según día de la semana 22:24
En esta lección implementamos un gráfico de barras, mostrando la cantidad de citas programadas por cada día de la semana (es decir, de domingo a sábado, vemos qué día suele presentar mayor demanda).
+1 recurso asociado a esta clase
152 Laravel Cache 19:17
En esta lección vemos cómo usar Cache, para recordar resultados de consultas y así evitar ejecutarlas por cada visita que recibe una página.
153 Clear cache 01:51
¿Qué ocurre si queremos actualizar la forma en que calculamos los valores de una variable guardada en Cache?
154 Botón y Activity para Editar perfil 08:39
En esta lección agregamos un botón nuevo a nuestro menú principal, y le asociamos un evento de "click" vía XML. Así mismo, creamos un Activity nuevo, le asociamos un parent y lo iniciamos cada vez que se hace clic sobre el nuevo botón.
155 Formulario y Loading indicator 13:58
En esta lección diseñamos el formulario donde estarán presentes los datos de perfil de cada usuario, y así mismo agregamos un ProgressBar, para mostrar un ícono de carga inicialmente, antes de presentar los campos con los datos traídos del servidor.
156 Obtener datos de perfil (GET) 12:43
En esta lección definimos una ruta GET en nuestra API, y la consultamos desde nuestra aplicación Android, para obtener los datos de perfil del usuario autenticado.
157 Actualizar datos de perfil (POST) 14:15
En esta lección definimos una ruta POST en nuestra API, y la consultamos desde nuestra aplicación Android, para guardar cambios sobre los datos de perfil del usuario autenticado.
158 Exigir teléfono en Android 15:12
En esta lección añadimos una condición sobre el registro de citas médicas, para validar que un usuario haya registrado su teléfono antes de poder reservar citas. Analizamos distintas formas de lograr ello, e implementamos una de tales alternativas.
159 Ruta GET y POST en Web 18:27
En esta lección definimos una vista para la edición de datos de perfil, y así mismo definimos una ruta POST para guardar los cambios como corresponde. Es decir, hacemos lo mismo que en Android pero ahora en nuestra versión Web. También revisamos brevemente la diferencia entre una variable enviada a una vista directamente y una variable de sesión.
160 Middleware phone 07:29
Implementamos un nuevo middleware a modo de repaso, y vemos cómo es posible definir un grupo de rutas dentro de otro grupo de rutas, además que podemos enviar variables de sesión al hacer redirect desde un middleware.
Preguntas frecuentes
Con una membresía premium obtienes acceso a todos los cursos de la plataforma, incluyendo este.
Como usuario premium tendrás acceso a la sección de preguntas y respuestas de la plataforma.
En nuestro foro privado, el 100% de las preguntas reciben respuesta 🙂.
Los pagos se pueden realizar vía PayPal o con tarjeta (crédito o débito).
Escríbenos a [email protected] si deseas coordinar otro medio de pago.
Esta serie consta de 160 capítulos.
Nivel de dificultad: Aprendiz.
Inicia sesión para empezar el curso y llevar un control de tu progreso.