INSTITUTO POLITÉCNICO NACIONAL

Centro de Estudios Científicos y Tecnológicos

No. 5
“Benito Juárez García”

“Manual de Usuario del

Geolocalizador
para Android”

NOMBRE DEL ALUMNO: Holaaa

Introducción
Este manual proporciona una guía detallada para integrar Google Maps en una
aplicación Android utilizando Google Maps API. A lo largo de este manual, se
cubrirán todos los pasos necesarios para configurar y utilizar Google Maps.

En el código va a enseñar:

 Latitud y longitud

 Mapa

 Búsqueda de ubicación

 Ubicación del dispositivo en tiempo real

 Creación de clave API

 Permisos

 Implementaciones
  PROYECTO

Para empezar, tenemos que crear un nuevo proyecto en Android Studio, Este será
un (Empaty Views Activity) lo trabajaremos en el lenguaje de java y le
asignaremos un nombre.
  Ya creado nuestro proyecto, vamos a iniciar con la creación de API, para esto
nos dirigiremos a Manifests el cual esta localizado en la parte superior a la
izquierda.

Abriremos la ventana y escribiremos lo siguiente

<meta-data
android:name="com.google.android.geo.API_KEY"
android:value=" "/>

En androit:value=””/> se escribirá la clave API

Esta línea:
1. Provee la clave de API que permite a tu aplicación comunicarse con los
servicios de Google Maps.

2. Autentica la solicitud entre la aplicación y los servidores de Google, asegurando

que solo las aplicaciones autorizadas puedan utilizar los servicios de Google Maps.
  CREACION DE CLAVE API

Para esto nos dirigiremos a tu navegador de confianza y escribiremos en la barra del

buscador
“google console” y daremos clic en la primera opción

Para esto ya tuviste que crearte una cuenta, al ingresar daremos clic en “Go to my
console ”

Después nos abrirá esta pestaña en la cual daremos clic en la parte de arriba a lado de
“GOOGLE
CLOUNT”, nos abrirá un menú y daremos clic en proyecto nuevo.
Al darle clic nos aparecerá una pestaña en la cual tenemos que asignarle un nombre a
nuestro proyecto y una ubicación “Pero no pondremos nada en este campo”, después le
daremos en crear

Después nos saldara un menú en la parte de notificaciones, esperaremos a que cargue y

después lo seleccionamos

Después nos abrirá el panel de nuestro proyecto, le daremos En el menú y

seleccionaremos “APIs y servicios” y le daremos en la primera opción “API y
servicios habilitados”
Nos enviara a esta ventana ,y daremos clic en “Habilitar APIs y servicios ”

Después abrirá esta ventana en la cual nos muestra todas las APIs que podemos
usar, pero nosotros elegiremos “Maps SDK for Android”, y le daremos clic.
Al darle clic nos mandara a esta ventana en la cual tendremos que habilitar el API,
solo hay que darle en habilitar.

Después que ya se allá habilitado, ahora tendremos que crear una credencial, para
eso daremos en menú y buscaremos “Credenciales”

Nos abrirá esta ventana y buscaremos “Crear Credenciales” al darle clic nos
aparecerá un menú en el cual elegiremos “Clave API”.
Con esto echo, nos dará nuestra clave API la cual tendremos que copiar.

 Después pegaremos nuestra clave API en nuestro código

  Vista del Programa

Primero crearemos 3 Edith Text, un botón y un fragment. A

todos se les cambiara su id y su estructura en la parte de
“Desing” y en la parte del código.

En la parte Desing quedaría de esta forma:

Y este es su forma en código
  Configuraciones del Edith Text

android:id="@+id/txtlatitud"
 Define el ID único del EditText.
 Permite acceder a este elemento desde el código
Java/Kotlin mediante findViewById().

android:layout_width="0dp"
 El ancho se ajusta dinámicamente según las
restricciones definidas (en este caso, usando
ConstraintLayout).
 El valor 0dp se usa con restricciones para decir que se
estire entre las posiciones marcadas por las
restricciones de inicio y fin.

android:layout_height="wrap_content"
 El alto se ajusta al contenido, es decir, al tamaño del
texto que contenga.

android:layout_marginStart="10dp"
 Define un margen de 10dp desde el borde izquierdo del
contenedor (compatible con el diseño RTL - de derecha
a izquierda).

