Eliminación de mapas espaciales dispersos

EasyAR proporciona dos métodos para gestionar datos de mapas espaciales que ya no son necesarios: eliminación permanente y desactivación temporal. Para garantizar la estabilidad del entorno de producción, se recomienda leer atentamente las siguientes instrucciones.

Eliminación mediante EasyAR Web

Inicie sesión en EasyAR Developer Center -> SpatialMap -> Seleccione la biblioteca de mapas correspondiente -> Haga clic en Manage para acceder a la interfaz de gestión de la biblioteca de mapas.
Haga clic para ingresar a la página de detalles del mapa espacial, luego haga clic en el botón Delete.

Guía de eliminación permanente

Prácticas recomendadas: desactivación temporal

En la mayoría de los escenarios comerciales, si no está seguro de si volverá a utilizar un mapa en el futuro, se recomienda usar desactivación en lugar de eliminación.

Características: Los mapas espaciales desactivados permanecen en la lista de la base de datos, pero no participan en el proceso de reconocimiento y localización. Sin embargo, consumen cuota de reconocimiento.
Método de desactivación: En la interfaz de gestión, marque el mapa, luego haga clic en Inactive.

Guía de desactivación

Desactivación por API: Mediante la llamada a la API de actualización de Spatial Map, establezca la propiedad status como inactive.

Eliminación mediante API

La API REST permite la limpieza automatizada de mapas espaciales dispersos.

Preparación

Antes de comenzar, lea la documentación de la API de eliminación de Spatial Map y prepare los siguientes recursos:

Spatial Map AppId
API Key / Secret o Token
Cloud URL
- Usuarios de China y Sudeste Asiático: https://armap-api.easyar.com
- Otros usuarios: https://armap-api-na1.easyar.com
MapId: ID único del mapa a eliminar. Si el MapId no existe, la API devolverá Http Status 404.

Reemplace los marcadores de posición con parámetros reales y ejecute el script curl

Your-Cloud-URL → URLs reales de API
Your-Token → Token de autorización de API Key real
Your-SpatialMap-AppId → Su appId
Your-todo-MapId → MapId pendiente de eliminación

curl -X DELETE "https://armap-api-<cn1|na1>.easyar.com/map/<Your-todo-MapId>?appId=<Your-SpatialMap-AppId>" \
  -H "Content-Type: application/json" \
  -H "Authorization: <Your-Token>"

Descargar ejemplos de código Java

Java Samples Download

Importar el proyecto mediante maven

Paso 1. Abrir el ejemplo de código RemoveMap.java

Paso 2. Modificar las variables globales, reemplazar con los parámetros de autenticación de tu manifiesto

SpatialMap AppId
API Key/API Secret
Cloud URL

RemoveMap.java

import okhttp3.*;
import org.json.JSONObject;
import java.io.IOException;
import java.util.Set;

public class RemoveMap {

    private static final String CLOUD_URL       = "https://armap-api-<cn1|na1>.easyar.com";
    private static final String SPATIALMAP_APPID= "--aquí está tu SpatialMap AppId--";
    private static final String API_KEY         = "--aquí está tu API Key--";
    private static final String API_SECRET      = "--aquí está tu API Secret--";
    private static final String MAPID           = "my_mapId";

    public String remove(Auth auth, String mapId) throws IOException {
        okhttp3.Request request = new okhttp3.Request.Builder()
                .url(auth.getCloudURL()+"/map/"+mapId+"?"+ Auth.toParam(
                        Auth.signParam(new JSONObject(), auth.getAppId(), auth.getApiKey(), auth.getApiSecret())
                ))
                .delete()
                .build();
        return new OkHttpClient.Builder().build().newCall(request).execute().body().string();
    }

    public static void main(String[] args) throws IOException{
        Auth accessInfo  =  new Auth(SPATIALMAP_APPID, API_KEY, API_SECRET, CLOUD_URL);
        System.out.println(new RemoveMap().remove(accessInfo, MAPID));
    }
}

Paso 3. Ejecutar Main

Paso 1. Copia el código de ejemplo en removemap.php

Modifica los parámetros de autenticación con tus recursos reales: Token, appId y Cloud URL
MapId del mapa a eliminar

<?php
class MapDeleteService {
    private $baseURL;
    private $token;
    private $appId;
    
    public function __construct($baseURL, $token, $appId) {
        $this->baseURL = $baseURL;
        $this->token = $token;
        $this->appId = $appId;
    }
    
