# Guia de integração manual (9 linguagens, sem necessidade de IA) Este guia se aplica ao provedor Licentivo. Comerciantes com outro sistema de licenciamento podem selecionar um serviço personalizado em “Seleção de licenciamento e personalização”, seguir a [API de licenciamento personalizado e seu fluxo de integração](/pt/launch-documents/external-licensing/) e continuar usando o SDK do próprio sistema. > As alterações atuais ainda não publicadas usam troca de identidade de conta. Responsabilidades e restrições de migração estão em [Limites entre o período comprado e o SDK de conta](/pt/launch-documents/account-purchase-boundary/). Launch calcula o período comprado; o SDK Licentivo executa a autorização. Instale apenas o pacote de integração Launch da linguagem escolhida. Ele inclui o SDK oficial, o adaptador padrão e a configuração de vinculação; o endereço oficial de licenciamento é fixado em `https://www.licentivo.com`. O programa usa a conta que o comprador cadastrou na loja Launch atual. ## Obter o código de inicialização preenchido 1. Associe software, planos comerciais e políticas Licentivo na administração Launch e publique no ambiente correspondente. 2. Abra **Integração de aplicação → Verificação de integração e código** e escolha software, linguagem e ambiente de teste ou produção. 3. Clique em “Ler informações do produto e gerar código de integração”. Launch lê automaticamente o endereço público atual do site, os mapeamentos existentes e a chave pública de assinatura. 4. Copie a função de conexão da página para o projeto e implemente a interface e as chamadas de negócio descritas abaixo. Também é possível consultar os parâmetros preenchidos automaticamente e chamar diretamente o `Connect/connect` da linguagem escolhida. Não é necessário preencher manualmente os dois IDs internos de produto nem gerar `launch-config.json` ou `product.json`. A página permite salvar o código-fonte da função de conexão. O `config.yaml` privado do servidor serve apenas para iniciar Launch e não pode acompanhar o software do cliente. O endereço do site vem do endereço público válido da instância atual (`public_url` de inicialização ou o endereço válido nas configurações administrativas do site). Pode ser domínio ou IP com porta, mas precisa de protocolo; produção usa HTTPS válido. `http_addr`, o endereço de escuta, não é o endereço de acesso dos clientes. Após mudar endereço, mapeamento ou ambiente, obtenha novamente a função de conexão no site atual; sessões e caches do site antigo não autorizam o novo. Os dois números de produto são correspondências internas existentes: o produto de software Launch e o produto de licenciamento Licentivo. A página os preenche conforme o software escolhido; o comprador só informa sua conta na loja. O servidor lê a chave pública de assinatura pela conexão Licentivo configurada; a chave administrativa e as credenciais de licença do cliente não entram no código-fonte. ## A função de `Connect/connect` `Connect/connect` nomeia a criação do cliente de aplicação Launch nas diferentes linguagens. Go, C# e algumas interfaces nativas usam `Connect` com inicial maiúscula; Python, JavaScript, Ruby e outras seguem seu estilo com `connect`. As funções de projeto `connectLaunch()`, `connect_launch()` ou `LaunchConnection.Open()` geradas pela administração já contêm os parâmetros públicos e chamam internamente o ponto de entrada da linguagem. A conexão apenas inicializa: verifica endereço da loja, mapeamento de produto, ambiente e chave pública de assinatura, cria o cliente Launch e configura o SDK oficial Licentivo incluído. Não verifica a identidade do cliente nem libera diretamente funcionalidades pagas. A sequência completa é: ```text Connect/connect → Login or Restore → RunFeature → Logout / Close └──────────→ ReleaseDevice (explicit device unlink only) ``` Mantenha o mesmo objeto cliente enquanto o aplicativo estiver em execução, para o SDK gerenciar heartbeats e postos flutuantes corretamente. O fechamento normal conserva o vínculo do dispositivo; quando o cliente solicita explicitamente sair, a entrada compatível com ReleaseDevice usa o mesmo fluxo de logout do SDK oficial. ## Instalação e ponto de entrada de inicialização A verificação pública de instalação da versão 0.1.6 passou nas nove linguagens (9/9); todos os métodos da tabela abaixo foram verificados. O [GitHub Release](https://github.com/spf86/licentivo-launch-sdk/releases/tag/v0.1.6) também oferece pacotes nativos e arquivos offline; veja as [instruções de instalação do pacote baixado](/pt/launch-documents/integration-packages/#install-a-downloaded-distribution). | Linguagem | Instalar apenas Launch | Funções de conexão fornecidas pela página | API de inicialização direta do pacote | | --- | --- | --- | --- | | Go | `go get github.com/spf86/licentivo-launch-sdk/pkg/launchclient@v0.1.6` | `connectLaunch()` | `launchclient.Connect` | | Python 3.10+ | `python -m pip install licentivo-launch==0.1.6` | `connect_launch()` | `Application.connect` | | C# / .NET 8+ | `dotnet add package Licentivo.Launch --version 0.1.6` | `LaunchConnection.Open()` | `Application.Connect` | | Java 17+ | Maven/Gradle: `com.licentivo.launch:launch-client:0.1.6` | `LaunchConnection.open()` | `Launch.connect` | | Node.js 20.3+ | `npm install @licentivo/launch@0.1.6` | `connectLaunch()` | `Application.connect` | | Rust 1.85+ | `cargo add licentivo-launch@=0.1.6` | `connect_launch()` | `Application::connect` | | Ruby 3.1+ | `gem install licentivo-launch --version 0.1.6` | `connect_launch` | `Application.connect` | | C11 | Baixar o pacote nativo no [GitHub Release](https://github.com/spf86/licentivo-launch-sdk/releases/tag/v0.1.6) e importar pelo CMake | `connect_launch()` | `launch_application_connect` | | C++17 | Usar o mesmo pacote nativo Launch | `connectLaunch()` | `Application::Connect` | O código-fonte e os READMEs de cada linguagem estão no [repositório do SDK Launch](https://github.com/spf86/licentivo-launch-sdk); pacotes nativos e arquivos offline estão no [Release v0.1.6](https://github.com/spf86/licentivo-launch-sdk/releases/tag/v0.1.6); os resultados públicos de instalação estão na [verificação dos registros das nove linguagens](https://github.com/spf86/licentivo-launch-sdk/blob/main/docs/registry-verification.json). O README de cada pacote fornece comandos de instalação e APIs. O pacote JavaScript inclui declarações TypeScript. O gerenciador de pacotes resolve dependências comuns, como cryptography em Python, BouncyCastle em C# e base64 em Ruby; não é necessário instalar o pacote oficial do SDK. O módulo público Go chama-se `github.com/spf86/licentivo-launch-sdk` e usa o import `github.com/spf86/licentivo-launch-sdk/pkg/launchclient`; o aplicativo não precisa de replace local. O pacote nativo Windows usa amd64 GNU/MinGW; também há pacote nativo Linux amd64. A gem Ruby de plataforma e as distribuições Rust/nativas Windows incluem curl; compilar fontes em outras plataformas exige C11 e as dependências de desenvolvimento curl/OpenSSL usuais. Os detalhes da toolchain estão no README de cada pacote. ## Login e operações protegidas Os trechos abaixo usam a função de conexão copiada na etapa anterior. `email` e `password` vêm da sua interface de login; nunca grave senhas no código ou na configuração. Substitua `export` por uma funcionalidade realmente existente no plano do pacote. ### Go ```go app, err := connectLaunch() if err != nil { return err } defer app.Close() if _, err := app.Login(ctx, email, password); err != nil { return err } return app.RunFeature("export", func() error { return exportReport() }) ``` `ctx` usa o contexto de ciclo de vida do aplicativo; o fim da requisição de login não pode cancelar imediatamente os heartbeats. Execute operações de rede em uma thread de trabalho. Use `Restore(ctx)` para restaurar, `Logout(ctx)` para sair da conta e `ReleaseDevice(ctx)` para liberar o dispositivo. ### Python ```python with connect_launch() as app: app.login(email, password) result = app.run_feature("export", export_report) ``` `restore()` restaura uma sessão segura existente; sem sessão, mostre a tela de login. `logout()` limpa a conta e `release_device()` libera explicitamente o dispositivo. Operações síncronas de rede não devem bloquear o loop de eventos do desktop. ### C# / .NET ```csharp await using var app = LaunchConnection.Open(); await app.Login(email, password); await app.RunFeature("export", async () => { await ExportReport(); }); ``` Use `await Restore()`, `await Logout()` e `await ReleaseDevice()`. Mantenha o ciclo de vida do SDK enquanto o aplicativo executa e use fluxos de interface assíncronos. ### Java ```java try (var app = LaunchConnection.open()) { app.login(email, passwordChars); app.runFeature("export", () -> exportReport()); } ``` A senha usa `char[]`. Sem sessão, `restore()` retorna a falha `NO_SESSION` e deve mostrar a tela de login; outras falhas não autorizam o uso. `logout()` e `releaseDevice()` são operações diferentes. try-with-resources cuida do fechamento. ### JavaScript / Node.js / TypeScript ```javascript const app = connectLaunch(); try { await app.login(email, password); const result = await app.runFeature('export', () => exportReport()); } finally { await app.close(); } ``` `restore()` retorna `null` quando não existe sessão; só permita operações de negócio após uma restauração normal. O booleano de `logout()` informa se a saída remota foi confirmada; falhas de liberação do dispositivo devem mostrar erro. O código executa em Node.js, no processo principal do Electron ou em um backend confiável; navegador e renderizador Electron não guardam credenciais de autorização. ### Rust ```rust let mut app = connect_launch()?; app.login(&email, &password)?; let result = app.run_feature("export", || { export_report()?; Ok(()) })?; app.close(); ``` O callback retorna `Result`. `restore()`, `logout()` e `release_device()` retornam resultados cujas falhas devem ser tratadas. `Drop` também fecha o runtime. Por padrão, build.rs compila e vincula o núcleo nativo; você não precisa vincular o SDK oficial separadamente. ### Ruby ```ruby app = connect_launch begin app.login(email, password) result = app.run_feature('export') { export_report } ensure app.close end ``` `restore` restaura a sessão, `logout` sai da conta e `release_device` libera o dispositivo. Proteja as operações com um bloco de código; exceções não podem virar sucesso. ### C ```c static int export_action(void *context) { return export_report(context); /* Return 1 only on success. */ } launch_application *app = connect_launch(); if (!app) return 0; int ok = launch_application_login(app, email, password); if (ok) ok = launch_application_run_feature(app, "export", export_action, context); /* Check launch_application_error(app) on failure; never log credentials. */ launch_application_close(app); return ok; ``` `launch_application_restore` tem três estados: `1` restaurado, `0` sem sessão e `-1` falha. Só a ausência de sessão deve levar normalmente ao login; recusas e exceções não são sucesso. Verifique também os retornos de `logout` e `release_device`. O CMake importa apenas Launch: ```cmake find_package(LicentivoLaunch CONFIG REQUIRED) add_executable(myapp main.c) licentivo_launch_link(myapp) ``` ### C++ ```cpp auto app = connectLaunch(); app.Login(email.c_str(), password.c_str()); app.RunFeature("export", [&] { exportReport(); }); ``` `Restore()`, `Logout()` e `ReleaseDevice()` seguem a semântica de exceções C++. Os destruidores RAII cuidam do fechamento. CMake usa `licentivo_launch_link(myapp CXX)`; Launch resolve automaticamente a vinculação do SDK e as bibliotecas de execução do pacote. ## Ciclo de vida, armazenamento seguro e erros Criar o objeto de conexão apenas inicializa. O programa precisa entrar na conta ou restaurá-la com sucesso e usar callbacks protegidos em cada operação de negócio. Pedidos pagos, sessões existentes e botões clicáveis não substituem a verificação do SDK. Por padrão, sessões ficam apenas na memória. Lembrar o login exige armazenamento seguro: Go, Python, C# e C/C++ nativos oferecem DPAPI do usuário Windows atual; Java, Node, Rust e Ruby oferecem AES-GCM com chave do chamador. Aplicativos multiplataforma devem integrar o cofre de credenciais do sistema. Não coloque chave e texto cifrado no mesmo diretório comum. O fechamento normal preserva sessões que o usuário escolheu lembrar e encerra o runtime. Ao sair da conta, chame primeiro o logout unificado do SDK oficial e depois limpe os registros de conta do Launch. ReleaseDevice é uma entrada compatível do mesmo fluxo; não anuncie liberação concluída enquanto a revogação remota estiver pendente. Não apague o diretório de cache nem os registros de recuperação de saída do SDK oficial. Proteger sessões Launch não criptografa todos os arquivos de dispositivo do SDK; restrinja as permissões do diretório de cache. | Estado | Tratamento no aplicativo | | --- | --- | | Falha de conta ou senha | Mostrar falha de login genérica sem revelar se a conta existe | | EMAIL_VERIFICATION_REQUIRED | Orientar a conclusão da verificação do e-mail da loja | | ENTITLEMENT_PENDING | Mostrar sincronização e aguardar com as tentativas limitadas e o Retry-After definidos no pacote | | ENTITLEMENT_NOT_PURCHASED | Orientar a compra ou a troca de conta | | ENTITLEMENT_EXPIRED | Orientar a renovação; não contornar uma recusa com credenciais antigas | | ENTITLEMENT_SUSPENDED | Interromper funcionalidades protegidas e contatar o comerciante | | Limite de dispositivos atingido | Orientar a gestão ou a liberação explícita de dispositivos | | Rede/HTTP 5xx | Usar apenas licenças offline verificadas pelo SDK que ainda sejam válidas | 401/403/404 explícitos, conta divergente, cancelamento ou limitação de frequência não podem virar autorização offline bem-sucedida. A primeira ativação e as políticas que restringem o modo offline continuam exigindo conexão. Quando o domínio ou IP do servidor estiver inacessível, mostre o problema de conexão; não conecte silenciosamente a outros sites. ## Validação e referências Verifique login real, autorização da conta, operações protegidas, recuperação após reinício, uso offline válido e sua expiração, adulteração do cache, logout, troca de conta e liberação do dispositivo. Este guia não exige IA. Ferramentas de teste e limites da validação externa estão em [acceptance.md](/pt/launch-documents/acceptance/); pacotes locais e instruções de compilação estão em [integration-packages.md](/pt/launch-documents/integration-packages/). Verificação de configuração, geração de código e testes locais não provam automaticamente pagamento real, emissão de licença ou ativação pelo serviço oficial. Lojas externas e ambientes sandbox de pagamento precisam ser configurados e validados separadamente.