

Las traducciones son generadas a través de traducción automática. En caso de conflicto entre la traducción y la version original de inglés, prevalecerá la version en inglés.

# Introducción a Amazon Location Service
<a name="getting-started"></a>

Este tema puede ser de ayuda para familiarizarse con Amazon Location Service. Siga estos pasos para crear su primera aplicación y comprender cómo elegir la API de Amazon Location adecuada en función de los casos de uso habituales. 

1. **Configure la cuenta de AWS y el acceso.**

   Si aún no tiene una cuenta, se le pedirá que cree una. Con la capa gratuita de AWS, puede obtener tres meses de la capa gratuita para Amazon Location Service.

   Si ya tiene una cuenta, debe proporcionar acceso a Amazon Location Service.

   Continúe con el tema de [Configure su cuenta](set-up.md).

1. **Comprenda y configure la autenticación.**

   Para utilizar Amazon Location, se le debe conceder acceso a un usuario a los recursos y las API que componen Amazon Location. Clave de API, Amazon Cognito e AWS Identity and Access Management (IAM) son tres opciones para conceder acceso a los recursos y acciones (API). 

   Continúe con el tema de [Autenticación con Amazon Location Service](access.md).

1. **Cree su primera aplicación de ubicación.**

   Compruebe [Creación de la primera aplicación de mapas y lugares de Amazon Location](first-app.md) para crear su primera aplicación “Hola, mundo”.

1. **Elija la API correcta.**

   Amazon Location ofrece un amplio conjunto de API para lugares, rutas, mapas, geocercas y rastreadores para resolver una variedad de casos de uso empresariales. 

   Para obtener más información sobre cómo elegir una API de Amazon Location, consulte [Elección de la API correcta](choose-an-api.md) para obtener más información.

# Configure su cuenta
<a name="set-up"></a>

En esta sección, se describen los pasos para utilizar Amazon Location Service. Debe disponer de una Cuenta de AWS de Amazon Location y haber configurado el acceso a ella para los usuarios que quieran utilizarla.

## Soy nuevo en AWS
<a name="new-user"></a>

### Inscríbase en una Cuenta de AWS
<a name="sign-up-for-aws"></a>

Si no tiene uno Cuenta de AWS, complete los siguientes pasos para crearlo.

**Para suscribirte a una Cuenta de AWS**