android:layout_marginTop="10dp" y
android:layout_marginEnd="10dp"
 Añaden un margen superior y margen derecho de
10dp.

android:ems="10"
 Establece el ancho predeterminado del EditText en
términos de caracteres "M".
 Por ejemplo, ems="10" significa que el campo será lo
suficientemente ancho para contener 10 letras "M" (ya
que es uno de los caracteres más anchos).
 android:inputType="text"
 Define el tipo de entrada esperado. En este caso,
permite ingresar texto libre.

app:layout_constraintBottom_toTopOf="@+id/
txtlongitud"
 Coloca el EditText encima del otro campo con ID
txtlongitud.

app:layout_constraintEnd_toEndOf="parent"
 Restringe el extremo derecho del EditText al borde
derecho del contenedor (parent).

app:layout_constraintStart_toStartOf="parent"

 Restringe el extremo izquierdo del EditText al borde

izquierdo del contenedor.

app:layout_constraintTop_toTopOf="parent"

 Restringe el borde superior del EditText al borde

superior del contenedor.

app:layout_constraintHorizontal_bias="0.5"

 Centra horizontalmente el EditText dentro del espacio

asignado entre las restricciones de inicio y fin.
 El valor 0.5 significa centrado; si cambias este valor a
0.0 o 1.0, se desplazará hacia un lado.

app:layout_constraintVertical_bias="0.5"

 Ajusta la posición vertical dentro del espacio

disponible entre las restricciones superior e inferior.
 Un valor de 0.5 lo coloca en el centro verticalmente.
  Parte de FRAGMENT
En esta parte se utilizaran algunas configuraciones ya

explicadas :

Pero se integrara una línea más, pero para esto tendremos

que ir a el a apartado del menú en donde dice “Grandle
Scripts” y seleccionaremos “Buils.grandle.kts(Module:app)”
Y nos iremos a la parte de “dependencies” y asignaremos
otra implementación.