    public function deleteMap($mapId) {
        // Construir parámetros de consulta
        $queryParams = [
            'appId' => $this->appId
        ];
        
        $queryString = http_build_query($queryParams);
        $url = $this->baseURL . '/map/' . urlencode($mapId) . '?' . $queryString;
        
        $ch = curl_init();
        curl_setopt_array($ch, [
            CURLOPT_URL => $url,
            CURLOPT_CUSTOMREQUEST => 'DELETE',
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_HTTPHEADER => [
                'Authorization: ' . $this->token,
                'Content-Type: application/json'
            ],
            CURLOPT_SSL_VERIFYPEER => false,
            CURLOPT_TIMEOUT => 30
        ]);
        
        echo "=== API Request ===" . PHP_EOL;
        echo "URL: " . $url . PHP_EOL;
        echo "Method: DELETE" . PHP_EOL;
        echo "Headers: Authorization: " . $this->token . PHP_EOL;
        echo "Query Params: " . json_encode($queryParams, JSON_PRETTY_PRINT) . PHP_EOL;
        
        $response = curl_exec($ch);
        $httpCode = curl_getinfo($ch, CURLINFO_HTTP_CODE);
        $error = curl_error($ch);
        
        curl_close($ch);
        
        echo "=== API Response ===" . PHP_EOL;
        echo "Status Code: " . $httpCode . PHP_EOL;
        echo "Timestamp: " . date('c') . PHP_EOL;
        
        if ($error) {
            echo "cURL Error: " . $error . PHP_EOL;
            return null;
        }
        
        $responseData = json_decode($response, true);
        echo "Response Data: " . json_encode($responseData, JSON_PRETTY_PRINT) . PHP_EOL;
        
        return $responseData;
    }
}


$mapId = 'your_map_id_here';
$config = [
    'baseURL' => 'https://armap-api-cn1.easyar.com',
    'token' => 'your_token_here',
    'appId' => 'your_app_id_here'
];

$mapDeleteService = new MapDeleteService($config['baseURL'], $config['token'], $config['appId']);

$result = $mapDeleteService->deleteMap($mapId);

if ($result) {
    echo PHP_EOL . "=== Solicitud de eliminación exitosa ===" . PHP_EOL;
    if (isset($result['statusCode']) && $result['statusCode'] == 200) {
        echo "Result: " . json_encode($result['result'], JSON_PRETTY_PRINT) . PHP_EOL;
    }
} else {
    echo PHP_EOL . "=== Failed ===" . PHP_EOL;
}
?>

Paso 2. Ejecutar

php removemap.php

Crear el archivo de código relacionado main.go, modificar las variables globales y luego ejecutar

go run main.go

main.go:

package main

import (
  "crypto/sha256"
  "fmt"
  "io"
  "net/http"
  "sort"
  "strconv"
  "time"
)

var (
  ApiKey    = "YOUR_API_KEY"
  ApiSecret = "YOUR_API_SECRET"
  AppId     = "YOUR_APP_ID"
  Host      = "https://armap-api-<cn1|na1>.easyar.com"
  MapId     = "YOUR_MAP_ID"
)

func main() {
  ts := strconv.FormatInt(time.Now().UnixNano()/1e6, 10)
  params := map[string]string{
    "apiKey":    ApiKey,
    "appId":     AppId,
    "timestamp": ts,
  }

  keys := []string{"apiKey", "appId", "timestamp"}
  sort.Strings(keys)

  builder := ""
  for _, k := range keys { builder += k + params[k] }
  builder += ApiSecret

  signature := fmt.Sprintf("%x", sha256.Sum256([]byte(builder)))

  url := fmt.Sprintf("%s/map/%s?apiKey=%s&appId=%s&timestamp=%s&signature=%s", 
    Host, MapId, ApiKey, AppId, ts, signature)
  
  req, _ := http.NewRequest("DELETE", url, nil)
  resp, _ := http.DefaultClient.Do(req)
  defer resp.Body.Close()
  
  body, _ := io.ReadAll(resp.Body)
  fmt.Printf("Response: %s\n", string(body))
}

En el archivo Cargo.toml, agrega las dependencias reqwest, tokio, sha2, hex.

Ejecuta cargo run.

use sha2::{Sha256, Digest};
use std::collections::BTreeMap;
use std::time::{SystemTime, UNIX_EPOCH};

const API_KEY: &str = "YOUR_API_KEY";
const API_SECRET: &str = "YOUR_API_SECRET";
const APP_ID: &str = "YOUR_APP_ID";
const HOST: &str = "https://armap-api-<cn1|na1>.easyar.com";
const MAP_ID: &str = "YOUR_MAP_ID";

#[tokio::main]
async fn main() -> Result<(), Box<dyn std::error::Error>> {
    let ts = SystemTime::now().duration_since(UNIX_EPOCH)?.as_millis().to_string();

    // 1. Componentes de la firma
    let mut params = BTreeMap::new();
    params.insert("apiKey", API_KEY);
    params.insert("appId", APP_ID);
    params.insert("timestamp", &ts);

    // 2. Concatenar claves y valores, luego añadir el secreto
    let mut sign_str = String::new();
    for (k, v) in &params {
        sign_str.push_str(k);
        sign_str.push_str(v);
    }
    sign_str.push_str(API_SECRET);
    
    let mut hasher = Sha256::new();
    hasher.update(sign_str.as_bytes());
    let signature = hex::encode(hasher.finalize());

    // 3. Construir URL y enviar DELETE
    let url = format!("{}/map/{}?apiKey={}&appId={}&timestamp={}&signature={}", 
                      HOST, MAP_ID, API_KEY, APP_ID, ts, signature);
    
    let res = reqwest::Client::new().delete(url).send().await?;
    println!("Respuesta: {}", res.text().await?);
    Ok(())
}