1. Abrir [https://portal.aws.amazon.com/billing/registro](https://portal.aws.amazon.com/billing/signup).

1. Siga las instrucciones que se le indiquen.

   Parte del procedimiento de registro consiste en recibir una llamada telefónica o mensaje de texto e indicar un código de verificación en el teclado del teléfono.

   Cuando te registras en un Cuenta de AWS, *Usuario raíz de la cuenta de AWS*se crea un. El usuario raíz tendrá acceso a todos los Servicios de AWS y recursos de esa cuenta. Como práctica recomendada de seguridad, asigne acceso administrativo a un usuario y utilice únicamente el usuario raíz para realizar [Tareas que requieren acceso de usuario raíz](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_root-user.html#root-user-tasks).

AWS te envía un correo electrónico de confirmación una vez finalizado el proceso de registro. En cualquier momento, puede ver la actividad de su cuenta actual y administrarla accediendo a [https://aws.amazon.com/](https://aws.amazon.com/)y seleccionando **Mi cuenta**.

### Creación de un usuario con acceso administrativo
<a name="create-an-admin"></a>

Después de crear un usuario administrativo Cuenta de AWS, asegúrelo Usuario raíz de la cuenta de AWS AWS IAM Identity Center, habilite y cree un usuario administrativo para no usar el usuario root en las tareas diarias.

**Proteja su Usuario raíz de la cuenta de AWS**

1.  Inicie sesión [Consola de administración de AWS](https://console.aws.amazon.com/)como propietario de la cuenta seleccionando el **usuario root** e introduciendo su dirección de Cuenta de AWS correo electrónico. En la siguiente página, escriba su contraseña.

   Para obtener ayuda para iniciar sesión con el usuario raíz, consulte [Iniciar sesión como usuario raíz](https://docs.aws.amazon.com/signin/latest/userguide/console-sign-in-tutorials.html#introduction-to-root-user-sign-in-tutorial) en la *Guía del usuario de AWS Sign-In *.

1. Active la autenticación multifactor (MFA) para el usuario raíz.

   Para obtener instrucciones, consulte [Habilitar un dispositivo MFA virtual para el usuario Cuenta de AWS raíz (consola)](https://docs.aws.amazon.com/IAM/latest/UserGuide/enable-virt-mfa-for-root.html) en la Guía del usuario de *IAM*.

**Creación de un usuario con acceso administrativo**

1. Activar IAM Identity Center.

   Consulte las instrucciones en [Activar AWS IAM Identity Center](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-set-up-for-idc.html) en la *Guía del usuario de AWS IAM Identity Center *.

1. En IAM Identity Center, conceda acceso administrativo a un usuario.

   Para ver un tutorial sobre su uso Directorio de IAM Identity Center como fuente de identidad, consulte [Configurar el acceso de los usuarios con la configuración predeterminada Directorio de IAM Identity Center en la](https://docs.aws.amazon.com//singlesignon/latest/userguide/quick-start-default-idc.html) Guía del *AWS IAM Identity Center usuario*.

**Inicio de sesión como usuario con acceso de administrador**
+ Para iniciar sesión con el usuario de IAM Identity Center, use la URL de inicio de sesión que se envió a la dirección de correo electrónico cuando creó el usuario de IAM Identity Center.

  Para obtener ayuda para iniciar sesión con un usuario del Centro de identidades de IAM, consulte [Iniciar sesión en el portal de AWS acceso](https://docs.aws.amazon.com/signin/latest/userguide/iam-id-center-sign-in-tutorial.html) en la *Guía del AWS Sign-In usuario*.

**Concesión de acceso a usuarios adicionales**

1. En IAM Identity Center, cree un conjunto de permisos que siga la práctica recomendada de aplicar permisos de privilegios mínimos.

   Para conocer las instrucciones, consulte [Create a permission set](https://docs.aws.amazon.com//singlesignon/latest/userguide/get-started-create-a-permission-set.html) en la *Guía del usuario de AWS IAM Identity Center *.

1. Asigne usuarios a un grupo y, a continuación, asigne el acceso de inicio de sesión único al grupo.

   Para conocer las instrucciones, consulte [Add groups](https://docs.aws.amazon.com//singlesignon/latest/userguide/addgroups.html) en la *Guía del usuario de AWS IAM Identity Center *.

## Ya tengo una cuenta AWS
<a name="existing-user"></a>

**Conceder acceso a Amazon Location Service**

De forma predeterminada, los usuarios que no son administradores no tienen permisos. Antes de que puedan acceder a Amazon Location, debe conceder el permiso adjuntando una política de IAM con permisos específicos. Asegúrese de seguir el principio de privilegios mínimos al conceder acceso a los recursos. 

**nota**  
Para obtener información sobre cómo dar acceso a los usuarios no autenticados a la funcionalidad de Amazon Location Service (por ejemplo, en una aplicación basada en la web), consulte [Autenticación con Amazon Location Service](access.md).

El siguiente ejemplo de política otorga a un usuario permiso para acceder a todas las operaciones de Amazon Location. Para obtener más ejemplos, consulte [Ejemplos de políticas basadas en identidad para Amazon Location Service](security-iam.md#security_iam_id-based-policy-examples).

```
{
  "Version": "2012-10-17",		 	 	 
  "Statement": [
    {
      "Action": [
        "geo:*",
        "geo-maps:*",
        "geo-places:*",
        "geo-routes:*"
      ],
      "Resource": "*",
      "Effect": "Allow"
    }
  ]
}
```

Para dar acceso, agregue permisos a los usuarios, grupos o roles:
+ Usuarios y grupos en AWS IAM Identity Center:

  Cree un conjunto de permisos. Siga las instrucciones de [Creación de un conjunto de permisos](https://docs.aws.amazon.com//singlesignon/latest/userguide/howtocreatepermissionset.html) en la *Guía del usuario de AWS IAM Identity Center *.
+ Usuarios gestionados en IAM a través de un proveedor de identidades:

  Cree un rol para la federación de identidades. Siga las instrucciones descritas en [Creación de un rol para un proveedor de identidad de terceros (federación)](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-idp.html) en la *Guía del usuario de IAM*.
+ Usuarios de IAM:
  + Cree un rol que el usuario pueda aceptar. Siga las instrucciones descritas en [Creación de un rol para un usuario de IAM](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_roles_create_for-user.html) en la *Guía del usuario de IAM*.
  + (No recomendado) Adjunte una política directamente a un usuario o agregue un usuario a un grupo de usuarios. Siga las instrucciones descritas en [Adición de permisos a un usuario (consola)](https://docs.aws.amazon.com//IAM/latest/UserGuide/id_users_change-permissions.html#users_change_permissions-add-console) de la *Guía del usuario de IAM*.

Al crear aplicaciones que utilizan Amazon Location Service, es posible que necesite que algunos usuarios tengan acceso no autenticado. Para ver estos casos de uso, consulte [Habilitar el acceso no autenticado mediante Amazon Cognito](authenticating-using-cognito.md).

# Uso de la consola de Amazon Location Service para autenticación
<a name="set-up-auth"></a>

**nota**  
Para obtener más información acerca de la autenticación, consulte [Autenticación con Amazon Location Service](access.md).

Para utilizar Amazon Location Service, el usuario debe tener acceso a los recursos y las API que componen Amazon Location. De forma predeterminada, las API de Amazon Location requieren autenticación para su uso. Puede utilizar las claves de Amazon Cognito o de las API para proporcionar autenticación y autorización a los usuarios anónimos. 

En el tutorial de [Creación de la primera aplicación de mapas y lugares de Amazon Location](first-app.md), la aplicación tiene un uso anónimo, lo que significa que los usuarios no están obligados a iniciar sesión. En este tutorial, se crean las API para usarlas en la aplicación de ejemplo.

Siga los procedimientos que se indican a continuación para crear su primera clave de API.

1. En la [https://console.aws.amazon.com/location](https://console.aws.amazon.com/location) y elija las **claves de API** en el menú de la izquierda.

1. En la página **Claves de API**, elija **Crear clave de API**.

1. En la página **Crear clave de API**, rellene la siguiente información:
   + **Nombre**: un nombre para su clave de API, por ejemplo `MyHelloWorldApp`.
   + **Descripción**: una descripción opcional para su clave de API.
   + **Acciones**: especifique las acciones que desea autorizar con esta clave de API. Debe seleccionar al menos **geo-maps:Get\$1** y **geo-places:Search\$1**.
   + **Hora de caducidad**: si lo desea, añada una fecha y una hora de caducidad para su clave de API. Para obtener más información, consulte [Prácticas recomendadas de clave de la API](using-apikeys.md#api-keys-best-practices).
   + **Restricciones de los clientes**: si lo desea, agregue uno o más dominios web o una o más aplicaciones de Android o Apple en las que pueda usar la clave de la API. Por ejemplo, si la clave de la API es para permitir que una aplicación se ejecute en el sitio web `example.com`, puede poner `*.example.com/` como referente permitido.
   + **Etiquetas**: si lo desea, añada etiquetas a la clave de API.
**importante**  
Recomendamos proteger el uso de la clave de la API estableciendo una fecha de caducidad o un referente, ambos a ser posible.

1. Seleccione **Crear clave de API** para crear la clave de API.

1. En la página de detalles de la clave de API, puede ver información sobre la clave de API que ha creado. 

   Elija **Mostrar clave de API** y copie el valor de la clave para usarla más adelante en el tutorial de [Creación de la primera aplicación de mapas y lugares de Amazon Location](first-app.md). El valor de la clave tendrá el formato `v1.public.a1b2c3d4...`. 

# Elección de la API correcta
<a name="choose-an-api"></a>

Este tema lo ayuda a elegir una API de Amazon Location Service en función de los casos de uso habituales que puede que quiera resolver con datos y servicios basados en la ubicación. 

Mapas  
Los mapas proporcionan acceso a tipos de mapas dinámicos y estáticos para una variedad de aplicaciones. Para obtener más información, consulte [Amazon Location Service Maps](maps.md).  
+ **Mapas dinámicos**: mapas interactivos que se pueden personalizar en tiempo real, lo que permite a los usuarios desplazar, hacer zoom y superponer datos. Para obtener más información, consulte [Mapas dinámicos](dynamic-maps.md).
+ **Mapas estáticos**: imágenes estáticas de mapas que muestran ubicaciones o rutas específicas sin elementos interactivos, adecuadas para aplicaciones con interactividad limitada. Para obtener más información, consulte [Mapas estáticos](static-maps.md).

Rutas  
Las rutas ofrecen la posibilidad de calcular rutas optimizadas entre ubicaciones. Estas características son compatibles con las aplicaciones que requieren planificación logística, cálculos de distancia y optimización de rutas. Los usuarios también pueden vincular los puntos de ubicación a las carreteras para mejorar la precisión. Para obtener más información, consulte[Amazon Location Service Routes](routes.md).  
+ **CalculateIsolines**: Genera isolíneas en función del tiempo o la distancia de viaje, útiles para definir áreas de servicio o zonas de accesibilidad. Para obtener más información, consulte. [Cálculo de isolíneas](calculate-isolines.md)
+ **CalculateRouteMatrix**: Proporciona una matriz de distancias y tiempos de viaje entre varios orígenes y destinos, lo que facilita la logística y la planificación de viajes. Para obtener más información, consulte[Cálculo de matriz de rutas](calculate-route-matrix.md).
+ **CalculateRoutes**: Calcula las rutas optimizadas para point-to-point la navegación con varias paradas, incluidas las preferencias de ruta personalizables. Para obtener más información, consulte[Cálculo de las rutas](calculate-routes.md).
+ **OptimizeWaypoints**: Optimiza el orden de los puntos de referencia para la ruta de viaje más eficiente, minimizando la distancia o el tiempo. Para obtener más información, consulte. [Optimización de paradas](actions-optimize-waypoints.md)
+ **SnapToRoads**: Alinea las coordenadas con las rutas de carretera más cercanas, lo que mejora la precisión del GPS al alinear los puntos con las carreteras conocidas. Para obtener más información, consulte. [Ajustar a carreteras](snap-to-roads.md)

Lugares  
Los sitios permiten a las aplicaciones buscar, encontrar y recuperar detalles sobre puntos de interés, direcciones y ubicaciones específicas. Estas capacidades mejoran los servicios basados en la ubicación al proporcionar contexto y mejorar la experiencia del usuario en las funciones de búsqueda. Para obtener más información, consulte[Amazon Location Service Places](places.md).   
+ **Geocodificación**: convierte direcciones o nombres de lugares en coordenadas geográficas (longitud, latitud), lo que admite aplicaciones que requieren una address-to-location transformación para la cartografía y el análisis espacial. Para obtener más información, consulte [Geocodificación](geocode.md).
+ **Geocodificación inversa**: convierte las coordenadas geográficas en la dirección o el nombre del lugar más cercanos, lo que proporciona el contexto de una ubicación. Para obtener más información, consulte [Geocodificación inversa](reverse-geocode.md).
+ **Autocompletar**: sugiere posibles opciones para completar el texto ingresado por el usuario, lo que mejora la eficacia de la entrada de datos de búsqueda. Para obtener más información, consulte[Autocompletar](autocomplete.md).
+ **GetPlace**: Recupera información detallada sobre un lugar específico, incluidos atributos como la dirección, los detalles de contacto y el horario de apertura. Para obtener más información, consulte[GetPlace](get-place.md).
+ **SearchNearby**: busca lugares dentro de un radio específico de un punto geográfico determinado, lo que permite realizar búsquedas «cerca de mí». Para obtener más información, consulte[Búsqueda de sitios cercanos](search-nearby.md).
+ **SearchText**: Permite la búsqueda basada en texto de lugares o puntos de interés a partir de una palabra clave o frase, lo que resulta ideal para buscar lugares por nombre o descripción. Para obtener más información, consulte. [Buscar texto](search-text.md)
+ **Sugerencia**: proporciona sugerencias de términos de búsqueda a medida que los usuarios escriben, lo que mejora la relevancia de la búsqueda y la experiencia del usuario. Para obtener más información, consulte [Sugerencia](suggest.md).

Geocercas  
El geocercado permite a las aplicaciones definir los límites geográficos y supervisar los eventos de entrada o salida dentro de estas regiones. Las características incluyen creación, actualización y eliminación de geocercas, así como la configuración de notificaciones o desencadenadores para acciones basadas en la ubicación cuando los dispositivos rastreados cruzan los límites de la geocerca. Ideal para las notificaciones basadas en la proximidad, la supervisión de la seguridad y el seguimiento de activos dentro de áreas predefinidas. Para obtener más información, consulte [Geocercas de Amazon Location Service](geofences.md).

Rastreadores  
El rastreo permite supervisar en tiempo real la ubicación de los dispositivos o activos a lo largo del tiempo. Las características incluyen agregar dispositivos rastreados, actualizar sus datos de ubicación y recuperar datos de posición históricos. Los rastreadores son útiles para administrar flotas, monitorear al personal y garantizar la seguridad de activos valiosos al proporcionar datos de up-to-date ubicación y patrones de movimiento. Para obtener más información, consulte. [Rastreadores de Amazon Location Service](trackers.md)

# Creación de la primera aplicación de mapas y lugares de Amazon Location
<a name="first-app"></a>

En esta sección, creará su primera aplicación con mapas y lugares.

**Requisito previo:**

Si ya ha creado una clave de API en los pasos de [Uso de la consola de Amazon Location Service para autenticación](set-up-auth.md), comencemos. 

Si aún no ha creado una clave de API, siga [Uso de la consola de Amazon Location Service para autenticación](set-up-auth.md) antes de continuar con la creación de la aplicación. Si tiene alguna duda, consulte [Uso de claves de la API para autenticación](using-apikeys.md) y [Regiones admitidas de Amazon Location](location-regions.md) para obtener más información.

## Web
<a name="qs-web"></a>

Aquí tienes un step-by-step tutorial para crear una aplicación de mapas de Amazon Location Service con MapLibre GL JS. Esta guía le explicará cómo configurar el mapa, agregar opciones de estilo y habilitar la funcionalidad de búsqueda de lugares.

### Configuración de la página inicial
<a name="qs-initial-page"></a>

En esta sección, configuraremos la estructura inicial de páginas y carpetas.

#### Agregación de las bibliotecas y hojas de estilo necesarias
<a name="qs-initial-add-library"></a>

Cree un archivo `index.html`. Para renderizar el mapa, necesitas MapLibre GL JS y MapLibre GL Geocoder. Añadirá las hojas de estilo MapLibre y los scripts de Geocoder. JavaScript 

Copie y pegue el siguiente código en el archivo `index.html`.

```
<!DOCTYPE html>
<html lang="en">
<head>

    <title>Amazon Location Service - Getting Started with First Map App</title>
    <meta charset='utf-8'>
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <meta name="description" content="Interactive map application using Amazon Location Service">

    <!--Link to MapLibre CSS and JavaScript library for map rendering and visualization -->
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/maplibre-gl@5.x/dist/maplibre-gl.css" />
    <script src="https://cdn.jsdelivr.net/npm/maplibre-gl@5.x/dist/maplibre-gl.js"></script>
    
    <!--Link to MapLibre Geocoder CSS and JavaScript library for place search and geocoding -->
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@maplibre/maplibre-gl-geocoder@1.7.0/dist/maplibre-gl-geocoder.css" />
    <script src="https://cdn.jsdelivr.net/npm/@maplibre/maplibre-gl-geocoder@1.7.0/dist/maplibre-gl-geocoder.js"></script>
    
    <!--Link to amazon-location JavaScript librarie -->
    <script src="https://cdn.jsdelivr.net/npm/@aws/amazon-location-utilities-auth-helper@1"></script>
    <script src="https://cdn.jsdelivr.net/npm/@aws/amazon-location-client@1.2"></script>
    
    <!-- Link to the first Amazon Location Map App's CSS and JavaScript -->
    <script src="utils.js"></script>
    <link rel="stylesheet" href="style.css"/>
   

</head>
<body>
    <main> 
        
    </main>
    <script> 
        // Step 1: Setup API Key and AWS Region 
        // Step 2.1 Add maps to application
        // Step 2.2 initialize the map
        // Step 3: Add places features to application
        // Step 3.1: Get GeoPlaces instance. It will be used for addion search box and map click functionality
        // Step 3.2: Add search box to the map
        // Step 3.3.: Setup map click functionality
        // Add functions
    </script>
</body>
</html>
```

#### Creación del contenedor de mapas
<a name="qs-create-map-container"></a>

 En el elemento `<body>` del archivo HTML, cree un elemento `<div>` en su HTML para contener el mapa. Puede darle un estilo a esto `<div>` en su CSS para establecer las dimensiones que necesite para la aplicación. Debe descargar el archivo CSS,, `style.css` de nuestro repositorio. GitHub Esto le ayudará a centrarse en la lógica empresarial. 

 Guarde los archivos `style.css` y `index.html` en la misma carpeta. 

 Descarga el `style.css` archivo desde [GitHub](https://github.com/aws-geospatial/amazon-location-samples-js/blob/quick_start_sample_js/quick-start/style.css). 

```
<main role="main" aria-label="Map Container">
    <div id="map"></div>
</main>
```

#### Agregue la clave de API y los detalles de AWS la región
<a name="qs-create-add-key"></a>

Agrega la clave de API que creaste [Uso de claves de la API para autenticación](using-apikeys.md) a este archivo, junto con la AWS región en la que se creó la clave. 

```
<!DOCTYPE html>
<html lang="en">
.....
.....
<body>
    <main role="main" aria-label="Map Container">
        <div id="map"></div>
    </main>
    <script>
        // Step 1: Setup API Key and AWS Region 
        const API_KEY = "Your_API_Key";
        const AWS_REGION = "Region_where_you_created_API_Key";
        // Step 2: Add maps to application
            // Step 2.1 initialize the map
            // Step 2.2 Add navigation controls to the map
        // Step 3: Add places feature to application        
            // Step 3.1: Get GeoPlaces instance. It will be used for addion search box and map click functionality
            // Step 3.2: Add search box to the map
            // Step 3.3.: Setup map click functionality
    </script>
</body>
</html>
```

### Agregación de un mapa a la aplicación
<a name="qs-add-map"></a>

En esta sección, agregaremos las capacidades de mapas a la aplicación. Antes de empezar, los archivos deben estar en esta estructura de carpetas. 

 Si aún no lo ha hecho, descargue el `style.css` archivo desde [GitHub](https://github.com/aws-geospatial/amazon-location-samples-js/blob/quick_start_sample_js/quick-start/style.css). 

```
|---FirstApp [Folder]
|-------------- index.html [File]
|-------------- style.css [File]
```

#### Creación de una función para inicializar el mapa
<a name="qs-initialize-map-function"></a>

Para configurar el mapa, cree la siguiente función, `initializeMap(...)`, después de `//Add functions` de la línea.

Elija una ubicación central y un nivel de zoom iniciales. En este ejemplo, establecemos el centro del mapa en Vancouver, Canadá, con un nivel de zoom de 10. Agregue controles de navegación para facilitar el zoom.

```
/**
 * Initializes the map with the specified style and color scheme.
 */
function initializeMap(mapStyle = "Standard", colorScheme = "Dark") {
     const styleUrl = `https://maps.geo.${AWS_REGION}.amazonaws.com/v2/styles/${mapStyle}/descriptor?key=${API_KEY}&color-scheme=${colorScheme}`;
     const map = new maplibregl.Map({
         container: 'map',                 // The ID of the map container
         style: styleUrl,                  // The style URL for the map
         center: [-123.116226, 49.246292], // Starting center coordinates
         zoom: 10,                         // Initial zoom level
         validateStyle: false              // Disable style validation
     });
     return map;                           // Return the initialized map
}
```

#### Inicialización del mapa
<a name="qs-initialize-map"></a>

Llame a `initializeMap(...)` para inicializar el mapa. Otra opción, puede inicializarlo con el estilo y la combinación de colores que prefiera después de la función `initializeMap`. Para obtener más opciones de estilo, consulte [AWS estilos y características del mapa](map-styles.md).

```
// Step 1: Setup API Key and AWS Region 
const API_KEY = "Your_API_Key";
const AWS_REGION = "Region_where_you_created_API_Key";

// Step 2.1 Add maps to application
// Step 2.2 initialize the map
const map = initializeMap("Standard","Light");

// Step 3: Add places features to application
```

Abra `index.html` en un navegador para ver el mapa en acción.

#### Agregación de control de navegación
<a name="qs-add-navigation"></a>

Otra opción, puede agregar controles de navegación (zoom y rotación) al mapa. Esto debe hacerse después de llamar a `initializeMap(...)`.

```
// Step 2.1 initialize the map
const map = initializeMap("Standard","Light");

// Step 2.2 Add navigation controls to the map
map.addControl(new maplibregl.NavigationControl());

// Step 3: Add places features to application
```

#### Revisión del código del mapa
<a name="qs-add-final"></a>

¡Enhorabuena\$1 Su primera aplicación está lista para usar un mapa. Abra `index.html` en un navegador. Asegúrese de que `style.css` esté en la misma carpeta que `index.html`.

El HTML final debe tener un aspecto similar al siguiente:

```
<!DOCTYPE html>
<html lang="en">
<head>

   <title>Amazon Location Service - Getting Started with First Map App</title>
   <meta charset='utf-8'>
   <meta name="viewport" content="width=device-width, initial-scale=1">
   <meta name="description" content="Interactive map application using Amazon Location Service">

   <!-- Link to MapLibre CSS and JavaScript library for map rendering and visualization -->
   <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/maplibre-gl@5.x/dist/maplibre-gl.css" />
   <script src="https://cdn.jsdelivr.net/npm/maplibre-gl@5.x/dist/maplibre-gl.js"></script>
   
   <!-- Link to MapLibre Geocoder CSS and JavaScript library for place search and geocoding -->
   <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@maplibre/maplibre-gl-geocoder@1.7.0/dist/maplibre-gl-geocoder.css" />
   <script src="https://cdn.jsdelivr.net/npm/@maplibre/maplibre-gl-geocoder@1.7.0/dist/maplibre-gl-geocoder.js"></script>
   
   <!-- Link to amazon-location JavaScript library -->
   <script src="https://cdn.jsdelivr.net/npm/@aws/amazon-location-utilities-auth-helper@1"></script>
   <script src="https://cdn.jsdelivr.net/npm/@aws/amazon-location-client@1.2"></script>
   
   <!-- Link to the first Amazon Location Map App's CSS and JavaScript -->
   <script src="utils.js"></script>
   <link rel="stylesheet" href="style.css"/>
</head>

<body>
    <main role="main" aria-label="Map Container">
        <div id="map"></div>
    </main>
    <script>
        const API_KEY = "Your_API_Key";
        const AWS_REGION = "Region_where_you_created_API_Key";
        
        function initializeMap(mapStyle, colorScheme) {
            const styleUrl = `https://maps.geo.${AWS_REGION}.amazonaws.com/v2/styles/${mapStyle}/descriptor?key=${API_KEY}&color-scheme=${colorScheme}`;
        
            const map = new maplibregl.Map({
                container: 'map',                 // ID of the HTML element for the map
                style: styleUrl,                  // URL for the map style
                center: [-123.116226, 49.246292], // Initial map center [longitude, latitude]
                zoom: 10                          // Initial zoom level
            });
            map.addControl(new maplibregl.NavigationControl());    
            return map;
        }
        
        const map = initializeMap("Standard", "Light");
        
    </script>
</body>
</html>
```

### Agregación de lugares a la aplicación
<a name="qs-add-places"></a>

En esta sección, configuraremos cómo agregar capacidades de lugares a la aplicación. Descarga el JavaScript archivo desde GitHub, [https://github.com/aws-geospatial/amazon-location-samples-js/blob/quick_start_sample_js/quick-start/utils.js](https://github.com/aws-geospatial/amazon-location-samples-js/blob/quick_start_sample_js/quick-start/utils.js).

Antes de empezar, los archivos deben estar en esta estructura de carpetas:

```
|---FirstApp [Folder]
|-------------- index.html [File]
|-------------- style.css [File]
|-------------- utils.js [File]
```

#### Crear función para crear GeoPlaces
<a name="qs-create-geoplaces"></a>

Para agregar una funcionalidad de búsqueda, inicialice la clase de `GeoPlaces` con `AuthHelper` y `AmazonLocationClient`. Agregue la función `getGeoPlaces(map)` siguiente antes de la etiqueta `</script>` en `index.html`.

```
/**
 * Gets a GeoPlaces instance for Places operations.
 */
function getGeoPlaces(map) {
    const authHelper = amazonLocationClient.withAPIKey(API_KEY, AWS_REGION);                      // Authenticate using the API key and AWS region
    const locationClient = new amazonLocationClient.GeoPlacesClient(authHelper.getClientConfig()); // Create a GeoPlaces client
    const geoPlaces = new GeoPlaces(locationClient, map);                                          // Create GeoPlaces instance
    return geoPlaces;                                                                              // Return the GeoPlaces instance
}
```

#### Creación de una función para agregar un cuadro de búsqueda a la aplicación
<a name="qs-add-searchbox"></a>

Agregue las funciones `addSearchBox(map, geoPlaces)`, `renderPopup(feature)` y `createPopup(feature)` siguientes antes de la etiqueta `</script>` en `index.html` para completar la configuración de la funcionalidad de búsqueda.

```
/**
 * Adds search box to the map.
 */
function addSearchBox(map, geoPlaces) {
    const searchBox = new MaplibreGeocoder(geoPlaces, {
        maplibregl,
        showResultsWhileTyping: true,                    // Show results while typing
        debounceSearch: 300,                             // Debounce search requests
        limit: 30,                                       // Limit number of results
        popuprender: renderPopup,                        // Function to render popup
        reverseGeocode: true,                            // Enable reverse geocoding
        zoom: 14,                                        // Zoom level on result selection
        placeholder: "Search text or nearby (lat,long)"  // Placeholder text for search box.
    });
    
    // Add the search box to the map
    map.addControl(searchBox, 'top-left'); 

    // Event listener for when a search result is selected
    searchBox.on('result', async (event) => {
        const { id, result_type } = event.result;                     // Get result ID and type
        if (result_type === "Place") {                                // Check if the result is a place
            const placeResults = await geoPlaces.searchByPlaceId(id); // Fetch details for the selected place
            if (placeResults.features.length) {
                createPopup(placeResults.features[0]).addTo(map);     // Create and add popup for the place
            }
        }
    });
}

/**
 * Renders the popup content for a given feature.
 */
function renderPopup(feature) {
    return `
        <div class="popup-content">
            <span class="${feature.place_type.toLowerCase()} badge">${feature.place_type}</span><br>
            ${feature.place_name}
        </div>`;
}

/**
 * Creates a popup for a given feature and sets its position.
 */
function createPopup(feature) {
    return new maplibregl.Popup({ offset: 30 })      // Create a new popup
        .setLngLat(feature.geometry.coordinates)     // Set the popup position
        .setHTML(renderPopup(feature));              // Set the popup content
}
```

#### Agregación de un cuadro de búsqueda a la aplicación
<a name="qs-add-searchbox-to-application"></a>

Cree un objeto de `GeoPlaces` llamando a `getGeoPlaces(map)` como se define en la sección 3.1 y, a continuación, llame a `addSearchBox(map, geoPlaces)` para agregar el cuadro de búsqueda a la aplicación.

```
// Step 2: Add maps to application
// Step 2.1 initialize the map
const map = initializeMap("Standard","Light");
// Step 2.2 Add navigation controls to the map
map.addControl(new maplibregl.NavigationControl()); 

// Step 3: Add places feature to application        
// Step 3.1: Get GeoPlaces instance. It will be used for adding search box and map click functionality
const geoPlaces = getGeoPlaces(map);
// Step 3.2: Add search box to the map
addSearchBox(map, geoPlaces);
```

La búsqueda de lugares está lista para usarse. Abra `index.html` en un navegador para verlo en acción.

#### Agregue una función para mostrar una ventana emergente cuando el usuario haga clic en el mapa
<a name="qs-add-map-click-feature"></a>

Cree una función `addMapClick(map, geoPlaces)` para mostrar una ventana emergente cuando el usuario haga clic en el mapa. Agregue esta función justo antes de la etiqueta `</script>`.

```
/**
 * Sets up reverse geocoding on map click events.
 */
function addMapClick(map, geoPlaces) {
    map.on('click', async ({ lngLat }) => {                     // Listen for click events on the map
        const response = await geoPlaces.reverseGeocode({ query: [lngLat.lng, lngLat.lat], limit: 1, click: true }); // Perform reverse geocoding

        if (response.features.length) {                         // If there are results
            const clickMarker = new maplibregl.Marker({ color: "orange" }); // Create a marker
            const feature = response.features[0];               // Get the clicked feature
            const clickedPopup = createPopup(feature);          // Create popup for the clicked feature
            clickMarker.setLngLat(feature.geometry.coordinates) // Set marker position
                .setPopup(clickedPopup)                         // Attach popup to marker
                .addTo(map);                                    // Add marker to the map

            clickedPopup.on('close', () => clickMarker.remove()).addTo(map); // Remove marker when popup is closed
        }
    });
}
```

#### Función de llamada para agregar la característica de hacer clic en el mapa
<a name="qs-call-map-click-feature"></a>

Para habilitar la acción de hacer clic en el mapa, llame a `addMapClick(map, geoPlaces)` después de la línea que contiene `addSearchBox(map, geoPlaces)`.

```
// Step 3: Add places feature to application        
// Step 3.1: Get GeoPlaces instance. It will be used for adding search box and map click functionality
const geoPlaces = getGeoPlaces(map);
// Step 3.2: Add search box to the map
addSearchBox(map, geoPlaces);
// Step 3.3: Setup map click functionality
addMapClick(map, geoPlaces);
```

#### Revisión de la aplicación de mapas y lugares
<a name="qs-review-places"></a>

¡Enhorabuena\$1 La primera aplicación está lista para usar mapas y lugares. Abra `index.html` en un navegador. Asegúrese de que `style.css` y `utils.js` estén en la misma carpeta que `index.html`. 

El HTML final debe tener un aspecto similar al siguiente:

```
<!DOCTYPE html>
<html lang="en">
<head>

   <title>Amazon Location Service - Getting Started with First Map App</title>
    <meta charset='utf-8'>
    <meta name="viewport" content="width=device-width, initial-scale=1">
    <meta name="description" content="Interactive map application using Amazon Location Service">

    <!--Link to MapLibre CSS and JavaScript library for map rendering and visualization -->
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/maplibre-gl@5.x/dist/maplibre-gl.css" />
    <script src="https://cdn.jsdelivr.net/npm/maplibre-gl@5.x/dist/maplibre-gl.js"></script>
    
    <!--Link to MapLibre Geocoder CSS and JavaScript library for place search and geocoding -->
    <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/@maplibre/maplibre-gl-geocoder@1.7.0/dist/maplibre-gl-geocoder.css" />
    <script src="https://cdn.jsdelivr.net/npm/@maplibre/maplibre-gl-geocoder@1.7.0/dist/maplibre-gl-geocoder.js"></script>
    
    <!--Link to amazon-location JavaScript librarie -->
    <script src="https://cdn.jsdelivr.net/npm/@aws/amazon-location-utilities-auth-helper@1"></script>
    <script src="https://cdn.jsdelivr.net/npm/@aws/amazon-location-client@1.2"></script>
    
    <!-- Link to the first Amazon Location Map App's CSS and JavaScript -->
    <script src="utils.js"></script>
    <link rel="stylesheet" href="style.css"/>
   

</head>
<body>
    <main role="main" aria-label="Map Container">
        <div id="map"></div>
    </main>
    <script>
        // Step 1: Setup API Key and AWS Region
        const API_KEY = "Your_API_Key";
        const AWS_REGION = "Region_where_you_created_API_Key";
        
        
        // Step 2: Add maps to application
        // Step 2.1 initialize the map
        const map = initializeMap("Standard","Light");
        // Step 2.2 Add navigation controls to the map
        map.addControl(new maplibregl.NavigationControl()); 

        // Step 3: Add places feature to application        
        // Step 3.1: Get GeoPlaces instance. It will be used for addion search box and map click functionality
        const geoPlaces =  getGeoPlaces(map);
        // Step 3.2: Add search box to the map
        addSearchBox(map, geoPlaces);
        // Step 3.3.: Setup map click functionality
        addMapClick(map, geoPlaces); 
                
 

        /**
         * Functions to add maps and places feature.
         */
         
         /**
         * Initializes the map with the specified style and color scheme.
         */ 
        function initializeMap(mapStyle = "Standard", colorScheme = "Dark") {
            const styleUrl = `https://maps.geo.${AWS_REGION}.amazonaws.com/v2/styles/${mapStyle}/descriptor?key=${API_KEY}&color-scheme=${colorScheme}`;
            const map = new maplibregl.Map({
                container: 'map',                   // The ID of the map container
                style: styleUrl,                    // The style URL for the map
                center: [-123.116226, 49.246292],   // Starting center coordinates
                zoom: 10,                           // Initial zoom level
                validateStyle: false                // Disable style validation
            });
            return map;                             // Return the initialized map
        }
        
        /**
         * Gets a GeoPlaces instance for Places operations.
         */
        function getGeoPlaces(map) {
            const authHelper =  amazonLocationClient.withAPIKey(API_KEY, AWS_REGION);                      // Authenticate using the API key and AWS region
            const locationClient = new amazonLocationClient.GeoPlacesClient(authHelper.getClientConfig()); // Create a GeoPlaces client
            const geoPlaces = new GeoPlaces(locationClient, map);                                          // Create GeoPlaces instance
                return geoPlaces;                                                                          // Return the GeoPlaces instance
        }
        
         /**
         * Adds search box to the map.
         */
        
        function addSearchBox(map, geoPlaces) {
            const searchBox = new MaplibreGeocoder(geoPlaces, {
                maplibregl,
                showResultsWhileTyping: true,                    // Show results while typing
                debounceSearch: 300,                             // Debounce search requests
                limit: 30,                                       // Limit number of results
                popuprender: renderPopup,                        // Function to render popup
                reverseGeocode: true,                            // Enable reverse geocoding
                zoom: 14,                                        // Zoom level on result selection
                placeholder: "Search text or nearby (lat,long)"  // Place holder text for search box.  
            });
            
            // Add the search box to the map
            map.addControl(searchBox, 'top-left'); 

            // Event listener for when a search result is selected
            searchBox.on('result', async (event) => {
                const { id, result_type } = event.result;                     // Get result ID and type
                if (result_type === "Place") {                                // Check if the result is a place
                    const placeResults = await geoPlaces.searchByPlaceId(id); // Fetch details for the selected place
                    if (placeResults.features.length) {
                        createPopup(placeResults.features[0]).addTo(map);     // Create and add popup for the place
                    }
                }
            });
        }

        /**
         * Renders the popup content for a given feature.
         */
        function renderPopup(feature) {
            return `
                <div class="popup-content">
                    <span class="${feature.place_type.toLowerCase()} badge">${feature.place_type}</span><br>
                    ${feature.place_name}
                </div>`;
        }

        /**
         * Creates a popup for a given feature and sets its position.
         */
        function createPopup(feature) {
            return new maplibregl.Popup({ offset: 30 })      // Create a new popup
                .setLngLat(feature.geometry.coordinates)     // Set the popup position
                .setHTML(renderPopup(feature));              // Set the popup content
        }
        
        /**
         * Sets up reverse geocoding on map click events.
         */
        function addMapClick(map, geoPlaces) {
            map.on('click', async ({ lngLat }) => {                     // Listen for click events on the map
                const response = await geoPlaces.reverseGeocode({ query: [lngLat.lng, lngLat.lat], limit: 1, click:true }); // Perform reverse geocoding

                if (response.features.length) {                         // If there are results
                    const clickMarker = new maplibregl.Marker({ color: "orange" }); // Create a marker
                    const feature = response.features[0];               // Get the clicked feature
                    const clickedPopup = createPopup(feature);          // Create popup for the clicked feature
                    clickMarker.setLngLat(feature.geometry.coordinates) // Set marker position
                        .setPopup(clickedPopup)                         // Attach popup to marker
                        .addTo(map);                                    // Add marker to the map

                    clickedPopup.on('close', () => clickMarker.remove()).addTo(map); // Remove marker when popup is closed
                }
            });
        }
        
    </script>
</body>
</html>
```

### Explorar más
<a name="qs-whats-next"></a>

Ha completado el tutorial de inicio rápido y debería entender, más o menos, cómo se utiliza Amazon Location Service para crear aplicaciones. Para sacar más provecho de Amazon Location, puede consultar los siguientes recursos:
+ **Detalles de las sugerencias de consulta**: considere la posibilidad de ampliar la clase de `GeoPlaces` o utilizar un enfoque similar a `ReverseGeocode` para obtener más detalles sobre los resultados devueltos por la API de `Suggestion`. 
+ **Elija la API adecuada para las necesidades de su empresa**: para determinar la mejor API de Amazon Location para sus necesidades, consulte este recurso: [Elección de la API correcta](choose-an-api.md). 
+ **Consulte las guías de aprendizaje de Amazon Location**: consulte la [guía para desarrolladores de Amazon Location Service](https://docs.aws.amazon.com/location/) para ver tutoriales y más recursos. 
+ **Documentación e información del producto**: para obtener la documentación completa, consulta la [Guía para desarrolladores de Amazon Location Service](https://docs.aws.amazon.com/location/). Para obtener más información sobre el producto, vaya a la página del [producto de Amazon Location Service](https://aws.amazon.com/location). 

# Creación de la primera aplicación de geocercas y rastreadores
<a name="first-geofence-app"></a>

En esta sección, creará una aplicación que muestre las características clave del uso de geocercas y rastreadores de Amazon Location. Las aplicaciones demuestran cómo interactúan un rastreador y una geocerca mediante una combinación de funciones de Lambda AWS IoT y Amazon Location. Elija la plataforma iOS o Android para empezar. 

Antes de empezar a crear la aplicación, siga los procedimientos descritos en [Uso de la consola de Amazon Location Service para autenticación](set-up-auth.md) para conceder el acceso adecuado.

**Topics**
+ [Creación de una aplicación de iOS](ios-geofence-app.md)
+ [Cree una aplicación Android](android-geofence-app.md)

# Creación de una aplicación de iOS
<a name="ios-geofence-app"></a>

Siga estos procedimientos para crear una aplicación de iOS mediante Amazon Location Service.

Clona los archivos del proyecto desde [GitHub](https://github.com/aws-geospatial/amazon-location-samples-ios/tree/main/tracking-with-geofence-notifications).

## Creación de recursos de Amazon Location para su aplicación
<a name="qs-ios-tracking-resources"></a>

Puedes generar recursos de Amazon Location Service una vez que tu AWS cuenta esté lista. Estos recursos serán esenciales para ejecutar los fragmentos de código proporcionados.

**nota**  
Si aún no has creado una AWS cuenta, [crea una AWS cuenta](https://portal.aws.amazon.com/billing/signup#/start/email).

Para empezar, tendrá que crear un ID de grupo de identidades de Amazon Cognito mediante el siguiente procedimiento:

1. En la AWS consola, navegue hasta el servicio Amazon Cognito y, a continuación, seleccione **Grupos de identidades** en el menú de la izquierda y seleccione **Crear grupo de identidades**. 

1. Asegúrese de que está marcado el **Acceso de invitados** y pulse **Siguiente** para continuar.

1. A continuación, cree un nuevo rol de IAM o use uno existente.

1. Ingrese un nombre de grupo de identidades y asegúrese de que el grupo de identidades tiene acceso a los recursos de Amazon Location `(geo)` para el mapa y el rastreador que va a crear en el siguiente procedimiento.

1. 

Ahora necesitas crear un mapa y darle estilo a él en la consola de AWS Amazon Location, usa el siguiente procedimiento:

1. Vaya a la [sección de mapas](https://console.aws.amazon.com/location/maps/home) de la consola de Amazon Location y seleccione **Crear mapa** para previsualizar estilos de mapas disponibles.

1. Asigne un **Nombre** y una **Descripción** al nuevo recurso de mapa. Registre el nombre que asigne al recurso del mapa, ya que se usará más adelante en el tutorial.

1. Al elegir un estilo de mapa, tenga en cuenta el proveedor de datos del mapa. Consulte la sección 82 de los [Términos de servicio de AWS](https://aws.amazon.com/service-terms) para obtener más detalles.

1.  Acepte los [términos y condiciones de Amazon Location](https://aws.amazon.com/service-terms/#:~:text=82.%20Amazon%20Location%20Service) y, a continuación, seleccione **Crear mapa**. Una vez creado el mapa, puede interactuar con él acercándolo, alejándolo o desplazándose en cualquier dirección.

Para crear un rastreador mediante la consola de Amazon Location

1.  Abra la consola de [Amazon Location Service](https://console.aws.amazon.com/location/).

1.  En el panel de navegación izquierdo, elija **Rastreadores**.

1.  Seleccione **Crear rastreador**.

1.  Rellene todos los campos obligatorios:

1.  En **Filtrado de posición**, elija la opción que mejor se adapte a la forma en que piensa utilizar el recurso de rastreo. Si no configura el filtrado de posición, la configuración predeterminada es TimeBased. Para obtener más información, consulta Trackers en esta guía y PositionFiltering en la referencia de la API de rastreadores de Amazon Location Service.

1.  Seleccione **Crear rastreador** para terminar.

## Creación de una recopilación de geocercas
<a name="qs-ios-tracking-geofence"></a>

Al crear una recopilación de geocercas, puede usar la consola, la API o la CLI. Los siguientes procedimientos le guiarán por cada opción.

Crear una colección de geovallas mediante la consola de Amazon Location:

1.  Abre la consola de Amazon Location Service en https://console.aws.amazon.com/location/.

1.  En el panel de navegación izquierdo, elija Recopilaciones de geocercas.

1.  Seleccione Crear colección de geocercas.

1.  Escriba un nombre y una descripción para la colección.

1.  En el EventBridge caso de una regla con CloudWatch como objetivo, puede crear una EventBridge regla opcional para empezar a reaccionar ante los eventos de la geocerca. Esto permite a Amazon Location publicar eventos en Amazon CloudWatch Logs.

1.  Seleccione Crear colección de geocercas.

Crea una colección de geovallas utilizando la ubicación de Amazon: APIs

Usa la CreateGeofenceCollection operación desde Amazon Location Geofences APIs. En el siguiente ejemplo, se utiliza una solicitud de API para crear una colección de geovallas llamada `GOECOLLECTION_NAME`.

```
POST /geofencing/v0/collections
Content-type: application/json
    {
        "CollectionName": "GOECOLLECTION_NAME",
        "Description": "Geofence collection 1 for shopping center",
        "Tags": { 
            "Tag1" : "Value1"
                }
    }
```

Cree una colección de geovallas mediante los siguientes comandos: AWS CLI 

Utilice el comando create-geofence-collection. En el siguiente ejemplo, se utiliza una AWS CLI para crear una recopilación de geocercas llamada `GOECOLLECTION_NAME`.

```
aws location \ create-geofence-collection \
    --collection-name "GOECOLLECTION_NAME" \
    --description "Shopping center geofence collection" \
    --tags Tag1=Value1                 
```

## Vincular un rastreador a una colección de geocercas
<a name="qs-ios-tracking-link-geofence"></a>

Para vincular un rastreador a una colección de geovallas, puede usar la consola, la API o la CLI. Los siguientes procedimientos le guiarán por cada opción.

Vincular un recurso de rastreo a una colección de geovallas mediante la consola de Amazon Location Service:

1. Abra la consola de Amazon Location.

1. En el panel de navegación izquierdo, elija **Rastreadores**.

1. En **Rastreadores de dispositivos**, seleccione el enlace con el nombre del rastreador objetivo.

1. En **Colecciones de geocercas vinculadas**, elija **Vincular colección de geocercas**.

1. En la ventana **Colección de geocercas vinculadas**, seleccione una colección de geocercas en el menú desplegable.

1. Elija **Vincular**.

1. Tras vincular el recurso de rastreador, se le asignará el estado Activo.

Vincule un recurso de rastreo a una colección de geovallas mediante la ubicación de Amazon: APIs

Usa la `` AsssociateTrackerConsumer operación de Amazon Location Trackers. APIs En el siguiente ejemplo, se utiliza una solicitud de API que se ExampleTracker asocia a una colección de geovallas mediante su nombre de recurso de Amazon (ARN).

```
POST /tracking/v0/trackers/ExampleTracker/consumers
Content-type: application/json
        {
           "ConsumerArn": "arn:aws:geo:us-west-2:123456789012:geofence-collection/GOECOLLECTION_NAME"
        }
```

Enlace un recurso de rastreo a una recopilación de geocercas mediante comandos de la AWS CLI :

Utilice el comando `associate-tracker-consumer `. En el siguiente ejemplo, se utiliza una AWS CLI para crear una colección de geocercas llamada. `GOECOLLECTION_NAME`

```
aws location \
associate-tracker-consumer \
    --consumer-arn "arn:aws:geo:us-west-2:123456789012:geofence-collection/GOECOLLECTION_NAME" \
    --tracker-name "ExampleTracker"
```

## Uso de AWS Lambda con MQTT
<a name="qs-ios-tracking-lambda"></a>

Cree una función de Lambda:

Para crear una conexión entre Amazon Location Service AWS IoT Core y Amazon, necesitas una AWS Lambda función que procese los mensajes reenviados por EventBridge CloudWatch los eventos. Esta función extraerá todos los datos posicionales, los formateará para Amazon Location Service y los enviará a través de la API de Amazon Location Tracker. Puede crear esta función a través de la AWS Lambda consola, o puede usar AWS Command Line Interface (AWS CLI) o AWS Lambda APIs. Para crear una función de Lambda que publique actualizaciones de posición en Amazon Location mediante la consola:

1.  Abra la AWS Lambda consola en https://console.aws.amazon.com/lambda/.

1. En el panel de navegación izquierdo, elija Funciones.

1. Elija Crear función y asegúrese de que esté seleccionada la opción Autor desde cero.

1. Complete las casillas siguientes:
   + un nombre de función
   + para la opción de **Tiempo de ejecución**, elija Node.js 16.x.

1. Seleccione Creación de función.

1. Elija la pestaña Código para abrir el editor.

1. Sobrescriba el código del marcador de posición en index.js con lo siguiente:

   ```
   const AWS = require('aws-sdk')
   const iot = new AWS.Iot();
   exports.handler =  function(event) {
                 console.log("event===>>>", JSON.stringify(event));
                 var param = {
                   endpointType: "iot:Data-ATS"
                 };
                 iot.describeEndpoint(param, function(err, data) {
                   if (err) {
                     console.log("error===>>>", err, err.stack); // an error occurred
                   } else {
                     var endp = data['endpointAddress'];
                     const iotdata = new AWS.IotData({endpoint: endp});    
                     const trackerEvent = event["detail"]["EventType"];
                     const src = event["source"];
                     const time = event["time"];
                     const gfId = event["detail"]["GeofenceId"];
                     const resources = event["resources"][0];  
                     const splitResources = resources.split(".");  
                     const geofenceCollection = splitResources[splitResources.length - 1];
                     const coordinates = event["detail"]["Position"];                               
                     const deviceId = event["detail"]["DeviceId"]; 
                     console.log("deviceId===>>>", deviceId);
                     const msg =  {
                         "trackerEventType" : trackerEvent,
                         "source" : src,
                         "eventTime" : time,
                         "geofenceId" : gfId,
                         "coordinates": coordinates, 
                         "geofenceCollection": geofenceCollection
                       };
                     const params = {
                       topic: `${deviceId}/tracker`,
                       payload: JSON.stringify(msg),
                       qos: 0
                     };
                     iotdata.publish(params, function(err, data) {
                         if (err) {
                           console.log("error===>>>", err, err.stack); // an error occurred
                         } else {
                           console.log("Ladmbda triggered===>>>", trackerEvent);  // successful response 
                         }
                     }); 
                   }
                 });
               }
   ```

1. Seleccione Implementar para almacenar la función actualizada.

1. Elija la pestaña Configuración.

1. En la sección Desencadenadores, haga clic en Agregar desencadenador.

1. Seleccione EventBridge (CloudWatch Eventos) en el campo Fuente.

1. Seleccione la opción de radio “Reglas existentes”.

1. Introduzca el nombre de la regla de esta manera: `AmazonLocationMonitor-GEOFENCECOLLECTION\$1NAME`.

1. Haga clic en el botón Agregar.

1. Esto también adjuntará las “Instrucciones de políticas basadas en recursos” en la pestaña de permisos

Cliente de prueba de MQTT

1. Abra la [https://console.aws.amazon.com/iot/](https://console.aws.amazon.com/iot/).

1. En el panel de navegación izquierdo, elija el cliente de pruebas de MQTT.

1. Verá una sección titulada **Cliente de prueba MQTT** en la que puede configurar su conexión MQTT.

1. Después de configurar los ajustes necesarios, haga clic en el botón **Conectar** para establecer una conexión con el intermediario MQTT utilizando los parámetros proporcionados.

1. Anote el valor del punto de conexión.

Una vez conectado, puede suscribirse a los temas de MQTT o publicar mensajes sobre los temas con los campos de entrada correspondientes que se proporcionan en la interfaz del cliente de pruebas de MQTT. A continuación, adjuntará la política de MQTT:

1.  En el menú de la izquierda, en **Administrar**, expanda la opción **Seguridad** y haga clic en **Políticas**.

1. Haga clic en el botón **Crear política**.

1. Escriba un nombre para la política.

1. En el **documento de política**, seleccione la pestaña **JSON**.

1. Copie y pegue la política que se muestra a continuación, pero asegúrese de actualizar todos los elementos con su `REGION` y `ACCOUNT_ID`:

   ```
   {
       "Version": "2012-10-17",		 	 	 
       "Statement": [
                   {
                     "Action": [
                       "iot:Connect",
                       "iot:Publish",
                       "iot:Subscribe",
                       "iot:Receive"
                     ],
                     "Resource": [
                       "arn:aws:iot:REGION:ACCOUNT_ID:client/${cognito-identity.amazonaws.com:sub}",
                       "arn:aws:iot:REGION:ACCOUNT_ID:topic/${cognito-identity.amazonaws.com:sub}",
                       "arn:aws:iot:REGION:ACCOUNT_ID:topicfilter/${cognito-identity.amazonaws.com:sub}/",
                       "arn:aws:iot:REGION:ACCOUNT_ID:topic/${cognito-identity.amazonaws.com:sub}/tracker"
                      ],
                      "Effect": "Allow"
                    }
                  ]
   }
   ```

1. Seleccione el botón **Crear** para terminar.

## Configuración de un código de aplicación de ejemplo
<a name="qs-ios-tracking-setup-sample"></a>

Para configurar el código de ejemplo debe tener instaladas las siguientes herramientas:
+ Git
+ XCode 15.3 o posterior
+ Simulador de iOS 16 o posterior

Utilice este procedimiento para configurar el código de aplicación de ejemplo:

1. Clona el repositorio de git desde esta URL: [https://github.com/aws-geospatial/amazon-location-samples-ios/tree/main/tracking- with-geofence-notifications](https://github.com/aws-geospatial/amazon-location-samples-ios/tree/main/tracking-with-geofence-notifications).

1. Abra el archivo de proyecto `AWSLocationSampleApp.xcodeproj`.

1. Espere a que finalice el proceso de resolución del paquete.

1. **Opcional**: en el menú de navegación del proyecto, cambie el nombre de `ConfigTemplate.xcconfig` a `Config.xcconfig` y rellene los siguientes valores:

   ```
   IDENTITY_POOL_ID = `YOUR_IDENTITY_POOL_ID`
   MAP_NAME = `YOUR_MAP_NAME`
   TRACKER_NAME = `YOUR_TRACKER_NAME`
   WEBSOCKET_URL = `YOUR_MQTT_TEST_CLIENT_ENDPOINT`
   GEOFENCE_ARN = `YOUR_GEOFENCE_COLLECTION_NAME`
   ```

## Uso de la aplicación de ejemplo
<a name="qs-ios-tracking-usage"></a>

Tras configurar el código de ejemplo, ahora puede ejecutar la aplicación en un simulador de iOS o en un dispositivo físico.

1. Cree y ejecute la aplicación.

1. La aplicación le pedirá permisos de ubicación y notificación. Debe permitirlos.

1. Pulse el botón “Configuración de Cognito”.

1. Si no ha rellenado los valores del archivo “Config.xcconfig”, tendrá que rellenar el campo con los valores de los recursos que creó anteriormente en la pantalla de configuración.

   ```
   IDENTITY_POOL_ID = `YOUR_IDENTITY_POOL_ID`
   MAP_NAME = `YOUR_MAP_NAME`
   TRACKER_NAME = `YOUR_TRACKER_NAME`
   WEBSOCKET_URL = `YOUR_MQTT_TEST_CLIENT_ENDPOINT`
   GEOFENCE_ARN = `YOUR_GEOFENCE_COLLECTION_NAME`
   ```

1. Guardado de la configuración

1. Ahora puede ver las opciones de filtro para ver el tiempo, la distancia y la precisión. Úselos según los necesite.

1. Vaya a la pestaña “Rastreo” de la aplicación y verá el mapa y el botón “Iniciar rastreo”.

1. Si ha instalado la aplicación en un simulador, es posible que desee simular los cambios de ubicación. Esto se puede hacer en Características -> Opción del menú de ubicación. Por ejemplo, seleccione Características -> Ubicación -> Freeway Drive.

1. Pulse el botón “Iniciar rastreo”. Debería ver los puntos de rastreo en el mapa.

1. La aplicación también rastrea las ubicaciones en segundo plano. Por lo tanto, cuando mueva la aplicación en segundo plano, le pedirá permiso para continuar rastreando en segundo plano.

1. Puede detener el rastreo pulsando el botón “Detener rastreo”.

# Cree una aplicación Android
<a name="android-geofence-app"></a>

Siga estos procedimientos para crear una aplicación de iOS mediante Amazon Location Service.

Clona los archivos del proyecto desde [GitHub](https://github.com/aws-geospatial/amazon-location-samples-android/tree/main/tracking-with-geofence-notifications).

## Creación de recursos de Amazon Location para su aplicación
<a name="qs-android-tracking-resources"></a>

Puedes generar recursos de Amazon Location Service una vez que tu AWS cuenta esté lista. Estos recursos serán esenciales para ejecutar los fragmentos de código proporcionados.

**nota**  
Si aún no has creado una AWS cuenta, [crea una AWS cuenta](https://portal.aws.amazon.com/billing/signup#/start/email).

Para empezar, tendrá que crear un ID de grupo de identidades de Amazon Cognito mediante el siguiente procedimiento:

1. En la AWS consola, navegue hasta el servicio Amazon Cognito y, a continuación, seleccione **Grupos de identidades** en el menú de la izquierda y seleccione **Crear grupo de identidades**. 

1. Asegúrese de que está marcado el **Acceso de invitados** y pulse **Siguiente** para continuar.

1. A continuación, cree un nuevo rol de IAM o use uno existente.

1. Ingrese un nombre de grupo de identidades y asegúrese de que el grupo de identidades tiene acceso a los recursos de Amazon Location `(geo)` para el mapa y el rastreador que va a crear en el siguiente procedimiento.

1. 

Ahora necesitas crear un mapa y darle estilo a él en la consola de AWS Amazon Location, usa el siguiente procedimiento:

1. Vaya a la [sección de mapas](https://console.aws.amazon.com/location/maps/home) de la consola de Amazon Location y seleccione **Crear mapa** para previsualizar estilos de mapas disponibles.

1. Asigne un **Nombre** y una **Descripción** al nuevo recurso de mapa. Registre el nombre que asigne al recurso del mapa, ya que se usará más adelante en el tutorial.

1. Al elegir un estilo de mapa, tenga en cuenta el proveedor de datos del mapa. Consulte la sección 82 de los [Términos de servicio de AWS](https://aws.amazon.com/service-terms) para obtener más detalles.

1. Acepte los [términos y condiciones de Amazon Location](https://aws.amazon.com/service-terms/#:~:text=82.%20Amazon%20Location%20Service) y, a continuación, seleccione **Crear mapa**. Una vez creado el mapa, puede interactuar con él acercándolo, alejándolo o desplazándose en cualquier dirección.

Para crear un rastreador mediante la consola de Amazon Location

1.  Abra la consola de [Amazon Location Service](https://console.aws.amazon.com/location/).

1. En el panel de navegación izquierdo, elija **Rastreadores**.

1. Seleccione **Crear rastreador**.

1. Rellene todos los campos obligatorios:

1. En **Filtrado de posición**, elija la opción que mejor se adapte a la forma en que piensa utilizar el recurso de rastreo. Si no establece el filtrado de posición, la configuración predeterminada es TimeBased. Para obtener más información, consulta Trackers en esta guía y PositionFiltering en la referencia de la API de rastreadores de Amazon Location Service.

1. Seleccione **Crear rastreador** para terminar.

## Creación de una recopilación de geocercas
<a name="qs-android-tracking-geofence"></a>

Al crear una recopilación de geocercas, puede usar la consola, la API o la CLI. Los siguientes procedimientos le guiarán por cada opción.

Crear una colección de geovallas mediante la consola de Amazon Location:

1. Abre la consola de Amazon Location Service en https://console.aws.amazon.com/location/.

1. En el panel de navegación izquierdo, elija Recopilaciones de geocercas.

1. Seleccione Crear colección de geocercas.

1. Escriba un nombre y una descripción para la colección.

1. Si la EventBridge regla tiene CloudWatch como objetivo, puede crear una EventBridge regla opcional para empezar a reaccionar ante los eventos de la geocerca. Esto permite a Amazon Location publicar eventos en Amazon CloudWatch Logs.

1. Seleccione Crear colección de geocercas.

Crea una colección de geovallas utilizando la ubicación de Amazon: APIs

Usa la CreateGeofenceCollection operación desde Amazon Location Geofences APIs. En el siguiente ejemplo, se utiliza una solicitud de API para crear una colección de geovallas llamada `GOECOLLECTION_NAME`.

```
POST /geofencing/v0/collections
Content-type: application/json
    {
    "CollectionName": "GOECOLLECTION_NAME",
    "Description": "Geofence collection 1 for shopping center",
    "Tags": { 
        "Tag1" : "Value1"
            }
    }
```

Cree una colección de geovallas mediante los siguientes comandos: AWS CLI 

Utilice el comando create-geofence-collection. En el siguiente ejemplo, se utiliza una AWS CLI para crear una recopilación de geocercas llamada `GOECOLLECTION_NAME`.

```
aws location \ create-geofence-collection \
    --collection-name "GOECOLLECTION_NAME" \
    --description "Shopping center geofence collection" \
    --tags Tag1=Value1               
```

## Vincular un rastreador a una colección de geocercas
<a name="qs-android-tracking-link-geofence"></a>

Para vincular un rastreador a una colección de geovallas, puede usar la consola, la API o la CLI. Los siguientes procedimientos le guiarán por cada opción.

Vincular un recurso de rastreo a una colección de geovallas mediante la consola de Amazon Location Service:

1. Abra la consola de Amazon Location.

1. En el panel de navegación izquierdo, elija **Rastreadores**.

1. En **Rastreadores de dispositivos**, seleccione el enlace con el nombre del rastreador objetivo.

1. En **Colecciones de geocercas vinculadas**, elija **Vincular colección de geocercas**.

1. En la ventana **Colección de geocercas vinculadas**, seleccione una colección de geocercas en el menú desplegable.

1. Elija **Vincular**.

1. Tras vincular el recurso de rastreador, se le asignará el estado Activo.

Vincule un recurso de rastreo a una colección de geovallas mediante la ubicación de Amazon: APIs

Usa la `` AsssociateTrackerConsumer operación de Amazon Location Trackers. APIs En el siguiente ejemplo, se utiliza una solicitud de API que se ExampleTracker asocia a una colección de geovallas mediante su nombre de recurso de Amazon (ARN).

```
POST /tracking/v0/trackers/ExampleTracker/consumers
Content-type: application/json
    {
    "ConsumerArn": "arn:aws:geo:us-west-2:123456789012:geofence-collection/GOECOLLECTION_NAME"
    }
```

Enlace un recurso de rastreo a una recopilación de geocercas mediante comandos de la AWS CLI :

Utilice el comando `associate-tracker-consumer `. En el siguiente ejemplo, se utiliza una AWS CLI para crear una colección de geocercas llamada. `GOECOLLECTION_NAME`

```
aws location \
associate-tracker-consumer \
    --consumer-arn "arn:aws:geo:us-west-2:123456789012:geofence-collection/GOECOLLECTION_NAME" \
    --tracker-name "ExampleTracker"
```

## Uso de AWS Lambda con MQTT
<a name="qs-android-tracking-lambda"></a>

Cree una función de Lambda:

Para crear una conexión entre Amazon Location Service AWS IoT Core y Amazon, necesitas una AWS Lambda función que procese los mensajes reenviados por EventBridge CloudWatch los eventos. Esta función extraerá todos los datos posicionales, los formateará para Amazon Location Service y los enviará a través de la API de Amazon Location Tracker. Puede crear esta función a través de la AWS Lambda consola, o puede usar AWS Command Line Interface (AWS CLI) o AWS Lambda APIs. Para crear una función de Lambda que publique actualizaciones de posición en Amazon Location mediante la consola:

1.  Abra la AWS Lambda consola en https://console.aws.amazon.com/lambda/.

1. En el panel de navegación izquierdo, elija Funciones.

1. Elija Crear función y asegúrese de que esté seleccionada la opción Autor desde cero.

1. Complete las casillas siguientes:
   + un nombre de función
   + para la opción de **Tiempo de ejecución**, elija Node.js 16.x.

1. Seleccione Creación de función.

1. Elija la pestaña Código para abrir el editor.

1. Sobrescriba el código del marcador de posición en index.js con lo siguiente:

   ```
   const AWS = require('aws-sdk')
   const iot = new AWS.Iot();
   exports.handler =  function(event) {
       console.log("event===>>>", JSON.stringify(event));
       var param = {
           endpointType: "iot:Data-ATS"
           };
       iot.describeEndpoint(param, function(err, data) {
           if (err) {
               console.log("error===>>>", err, err.stack); // an error occurred
            } else {
                     var endp = data['endpointAddress'];
                     const iotdata = new AWS.IotData({endpoint: endp});    
                     const trackerEvent = event["detail"]["EventType"];
                     const src = event["source"];
                     const time = event["time"];
                     const gfId = event["detail"]["GeofenceId"];
                     const resources = event["resources"][0];  
                     const splitResources = resources.split(".");  
                     const geofenceCollection = splitResources[splitResources.length - 1];
                     const coordinates = event["detail"]["Position"];                               
                     const deviceId = event["detail"]["DeviceId"]; 
                     console.log("deviceId===>>>", deviceId);
                     const msg =  {
                         "trackerEventType" : trackerEvent,
                         "source" : src,
                         "eventTime" : time,
                         "geofenceId" : gfId,
                         "coordinates": coordinates, 
                         "geofenceCollection": geofenceCollection
                     };
       const params = {
           topic: `${deviceId}/tracker`,
           payload: JSON.stringify(msg),
           qos: 0
                };
       iotdata.publish(params, function(err, data) {
           if (err) {
               console.log("error===>>>", err, err.stack); // an error occurred
           } else {
               console.log("Ladmbda triggered===>>>", trackerEvent);  // successful response 
                  }
           }); 
          }
         });
        }
   ```

1. Seleccione Implementar para almacenar la función actualizada.

1. Elija la pestaña Configuración.

1. En la sección Desencadenadores, haga clic en Agregar desencadenador.

1. Seleccione EventBridge (CloudWatch Eventos) en el campo Fuente.

1. Seleccione la opción de radio “Reglas existentes”.

1. Introduzca el nombre de la regla de esta manera: `AmazonLocationMonitor-GEOFENCECOLLECTION\$1NAME`.

1. Haga clic en el botón Agregar.

1. Esto también adjuntará las “Instrucciones de políticas basadas en recursos” en la pestaña de permisos

Cliente de prueba de MQTT

1. Abra la [https://console.aws.amazon.com/iot/](https://console.aws.amazon.com/iot/).

1. En el panel de navegación izquierdo, elija el cliente de pruebas de MQTT.

1. Verá una sección titulada **Cliente de prueba MQTT** en la que puede configurar su conexión MQTT.

1. Después de configurar los ajustes necesarios, haga clic en el botón **Conectar** para establecer una conexión con el intermediario MQTT utilizando los parámetros proporcionados.

1. Anote el valor del punto de conexión.

Una vez conectado, puede suscribirse a los temas de MQTT o publicar mensajes sobre los temas con los campos de entrada correspondientes que se proporcionan en la interfaz del cliente de pruebas de MQTT. A continuación, adjuntará la política de MQTT:

1.  En el menú de la izquierda, en **Administrar**, expanda la opción **Seguridad** y haga clic en **Políticas**.

1. Haga clic en el botón **Crear política**.

1. Escriba un nombre para la política.

1. En el **documento de política**, seleccione la pestaña **JSON**.

1. Copie y pegue la política que se muestra a continuación, pero asegúrese de actualizar todos los elementos con su `REGION` y `ACCOUNT_ID`:

   ```
   {
    "Version": "2012-10-17",		 	 	 
    "Statement": [
                   {
                     "Action": [
                       "iot:Connect",
                       "iot:Publish",
                       "iot:Subscribe",
                       "iot:Receive"
                        ],
                     "Resource": [
                       "arn:aws:iot:REGION:ACCOUNT_ID:client/${cognito-identity.amazonaws.com:sub}",
                       "arn:aws:iot:REGION:ACCOUNT_ID:topic/${cognito-identity.amazonaws.com:sub}",
                       "arn:aws:iot:REGION:ACCOUNT_ID:topicfilter/${cognito-identity.amazonaws.com:sub}/",
                       "arn:aws:iot:REGION:ACCOUNT_ID:topic/${cognito-identity.amazonaws.com:sub}/tracker"
                       ],
                     "Effect": "Allow"
                   }
                 ]
   }
   ```
**nota**  
Registre el nombre de la política y el nombre del tema para usarlos en el procedimiento siguiente.

1. Seleccione el botón **Crear** para terminar.

Tras completar el procedimiento anterior, actualizará los permisos del rol de invitado como sigue:

1. Vaya a Amazon Cognito y abra su grupo de identidades. A continuación, vaya al acceso de usuario y seleccione el rol de invitado.

1. Haga clic en las políticas de permisos para habilitar la edición.

   ```
   {
       'Version': '2012-10-17		 	 	 ',
       'Statement': [
           {
               'Action': [
                   'geo:GetMap*',
                   'geo:BatchUpdateDevicePosition',
                   'geo:BatchEvaluateGeofences',
                   'iot:Subscribe',
                   'iot:Publish',
                   'iot:Connect',
                   'iot:Receive',
                   'iot:AttachPrincipalPolicy',
                   'iot:AttachPolicy',
                   'iot:DetachPrincipalPolicy',
                   'iot:DetachPolicy'
               ],
               'Resource': [
                   'arn:aws:geo:us-east-1:{USER_ID}:map/{MAP_NAME}',
                   'arn:aws:geo:us-east-1:{USER_ID}:tracker/{TRACKER_NAME}',
                   'arn:aws:geo:us-east-1:{USER_ID}:geofence-collection/{GEOFENCE_COLLECTION_NAME}',
                   'arn:aws:iot:us-east-1:{USER_ID}:client/${cognito-identity.amazonaws.com:sub}',
                   'arn:aws:iot:us-east-1:{USER_ID}:topic/${cognito-identity.amazonaws.com:sub}',
                   'arn:aws:iot:us-east-1:{USER_ID}:topicfilter/${cognito-identity.amazonaws.com:sub}/*',
                   'arn:aws:iot:us-east-1:{USER_ID}:topic/${cognito-identity.amazonaws.com:sub}/tracker'
               ],
               'Effect': 'Allow'
           },
           {
               'Condition': {
                   'StringEquals': {
                       'cognito-identity.amazonaws.com:sub': '${cognito-identity.amazonaws.com:sub}'
                   }
               },
               'Action': [
                   'iot:AttachPolicy',
                   'iot:DetachPolicy',
                   'iot:AttachPrincipalPolicy',
                   'iot:DetachPrincipalPolicy'
               ],
               'Resource': [
                   '*'
               ],
               'Effect': 'Allow'
           }
       ]
   }
   ```

1. Con los cambios de política anteriores, todos los AWS recursos necesarios ahora están configurados adecuadamente para la aplicación.

## Configuración de un código de aplicación de ejemplo
<a name="qs-android-tracking-sample-app-code"></a>



1. Abra Android Studio y seleccione **Nuevo** y, a continuación, **Proyectar desde el control de versiones**.

1. Vaya al menú **Archivo** en la esquina superior izquierda de Android Studio.

1. Seleccione “Nuevo” en el menú desplegable.

1. Elija “Proyectar desde el control de versiones”.

1. Ingrese la URL del repositorio En el cuadro de diálogo que aparece, busque el campo marcado como “URL”.

1. Copia y pega la siguiente URL de la aplicación de ejemplo en este campo: [https://github.com/aws-geospatial/amazon-location-samples-android.git](https://github.com/aws-geospatial/amazon-location-samples-android.git)

1. Decida el directorio en el que desee clonar el repositorio. Utilice el directorio predeterminado u opte por una ubicación personalizada.

1. Tras configurar la URL del repositorio y las preferencias del directorio, pulse el botón “Clonar”. Android Studio procederá a clonar el repositorio en la ubicación especificada.

1. Ahora ha clonado la aplicación en la máquina y puede empezar a usarla.

## Uso de la aplicación de ejemplo
<a name="qs-android-tracking-use"></a>

Para usar el ejemplo, siga estos procedimientos:
+ **Cree un `custom.properties`**:

  Para configurar el archivo `custom.properties`, siga estos pasos:

  1. Abra el editor de texto o IDE que desee.

  1. Cree un archivo nuevo.

  1. Guarde el archivo con el nombre `custom.properties`.

  1. Actualice `custom.properties` con el siguiente código de ejemplo y reemplace `MQTT_END_POINT`, `POLICY_NAME`, `GEOFENCE_COLLECTION_NAME` y `TOPIC_TRACKER` por los valores reales:

     ```
     MQTT_END_POINT=xxxxxxxxxxxxx-xxx.xxx.us-east-1.amazonaws.com
     POLICY_NAME=xxxxxxxxx
     GEOFENCE_COLLECTION_NAME=xxxxxxxxxxxxxxxxx
     TOPIC_TRACKER=xxxxxxxxxx
     ```

  1. Limpie y vuelva a crear el proyecto. Después de esto, puede ejecutar el proyecto.
+ **Iniciar sesión**:

  Para iniciar sesión en la aplicación, siga los pasos que se indican a continuación:

  1. Pulse el botón de **inicio de sesión**.

  1. Proporcione un **ID del grupo de identidades**, un **Nombre del rastreador** y un **Nombre del mapa**.

  1. Vuelva a pulsar el botón **Inicio de sesión** para terminar.
+ **Administrar filtros**:

  Abra la pantalla de configuración y realice lo siguiente:

  1. Cambia los filtros on/off mediante la interfaz de usuario del conmutador.

  1. Actualice los filtros de tiempo y distancia cuando sea necesario.
+ **Operaciones de rastreo**:

  Abra la pantalla de rastreo y realice lo siguiente:
  + Puede iniciar y detener el rastreo en primer plano, en segundo plano o en modo de ahorro de batería pulsando los botones correspondientes.