implementation("com.google.android.gms:play-services-
maps:19.0.0")

¿Qué hace?

 Agrega la dependencia de los servicios de Google

Maps a tu proyecto Android. Esto permite integrar
mapas interactivos de Google Maps dentro de tu
aplicación.
 Es parte de los servicios de Google Play, y proporciona
las clases y herramientas necesarias para trabajar con
mapas

¿Por qué es necesaria?

1. Cargar mapas de Google Maps dentro de una

actividad o fragmento.
2. Añadir marcadores, rutas, y personalización de los
mapas.
3. Permitir interactividad con los gestos de los usuarios
(por ejemplo, zoom, desplazamiento, etc.).
4. Utilizar la API de geolocalización para mostrar la
ubicación del usuario en el mapa.
 Después regresaremos a Activity main.xml a nuestro
apartado de fragment y pondremos esta línea.

android:name="com.google.android.gms.maps.SupportMapFr

agment"
  Parte logica

Para empezar con esta parte nos iremos a la Ventana

“Manifests” y escribiremos

<uses-permission
android:name="android.permission.ACCESS_FINE_LOCATION"
/>

<uses-permission
android:name="android.permission.ACCESS_COARSE_LOCATI
ON"/>

<uses-permission
android:name="android.permission.INTERNET" />
<uses-permission
android:name="android.permission.ACCESS_FINE_LOCATION"
/>

Este permiso permite a la aplicación acceder a la ubicación

precisa del dispositivo mediante:
 GPS (Global Positioning System)
 Wi-Fi o torres de red móvil, cuando están disponibles.

Uso típico:
 Para obtener coordenadas exactas del usuario.
 Mostrar la ubicación del usuario en Google Maps.
 Aplicaciones que requieren alta precisión, como apps de
 navegación y mapas en tiempo real.

<uses-permission
android:name="android.permission.ACCESS_COARSE_L
OCATION"/>

Este permiso permite acceder a la ubicación aproximada

del dispositivo, con una precisión inferior a la del GPS,
obtenida principalmente mediante:
 Wi-Fi y redes de telefonía.
 Menor consumo de batería comparado con el GPS.

Uso típico:
 Cuando no necesitas la ubicación exacta del usuario, por
ejemplo, para personalizar el contenido según la
ciudad o región.

<uses-permission
android:name="android.permission.INTERNET" />

Este permiso permite que la aplicación acceda a Internet,

necesario para:
 Cargar mapas de Google Maps.
 Obtener datos de ubicación mediante servicios de
red.
 Conectar con APIs y servicios en la nube.
Uso típico:
 Para aplicaciones que dependen de servicios en línea
(por ejemplo, aplicaciones de mapas, clima, noticias,
etc.).

 Después nos iremos a la ventana MainActivity

Definición de la clase

public class MainActivity extends AppCompatActivity

implements OnMapReadyCallback,
GoogleMap.OnMapClickListener,
GoogleMap.OnMapLongClickListener {

 MainActivity: Es la clase principal de la actividad de la

aplicación Android que extiende de AppCompatActivity,
lo que le permite heredar funcionalidades clave para
gestionar la interfaz gráfica y ciclo de vida de la
actividad.

 Interfaces implementadas:

o OnMapReadyCallback: Permite que esta actividad

reciba una notificación cuando el mapa esté listo
para ser usado. Se utiliza para configurar el mapa
(cargar marcadores, personalizar la cámara, etc.).
o GoogleMap.OnMapClickListener: Permite que la
actividad detecte cuando el usuario hace clic en el
mapa.
o GoogleMap.OnMapLongClickListener: Permite
que la actividad detecte cuando el usuario realiza un
clic largo en el mapa.

3.Declaración de variables globales

private static final int
LOCATION_PERMISSION_REQUEST_CODE = 1;
EditText txtlongitud, txtlatitud, txtSearch;
Button btnSearch;
GoogleMap mMap;

 LOCATION_PERMISSION_REQUEST_CODE: Es un valor
constante que se usa para identificar la solicitud de
permisos de ubicación.
 txtlongitud, txtlatitud, txtSearch: Son objetos de tipo
EditText, que son campos de texto donde el usuario
puede ver o ingresar información (en este caso, latitud,
longitud y texto para buscar una ubicación).
 btnSearch: Un botón que permite al usuario realizar una
acción cuando lo pulsa, como buscar una ubicación.
 mMap: Es una instancia de GoogleMap, que será el
objeto para interactuar con el mapa de Google.

4.Método onCreate

@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
setContentView(R.layout.activity_main);

 onCreate(Bundle savedInstanceState): Este es el

método principal que se llama cuando la actividad es
creada. Aquí es donde se inicializa la actividad y se
 configura el layout.
 setContentView(R.layout.activity_main): Esto carga
el diseño (layout) de la actividad desde el archivo XML
activity_main, lo cual define la interfaz gráfica que el
usuario verá.

5.Vinculación de vistas con el layout

txtlatitud = findViewById(R.id.txtlatitud);
txtlongitud = findViewById(R.id.txtlongitud);
txtSearch = findViewById(R.id.txtSearch);
btnSearch = findViewById(R.id.btnSearch);
 findViewById: Este método busca dentro del archivo de
diseño (XML) un componente que tenga el id
especificado.
o txtlatitud: Se vincula con el campo de texto en el
layout que tiene el id txtlatitud, donde se mostrará o
ingresará la latitud.
o txtlongitud: Se vincula con el campo de texto que
tiene el id txtlongitud para mostrar o ingresar la
longitud.
o txtSearch: Se vincula con el campo de búsqueda
con el id txtSearch.
o btnSearch: Vincula el botón de búsqueda con el id
btnSearch.

6.Inicialización del mapa

 SupportMapFragment: Es una clase que permite

integrar Google Maps en un fragmento dentro de la
actividad. Un fragmento es una parte de la interfaz de
usuario que puede ser reutilizable y modular.
 getSupportFragmentManager().findFragmentById(
R.id.map): Busca el fragmento que contiene el mapa en
 el diseño y lo asigna a mapFragment. El id R.id.map es el
identificador del fragmento de mapa dentro del archivo
XML de diseño.
 mapFragment.getMapAsync(this): Aquí se llama al
método getMapAsync, que carga el mapa de manera
asíncrona (es decir, no bloquea la interfaz de usuario).
Cuando el mapa esté listo, llamará al método
onMapReady, que es parte de la interfaz
OnMapReadyCallback que la actividad implementa.
. Comprobación de permisos de ubicación

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {

if (ContextCompat.checkSelfPermission(this,
Manifest.permission.ACCESS_FINE_LOCATION) !=
PackageManager.PERMISSION_GRANTED) {
ActivityCompat.requestPermissions(this, new String[]
{Manifest.permission.ACCESS_FINE_LOCATION},
LOCATION_PERMISSION_REQUEST_CODE);
} else {
enableMyLocation(); // Habilitar la ubicación si ya se han
otorgado permisos
}
} else {
enableMyLocation(); // Habilitar la ubicación en versiones
anteriores
}

 Verificación de la versión de Android:

o Build.VERSION.SDK_INT >=
Build.VERSION_CODES.M: Aquí se verifica si la
versión de Android del dispositivo es Marshmallow
(API 23) o superior. A partir de Android 6.0
(Marshmallow), la forma de solicitar permisos cambió
y ahora los permisos sensibles, como el de
ubicación, deben solicitarse en tiempo de ejecución.

 Comprobación de permisos:
o ContextCompat.checkSelfPermission(this,
Manifest.permission.ACCESS_FINE_LOCATION):
Este método verifica si el permiso para acceder a la
ubicación precisa (ACCESS_FINE_LOCATION) ha
 sido otorgado.
o != PackageManager.PERMISSION_GRANTED: Si
el permiso no ha sido otorgado, se ejecuta el
siguiente bloque de código para solicitarlo.

 Solicitud de permisos:
o ActivityCompat.requestPermissions: Si el
permiso aún no ha sido concedido, este método
solicita al usuario que lo otorgue. Los permisos
solicitados aquí son ACCESS_FINE_LOCATION, y el
resultado de la solicitud será gestionado en el
método onRequestPermissionsResult.
o LOCATION_PERMISSION_REQUEST_CODE: Es un
código numérico que permite identificar qué solicitud
de permisos está siendo gestionada. En este caso, se
usa para la ubicación.

 Habilitar la ubicación:
o Si el permiso ya fue concedido o si la versión de
Android es inferior a Marshmallow, se llama a
enableMyLocation(), un método que habilita la
funcionalidad de ubicación en el mapa.

2. Listener para el botón de búsqueda

btnSearch.setOnClickListener(new View.OnClickListener() {
@Override
public void onClick(View v) {
String location = txtSearch.getText().toString();
searchLocation(location);
}
});

 Listener del botón:

 o btnSearch.setOnClickListener: Aquí se define un
listener para el botón de búsqueda. Cuando el
usuario hace clic en este botón, se ejecuta el código
dentro del método onClick.
 Búsqueda de ubicación:
o txtSearch.getText().toString(): Obtiene el texto
ingresado en el campo de búsqueda (txtSearch), que
representa el nombre o dirección de la ubicación que
el usuario desea buscar.
o searchLocation(location): Llama al método
searchLocation(), que será el encargado de buscar la
ubicación en el mapa con el nombre o dirección
ingresado.

3. Gestión de la respuesta de la solicitud de permisos

@Override
public void onRequestPermissionsResult(int requestCode,
@NonNull String[] permissions, @NonNull int[] grantResults) {
if (requestCode ==
LOCATION_PERMISSION_REQUEST_CODE) {
if (grantResults.length > 0 && grantResults[0] ==
PackageManager.PERMISSION_GRANTED) {
 enableMyLocation(); // Habilitar la ubicación si se
otorgan los permisos
} else {
Toast.makeText(this, "Permiso de ubicación
denegado", Toast.LENGTH_SHORT).show();
}
}
}
 onRequestPermissionsResult: Este método gestiona
el resultado de la solicitud de permisos (en este caso, de
ubicación). Se ejecuta automáticamente después de que
el usuario acepta o rechaza los permisos solicitados.

 Comprobación del código de solicitud:

o requestCode ==
LOCATION_PERMISSION_REQUEST_CODE: Aquí
se verifica si el resultado corresponde a la solicitud
de permisos para la ubicación, usando el código de
solicitud que definimos anteriormente
(LOCATION_PERMISSION_REQUEST_CODE).

 Verificación del resultado:

o grantResults.length > 0 && grantResults[0] ==
PackageManager.PERMISSION_GRANTED:
Comprueba si el array grantResults contiene algún
valor (es decir, si se obtuvo una respuesta) y si el
primer permiso en la lista fue concedido
(PERMISSION_GRANTED).
o Si el permiso fue concedido, se llama a
enableMyLocation() para habilitar la funcionalidad
de ubicación en el mapa.

 Manejo del rechazo del permiso:

o Si el permiso es denegado, se muestra un mensaje
de error al usuario usando un Toast, que es una
pequeña notificación en pantalla: "Permiso de
 ubicación denegado".

1. Método onMapReady
@Override
public void onMapReady(@NonNull GoogleMap googleMap) {
mMap = googleMap;
this.mMap.setOnMapClickListener(this);
this.mMap.setOnMapLongClickListener(this);
enableMyLocation(); // Habilitar mi ubicación
loadCurrentLocation();
}
Este método es parte de la interfaz OnMapReadyCallback,
que se implementa cuando se usa Google Maps en una
actividad. Se llama cuando el mapa está listo para ser usado.

 mMap = googleMap: Asigna el mapa proporcionado por

la API de Google Maps a la variable mMap para que
puedas interactuar con él a partir de ahora.
  this.mMap.setOnMapClickListener(this): Configura
un listener para detectar cuando el usuario hace clic en
el mapa. El método onMapClick se ejecutará cuando
ocurra el evento. La actividad (this) se usa como la clase
que manejará el evento.
 this.mMap.setOnMapLongClickListener(this): De
forma similar, esto configura un listener para detectar
cuando el usuario hace una pulsación larga en el mapa.
El método onMapLongClick se ejecutará en este caso.
 enableMyLocation(): Este método activa la
funcionalidad de ubicación en el mapa, mostrando la
ubicación del usuario y habilitando el botón de "Mi
ubicación" si se han concedido los permisos
correspondientes.
 loadCurrentLocation(): Este método intenta cargar la
ubicación actual del usuario en el mapa. Si no se puede
obtener la ubicación actual, centra el mapa en una
ubicación predeterminada.

2. Método loadCurrentLocation

private void loadCurrentLocation() {

if (ActivityCompat.checkSelfPermission(this,
Manifest.permission.ACCESS_FINE_LOCATION) ==
PackageManager.PERMISSION_GRANTED ||
ActivityCompat.checkSelfPermission(this,
Manifest.permission.ACCESS_COARSE_LOCATION) ==
PackageManager.PERMISSION_GRANTED) {

Location currentLocation = mMap.getMyLocation();

if (currentLocation != null) {
LatLng currentLatLng = new
LatLng(currentLocation.getLatitude(),
currentLocation.getLongitude());
mMap.moveCamera(CameraUpdateFactory.newLatLngZoom(
currentLatLng,
15));
} else {
LatLng defaultLocation = new LatLng(19.4310853, -
99.152987); // Ubicación predeterminada
mMap.moveCamera(CameraUpdateFactory.newLatLngZoom(
defaultLocation, 10));
}
}
}

Este método intenta cargar y centrar el mapa en la

ubicación actual del usuario o, si no está disponible, en
una ubicación predeterminada.

 Verificación de permisos:

o ActivityCompat.checkSelfPermission(this,
Manifest.permission.ACCESS_FINE_LOCATION):
Verifica si el permiso para acceder a la ubicación
precisa (ACCESS_FINE_LOCATION) ha sido otorgado.
o ActivityCompat.checkSelfPermission(this,
Manifest.permission.ACCESS_COARSE_LOCATIO
N): Verifica si se ha otorgado el permiso para
acceder a la ubicación aproximada
 (ACCESS_COARSE_LOCATION).
o Si alguno de los permisos ha sido concedido, el
código intenta obtener la ubicación actual del
usuario.

 Obtener la ubicación actual:

o Location currentLocation =
mMap.getMyLocation(): Intenta obtener la
ubicación actual del usuario usando el método
getMyLocation() del mapa. Si la ubicación actual
está disponible, se almacena en currentLocation.

 Centrar el mapa en la ubicación actual:

o if (currentLocation != null): Si la ubicación actual
es válida (es decir, no es null), el código:
 Crea un objeto LatLng con la latitud y longitud
actuales.
 Usa
mMap.moveCamera(CameraUpdateFactory
.newLatLngZoom(currentLatLng, 15)) para
mover la cámara del mapa a esa posición con
un nivel de zoom de 15 (un zoom relativamente
cercano).

 Ubicación predeterminada:
o else: Si la ubicación actual no está disponible (es
null), el código centra el mapa en una ubicación
predeterminada con latitud 19.4310853 y longitud -
99.152987, que corresponde a la Ciudad de México.
o El nivel de zoom en este caso es 10, lo que muestra
un área más amplia.
 1.Verificación de permisos

if (ActivityCompat.checkSelfPermission(this,
Manifest.permission.ACCESS_FINE_LOCATION) !=
PackageManager.PERMISSION_GRANTED
&& ActivityCompat.checkSelfPermission(this,
Manifest.permission.ACCESS_COARSE_LOCATION) !=
PackageManager.PERMISSION_GRANTED) {
return;
}

 Comprobación de permisos:
o Este bloque verifica si los permisos de ubicación han
sido concedidos.
o ACCESS_FINE_LOCATION: Permiso para acceder a
la ubicación precisa del usuario.
o ACCESS_COARSE_LOCATION: Permiso para
acceder a la ubicación aproximada del usuario.
 Condición &&:
o La condición comprueba que ninguno de los dos
permisos haya sido concedido. Si ambos son
denegados, el método sale sin hacer nada usando
return.

2.Habilitar la funcionalidad de "Mi ubicación" en el

mapa

mMap.setMyLocationEnabled(true);

 Si los permisos fueron otorgados, se llama a

mMap.setMyLocationEnabled(true).
 setMyLocationEnabled(true): Este método habilita
una capa en el mapa que muestra la ubicación del
usuario en tiempo real (normalmente representada por
un punto azul en el mapa).
 3.Mostrar el botón de "Mi ubicación"

mMap.getUiSettings().setMyLocationButtonEnabled(true);

 mMap.getUiSettings(): Obtiene los ajustes de la

interfaz de usuario del mapa (UI settings), que permiten
configurar distintos aspectos visuales del mapa.
 setMyLocationButtonEnabled(true): Este método
habilita un botón de ubicación en la interfaz del mapa.
Este botón, generalmente ubicado en la esquina superior
derecha, permite al usuario centrarse automáticamente
en su ubicación actual cuando lo presiona.
 1.Creación del Geocoder y List<Address>

Geocoder geocoder = new Geocoder(this);

List<android.location.Address> addressList;

 Geocoder: Esta clase se utiliza para convertir

direcciones o nombres de lugares en coordenadas
geográficas (latitud y longitud) y viceversa.
 addressList: Se declara una lista de objetos Address,
que almacenará las posibles ubicaciones obtenidas tras
la búsqueda del nombre de la ubicación.

2.Validación de la ubicación ingresada

if (location != null && !location.isEmpty()) {

 Se verifica que la variable location (es decir, el texto

ingresado por el usuario) no sea nula ni esté vacía.

3.Búsqueda de la ubicación usando Geocoder
try {
addressList = geocoder.getFromLocationName(location, 1);
if (addressList != null && !addressList.isEmpty()) {
android.location.Address address = addressList.get(0);

 geocoder.getFromLocationName(location, 1): Se
utiliza el Geocoder para buscar una ubicación en base al
nombre o dirección proporcionada por el usuario. El
número 1 indica que queremos obtener un solo resultado
(la primera coincidencia).
  if (addressList != null && !addressList.isEmpty()):
Si la búsqueda devuelve resultados, se toma el primer
resultado de la lista (addressList.get(0)) y se almacena
en la variable address.

Obtener latitud y longitud de la ubicación

LatLng latLng = new LatLng(address.getLatitude(),

address.getLongitude());
mMap.clear();
mMap.addMarker(new
MarkerOptions().position(latLng).title(address.getFeatureNam
e()));
mMap.moveCamera(CameraUpdateFactory.newLatLngZoom(l
atLng, 15));
txtlatitud.setText(String.valueOf(address.getLatitude()));
txtlongitud.setText(String.valueOf(address.getLongitude()));

 new LatLng(address.getLatitude(),
address.getLongitude()): Se crea un objeto LatLng
con las coordenadas de la ubicación encontrada (latitud y
longitud).
  mMap.clear(): Se limpia el mapa de cualquier marcador
o elemento previo

 mMap.addMarker(new
MarkerOptions().position(latLng).title(address.get
FeatureName())): Se añade un marcador en la
ubicación encontrada usando las coordenadas de latLng.
El título del marcador es el nombre del lugar obtenido
por address.getFeatureName().

 mMap.moveCamera(CameraUpdateFactory.newLat
LngZoom(latLng, 15)): La cámara del mapa se mueve
a las coordenadas de latLng con un nivel de zoom 15,
lo que muestra una vista cercana del lugar.

 txtlatitud.setText(String.valueOf(address.getLatitu
de())) y
txtlongitud.setText(String.valueOf(address.getLon
gitude())): Los valores de latitud y longitud se muestran
en los EditText correspondientes para que el usuario los
vea.

4.Manejo de errores y excepciones

} else {
Toast.makeText(this, "No se encontró la ubicación",
Toast.LENGTH_SHORT).show();
}
 Si no se encuentra ninguna dirección con el nombre
proporcionado, se muestra un mensaje de error usando
 Toast.

Captura de excepciones:
 IOException: Si ocurre un error de entrada/salida (por
ejemplo, problemas de red al usar el Geocoder), se
muestra un mensaje de error con Toast.

 IllegalArgumentException: Si la ubicación
proporcionada es inválida (por ejemplo, una cadena vacía
o con caracteres no válidos), también se muestra un
mensaje de error.

5.Mensaje de error si no se ingresa ninguna

ubicación

} else {
Toast.makeText(this, "Por favor ingresa una ubicación",
Toast.LENGTH_SHORT).show();
}
 Si el usuario no ha ingresado ninguna ubicación o el
campo de búsqueda está vacío, se muestra un mensaje
pidiéndole que introduzca una ubicación válida.
1. Método onMapClick
Este método se ejecuta cuando el usuario hace un clic corto
(tap) en el mapa.
Paso a paso:

@Override
public void onMapClick(@NonNull LatLng latLng) {
txtlatitud.setText("" + latLng.latitude);
txtlongitud.setText("" + latLng.longitude);
mMap.clear();

 Actualización de latitud y longitud:

 o latLng.latitude y latLng.longitude son las
coordenadas del lugar donde el usuario hizo clic.
o Estas coordenadas se muestran en los campos
txtlatitud y txtlongitud.
o
 Limpiar el mapa:
o mMap.clear() elimina cualquier marcador o capa
existente en el mapa antes de agregar uno nuevo.
LatLng clickedLocation = new LatLng(latLng.latitude,
latLng.longitude);
mMap.addMarker(new
MarkerOptions().position(clickedLocation).title(""));
mMap.moveCamera(CameraUpdateFactory.newLatLng(clicke
dLocation));
}
 Agregar marcador:
o Se crea un nuevo objeto LatLng llamado
clickedLocation con las coordenadas donde el
usuario hizo clic.
o Se añade un marcador en esa posición mediante
mMap.addMarker(). El marcador no tiene un título
porque se ha proporcionado una cadena vacía ("").
 Mover la cámara:
o El mapa se centra en el lugar donde se hizo clic,
utilizando
mMap.moveCamera(CameraUpdateFactory.ne
wLatLng(clickedLocation)).

2. Método onMapLongClick
Este método es casi idéntico al anterior, pero se ejecuta
cuando el usuario hace un clic prolongado (long click) en
el mapa.
Paso a paso:

@Override
public void onMapLongClick(@NonNull LatLng latLng) {
txtlatitud.setText("" + latLng.latitude);
 txtlongitud.setText("" + latLng.longitude);
mMap.clear();

 Actualización de latitud y longitud:

o Similar al método onMapClick, se muestran las
coordenadas de la ubicación en los campos de texto.
 Limpiar el mapa:
o Se elimina cualquier marcador o capa previa en el
mapa.

LatLng longClickedLocation = new LatLng(latLng.latitude,

latLng.longitude);
mMap.addMarker(new
MarkerOptions().position(longClickedLocation).title(""));
mMap.moveCamera(CameraUpdateFactory.newLatLng(longCli
ckedLocation));
}
 Agregar marcador:
o Se crea un nuevo objeto LatLng llamado
longClickedLocation con las coordenadas de la
ubicación donde se hizo el clic prolongado.
o Se añade un marcador en esa posición sin un título.
 Mover la cámara:
o Similar al método anterior, el mapa se centra en el
lugar donde se hizo el clic prolongado.
Vista final de los codigos