Crear un proyecto de consola .NET.

dotnet new console
dotnet run

using System;
using System.Collections.Generic;
using System.Linq;
using System.Security.Cryptography;
using System.Text;
using System.Net.Http;

class Program {
    static string API_KEY = "YOUR_API_KEY";
    static string API_SECRET = "YOUR_API_SECRET";
    static string APP_ID = "YOUR_APP_ID";
    static string HOST = "https://armap-api-<cn1|na1>.easyar.com";
    static string MAP_ID = "YOUR_MAP_ID";

    static async System.Threading.Tasks.Task Main() {
        string timestamp = DateTimeOffset.Now.ToUnixTimeMilliseconds().ToString();

        // 1. Ordenar parámetros
        var dict = new SortedDictionary<string, string> {
            { "apiKey", API_KEY },
            { "appId", APP_ID },
            { "timestamp", timestamp }
        };

        // 2. Concatenar y añadir Secret
        StringBuilder sb = new StringBuilder();
        foreach (var kv in dict) sb.Append(kv.Key).Append(kv.Value);
        sb.Append(API_SECRET);
        
        string signature = Sha256(sb.ToString());

        // 3. Ejecutar solicitud DELETE
        using var client = new HttpClient();
        string query = string.Join("&", dict.Select(x => $"{x.Key}={x.Value}")) + $"&signature={signature}";
        string url = $"{HOST}/map/{MAP_ID}?{query}";
        
        var response = await client.DeleteAsync(url);
        Console.WriteLine($"Resultado: {await response.Content.ReadAsStringAsync()}");
    }

    static string Sha256(string str) {
        byte[] bytes = SHA256.HashData(Encoding.UTF8.GetBytes(str));
        return BitConverter.ToString(bytes).Replace("-", "").ToLower();
    }
}

Entorno de ejecución
- Unity 2020 LTS o superior
- Scripting Backend: Mono o IL2CPP
- API Compatibility Level: .NET Standard 2.1 (recomendado)

Paso 1: preparar archivos de imagen

Crear directorio en el proyecto Unity:

Assets/
└── Scripts/
     └── DeleteMap.cs

Seguir el nombre del directorio Assets
- Copiar el código de ejemplo DeleteMap.cs a continuación

using System.Collections;
using UnityEngine;
using UnityEngine.Networking;

public class DeleteMap : MonoBehaviour
{
    [Header("Config")]
    public string mapId = "Your mapId";
    public string apiBaseUrl = "https://armap-api-<cn1|na1>.easyar.com";
    public string authorizationToken = "YOUR API KEY AUTH TOKEN"; 
    public string spatialMapAppId = "Your Spatial Map appId"; 
    
    private void Start()
    {
        StartCoroutine(DeleteAMap());
    }

    private IEnumerator DeleteAMap()
    {
     
        string url =
            $"{apiBaseUrl}/map/{mapId}?appId={spatialMapAppId}";

        UnityWebRequest request = UnityWebRequest.Delete(url);
        request.downloadHandler = new DownloadHandlerBuffer();

        request.SetRequestHeader("Content-Type", "application/json");
        request.SetRequestHeader("Authorization", authorizationToken);

        yield return request.SendWebRequest();

        if (request.result == UnityWebRequest.Result.Success)
        {
            Debug.Log("Delete map success:");
            Debug.Log(request.downloadHandler.text);
        }
        else
        {
            Debug.LogError("Delete map failed:");
            Debug.LogError(request.error);
            Debug.LogError(request.downloadHandler.text);
        }
    }
}

En Unity Editor:
- Crear un GameObject vacío
- Nombrarlo DeleteMap
- Arrastrar el script DeleteMap a este objeto

Paso 3: configurar parámetros (Inspector)

Modificar en el panel Inspector:
- Api Url
- Authorization Token
- Spatial Map App Id
- Map Id : mapId del mapa a eliminar
Solo modifique estos elementos para ejecutar, complete con los parámetros preparados

Paso 4: ejecutar

Haga clic en Play
Ver resultados en Console:
- Éxito: retorna JSON (incluye result)
- Fallo: información de error HTTP

Temas relacionados:

Table of Contents

Eliminación de mapas espaciales dispersos

Eliminación mediante EasyAR Web

Prácticas recomendadas: desactivación temporal

Eliminación mediante API

Preparación