Exclusão de mapas espaciais esparsos

O EasyAR oferece duas formas de lidar com dados de mapas espaciais que não são mais necessários: exclusão permanente e desativação temporária. Para garantir a estabilidade do ambiente de produção, recomendamos que você leia atentamente as instruções a seguir.

Exclusão via EasyAR Web

Faça login no EasyAR Developer Center -> SpatialMap -> selecione a biblioteca de mapas correspondente -> clique em Gerenciar para acessar a interface de gerenciamento da biblioteca de mapas.
Clique para entrar na página de detalhes do mapa espacial, clique no botão Excluir na página.

Guia de operação de exclusão permanente

Melhor prática: desativação temporária

Na maioria dos cenários comerciais, se você não tem certeza se usará um mapa novamente no futuro, recomenda-se usar desativar em vez de excluir.

Características: mapas espaciais desativados permanecem na lista do banco de dados, mas não participam do processo de reconhecimento e localização. No entanto, ocupam cota de reconhecimento.
Método de desativação: na interface de gerenciamento, marque o mapa de reconhecimento e clique em Desativar.

Guia de operação de desativação

Desativação via API: chamando a API de atualização de Spatial Map, defina o atributo status como inactive.

Exclusão via API

Através da REST API, é possível automatizar a limpeza de mapas espaciais esparsos.

Preparação

Antes de começar, leia a documentação da API de exclusão de Spatial Map e prepare os seguintes recursos:

Spatial Map AppId
API Key / Secret ou Token
Cloud URL
- Usuários da China e Sudeste Asiático: https://armap-api.easyar.com
- Outros usuários: https://armap-api-na1.easyar.com
MapId: ID único do mapa a ser excluído. Se o MapId não existir, a API retornará Http Status 404.

Substitua os marcadores por parâmetros reais e execute o script curl

Your-Cloud-URL → URLs reais da API
Your-Token → Token de autorização real da API Key
Your-SpatialMap-AppId → Seu appId
Your-todo-MapId → MapId pendente para exclusão

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>"

Baixe exemplos de código Java

Java Samples Download

Importe o projeto via Maven

Passo 1. Abra o código de exemplo RemoveMap.java

Passo 2. Modifique as variáveis globais, substituindo os parâmetros de autenticação da sua lista de preparação

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= "--aqui está o seu SpatialMap AppId--";
    private static final String API_KEY         = "--aqui está a sua API Key--";
    private static final String API_SECRET      = "--aqui está o seu 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));
    }
}

Passo 3. Execute o main

Step 1. Copie o código de exemplo para removemap.php

Modifique os parâmetros de autenticação para seus recursos reais: Token, appId e Cloud URL
O MapId do mapa a ser excluído

<?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) {
        // 构建查询参数
        $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 . "=== 删除请求成功 ===" . 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;
}
?>

Step 2. Execute

php removemap.php

Criar o arquivo de código relevante main.go, modificar as variáveis globais e, em seguida, executar

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))
}

Adicione as dependências reqwest, tokio, sha2, hex no Cargo.toml.

Execute 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. Signature components
    let mut params = BTreeMap::new();
    params.insert("apiKey", API_KEY);
    params.insert("appId", APP_ID);
    params.insert("timestamp", &ts);

    // 2. Concatenate keys and values, then append secret
    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. Construct URL and send 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!("Response: {}", res.text().await?);
    Ok(())
}

Criar um projeto de console .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 e anexar o 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. Executar a requisição 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();
    }
}

Ambiente de execução
- Unity 2020 LTS ou superior
- Scripting Backend: Mono ou IL2CPP
- Nível de Compatibilidade de API: .NET Standard 2.1 (recomendado)

Passo 1: Preparar arquivos

Criar diretório no projeto Unity:

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

Copiar o código de exemplo DeleteMap.cs abaixo para o diretório Assets/Scripts

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);
        }
    }
}

No Unity Editor:
- Criar um GameObject vazio
- Nomeá-lo como DeleteMap
- Arrastar o script DeleteMap para este objeto

Passo 3: Configurar parâmetros (Inspector)

Modificar no painel Inspector:
- Api Url
- Authorization Token
- Spatial Map App Id
- Map Id: mapId do mapa a ser excluído
Basta modificar estes itens e executar, preenchendo com os parâmetros preparados

Passo 4: Executar

Clicar em Play
Verificar o resultado no Console:
- Sucesso: Retorna JSON (contendo result)
- Falha: Mensagem de erro HTTP/detalhada

Tópicos relacionados:

Table of Contents

Exclusão de mapas espaciais esparsos

Exclusão via EasyAR Web

Melhor prática: desativação temporária

Exclusão via API

Preparação