# Panduan integrasi pengembangan manual (9 bahasa, tanpa AI)

Panduan ini berlaku untuk penyedia Licentivo. Pedagang yang sudah memiliki sistem lisensi lain dapat memilih layanan kustom di ‘Pemilihan dan kustomisasi lisensi’ pada panel administrasi, mengintegrasikannya sesuai [API lisensi kustom dan alur integrasi](/id/launch-documents/external-licensing/), dan terus menggunakan SDK sistem lisensi sendiri.

> Perubahan yang saat ini belum dirilis menggunakan pertukaran identitas akun; tanggung jawab dan batasan migrasi dijelaskan dalam [Batas masa pembelian dan SDK akun](/id/launch-documents/account-purchase-boundary/). Launch menghitung masa pembelian; Licentivo SDK menjalankan lisensi.

Instal hanya paket integrasi Launch untuk bahasa yang sesuai. Paket Launch mencakup SDK resmi, adaptor default, dan konfigurasi tautan; alamat lisensi resmi ditetapkan ke `https://www.licentivo.com`. Aplikasi menggunakan akun pembeli yang terdaftar di toko Launch saat ini untuk masuk.

## Dapatkan kode inisialisasi yang sudah diisi

1. Di panel administrasi Launch, hubungkan perangkat lunak, paket penjualan, dan kebijakan lisensi Licentivo, lalu terbitkan di lingkungan yang sesuai.
2. Buka **Integrasi aplikasi → Pemeriksaan integrasi dan kode**, lalu pilih perangkat lunak, bahasa, dan lingkungan uji/produksi.
3. Klik ‘Baca informasi produk dan buat kode integrasi’. Launch otomatis membaca alamat publik situs saat ini, pemetaan produk yang ada, dan kunci publik tanda tangan.
4. Salin fungsi koneksi pada halaman ke proyek Anda, lalu tulis antarmuka dan panggilan bisnis secara manual sesuai petunjuk di bawah. Anda juga dapat meninjau parameter yang sudah diisi dan memanggil `Connect/connect` untuk bahasa terkait sendiri.

Tidak perlu mengisi dua ID produk internal secara manual atau membuat `launch-config.json` maupun `product.json`. Halaman dapat menyimpan fungsi koneksi kode sumber. `config.yaml` privat server hanya untuk menjalankan layanan Launch dan tidak boleh didistribusikan bersama perangkat lunak pelanggan.

Alamat situs berasal dari alamat publik yang valid untuk instance saat ini (`public_url` dalam konfigurasi startup, atau alamat publik valid dalam pengaturan situs di panel administrasi). Alamat dapat berupa domain atau alamat IP dengan port, tetapi harus menyertakan protokol; integrasi produksi menggunakan HTTPS yang valid. Alamat pendengar `http_addr` bukan alamat akses pelanggan. Setelah mengubah alamat situs, pemetaan produk, atau lingkungan, dapatkan kembali fungsi koneksi dari situs saat ini; sesi dan cache situs lama tidak boleh digunakan sebagai otorisasi situs baru.

Dua nomor produk merupakan hubungan internal yang sudah ada: produk perangkat lunak Launch dan produk lisensi Licentivo. Halaman integrasi mengisinya otomatis berdasarkan perangkat lunak yang dipilih; pembeli hanya memasukkan akun toko. Server membaca kunci publik tanda tangan menggunakan koneksi Licentivo yang telah dikonfigurasi; kunci administrasi dan kredensial lisensi pelanggan tidak masuk ke kode sumber.

## Fungsi `Connect/connect`

`Connect/connect` adalah nama dalam berbagai bahasa untuk operasi ‘membuat klien aplikasi Launch’. Go, C#, dan sebagian antarmuka native menggunakan `Connect` dengan huruf awal kapital; Python, JavaScript, Ruby, dan bahasa lain menggunakan `connect` sesuai gaya masing-masing. `connectLaunch()`, `connect_launch()`, atau `LaunchConnection.Open()` yang dibuat panel administrasi adalah fungsi proyek dengan parameter publik yang telah diisi; di dalamnya fungsi tersebut memanggil titik masuk bahasa yang sesuai.

Koneksi hanya melakukan inisialisasi: memvalidasi alamat toko, pemetaan produk, lingkungan, dan kunci publik tanda tangan, membuat klien Launch, serta mengonfigurasi Licentivo SDK resmi dalam paket. Koneksi tidak memverifikasi identitas pelanggan atau langsung membuka fitur berbayar. Urutan lengkapnya adalah:

```text
Connect/connect → Login or Restore → RunFeature → Logout / Close
                                       └──────────→ ReleaseDevice (explicit device unlink only)
```

Pertahankan objek klien yang sama selama aplikasi berjalan agar SDK menangani heartbeat dan kursi mengambang dengan benar. Penutupan biasa mempertahankan pengikatan perangkat; keluar secara eksplisit oleh pelanggan dan titik masuk kompatibilitas ReleaseDevice memanggil alur keluar SDK resmi yang sama.

## Instalasi dan titik masuk inisialisasi

Verifikasi instalasi publik untuk sembilan bahasa pada 0.1.6 semuanya lulus (9/9); semua metode instalasi pada tabel berikut telah diverifikasi. [GitHub Release](https://github.com/spf86/licentivo-launch-sdk/releases/tag/v0.1.6) juga menyediakan paket native dan file offline; lihat [Petunjuk instalasi paket unduhan](/id/launch-documents/integration-packages/#install-a-downloaded-distribution).

| Bahasa | Instal hanya Launch | Fungsi koneksi yang disediakan halaman | API inisialisasi langsung dalam paket |
| --- | --- | --- | --- |
| 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 | Unduh paket native dari [GitHub Release](https://github.com/spf86/licentivo-launch-sdk/releases/tag/v0.1.6), lalu impor dengan CMake | `connect_launch()` | `launch_application_connect` |
| C++17 | Gunakan paket native Launch yang sama | `connectLaunch()` | `Application::Connect` |

Kode sumber publik dan README setiap bahasa tersedia di [repositori Launch SDK](https://github.com/spf86/licentivo-launch-sdk), paket native dan file offline di [v0.1.6 Release](https://github.com/spf86/licentivo-launch-sdk/releases/tag/v0.1.6), dan hasil instalasi publik di [Verifikasi registry sembilan bahasa](https://github.com/spf86/licentivo-launch-sdk/blob/main/docs/registry-verification.json). README setiap paket menyediakan perintah instalasi dan API. Paket JavaScript mencakup deklarasi TypeScript. Dependensi bahasa biasa diselesaikan oleh manajer paket, misalnya cryptography untuk Python, BouncyCastle untuk C#, dan base64 untuk Ruby; paket SDK resmi tidak perlu diinstal.

Nama modul publik Go adalah `github.com/spf86/licentivo-launch-sdk`, dan path impor adalah `github.com/spf86/licentivo-launch-sdk/pkg/launchclient`; aplikasi tidak memerlukan replace lokal. Paket native Windows menggunakan amd64 GNU/MinGW, dan tersedia juga paket native Linux amd64. Paket platform Ruby serta distribusi Windows Rust/native menyertakan curl; build sumber pada platform lain memerlukan dependensi pengembangan C11 dan curl/OpenSSL biasa. Lihat README setiap paket untuk informasi toolchain platform.

## Login dan operasi yang dilindungi

Cuplikan berikut menggunakan fungsi koneksi yang disalin pada langkah sebelumnya. `email` dan `password` berasal dari antarmuka login Anda sendiri; jangan tulis kata sandi ke kode sumber atau konfigurasi. `export` harus diganti dengan nama fitur yang benar-benar ada dalam kebijakan paket.

### 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` menggunakan konteks siklus hidup aplikasi dan tidak boleh langsung dibatalkan saat permintaan login berakhir sehingga heartbeat berhenti. Jalankan operasi jaringan pada thread pekerja latar belakang. Panggil `Restore(ctx)` untuk memulihkan, `Logout(ctx)` untuk keluar akun, dan `ReleaseDevice(ctx)` untuk melepas perangkat.

### Python

```python
with connect_launch() as app:
    app.login(email, password)
    result = app.run_feature("export", export_report)
```

`restore()` memulihkan sesi aman yang ada; tampilkan antarmuka login jika tidak ada sesi. `logout()` membersihkan akun; `release_device()` secara eksplisit melepas perangkat. Jangan biarkan operasi jaringan sinkron memblokir event loop desktop.

### C# / .NET

```csharp
await using var app = LaunchConnection.Open();
await app.Login(email, password);
await app.RunFeature("export", async () => {
    await ExportReport();
});
```

Gunakan `await Restore()`, `await Logout()`, dan `await ReleaseDevice()`. Pertahankan siklus hidup SDK selama aplikasi berjalan dan gunakan alur antarmuka asinkron.

### Java

```java
try (var app = LaunchConnection.open()) {
    app.login(email, passwordChars);
    app.runFeature("export", () -> exportReport());
}
```

Gunakan `char[]` untuk kata sandi. `restore()` mengembalikan kegagalan `NO_SESSION` jika tidak ada sesi; tampilkan antarmuka login. Kegagalan lain tidak boleh dianggap sebagai otorisasi. `logout()` dan `releaseDevice()` adalah operasi yang berbeda. try-with-resources bertanggung jawab menutup sumber daya.

### 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()` mengembalikan `null` jika tidak ada sesi; operasi bisnis hanya boleh dijalankan setelah pemulihan berhasil. Nilai boolean `logout()` menunjukkan apakah keluar jarak jauh telah dikonfirmasi; tampilkan kesalahan jika pelepasan perangkat gagal. Kode berjalan di Node.js, proses utama Electron, atau backend tepercaya; browser dan proses renderer Electron tidak menyimpan kredensial lisensi.

### Rust

```rust
let mut app = connect_launch()?;
app.login(&email, &password)?;
let result = app.run_feature("export", || {
    export_report()?;
    Ok(())
})?;
app.close();
```

Callback mengembalikan `Result<T, Failure>`. `restore()`, `logout()`, dan `release_device()` mengembalikan hasil yang kegagalannya harus ditangani. `Drop` juga bertanggung jawab menutup runtime. Inti native default dikompilasi dan ditautkan oleh build.rs; Anda tidak perlu menautkan SDK resmi sendiri.

### Ruby

```ruby
app = connect_launch
begin
  app.login(email, password)
  result = app.run_feature('export') { export_report }
ensure
  app.close
end
```

`restore` memulihkan sesi, `logout` keluar dari akun, dan `release_device` melepas perangkat. Operasi yang dilindungi menggunakan blok kode; exception tidak boleh diubah menjadi keberhasilan.

### 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` memiliki tiga status: `1` dipulihkan, `0` tidak ada sesi, dan `-1` gagal. Hanya ketika tidak ada sesi antarmuka login ditampilkan secara normal; penolakan atau exception tidak boleh dianggap berhasil. Nilai balik `logout` dan `release_device` juga harus diperiksa.

CMake hanya mengimpor 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()`, dan `ReleaseDevice()` mengikuti semantik exception C++. Destruktor RAII bertanggung jawab menutup sumber daya. CMake menggunakan `licentivo_launch_link(myapp CXX)`; Launch otomatis menangani penautan SDK dan runtime dalam paket distribusi.

## Siklus hidup, penyimpanan aman, dan kesalahan

Membuat objek koneksi hanya menyelesaikan inisialisasi. Aplikasi harus berhasil login atau memulihkan sesi dan menggunakan callback perlindungan fitur pada setiap operasi bisnis. Pesanan berbayar, sesi yang ada, atau tombol yang dapat diklik tidak menggantikan verifikasi SDK.

Secara default sesi hanya disimpan dalam memori. Mengingat login memerlukan penyimpanan aman: Go, Python, C#, dan native C/C++ menyediakan DPAPI pengguna Windows saat ini; Java, Node, Rust, dan Ruby menyediakan penyimpanan AES-GCM menggunakan kunci pemanggil. Aplikasi lintas platform harus terhubung ke penyimpanan kredensial sistem. Jangan menaruh kunci dan ciphertext dalam direktori biasa yang sama.

Penutupan biasa mempertahankan sesi yang secara aktif dipilih pengguna untuk diingat dan menghentikan runtime. Keluar dari akun terlebih dahulu memanggil alur keluar terpadu SDK resmi, lalu membersihkan catatan akun milik Launch. ReleaseDevice adalah titik masuk kompatibilitas untuk alur yang sama; jangan melaporkan pelepasan berhasil ketika pencabutan jarak jauh masih menunggu penyelesaian. Jangan hapus direktori cache atau log pemulihan keluar SDK resmi. Perlindungan sesi Launch tidak berarti semua file perangkat SDK resmi sudah dienkripsi; batasi izin direktori cache.

| Status | Penanganan aplikasi |
| --- | --- |
| Akun atau kata sandi gagal | Tampilkan kegagalan login umum tanpa mengungkap apakah akun ada |
| EMAIL_VERIFICATION_REQUIRED | Arahkan pengguna menyelesaikan verifikasi email toko |
| ENTITLEMENT_PENDING | Tampilkan status sinkronisasi dan tunggu sesuai percobaan ulang terbatas paket serta Retry-After |
| ENTITLEMENT_NOT_PURCHASED | Arahkan pengguna membeli atau mengganti akun |
| ENTITLEMENT_EXPIRED | Arahkan pengguna memperpanjang; jangan gunakan kredensial lama untuk menghindari penolakan |
| ENTITLEMENT_SUSPENDED | Hentikan fitur yang dilindungi dan hubungi pedagang |
| Jumlah perangkat sudah penuh | Arahkan pengguna mengelola atau secara eksplisit melepas perangkat |
| Jaringan/HTTP 5xx | Hanya lisensi offline yang telah diverifikasi SDK dan masih berlaku yang boleh digunakan |

401/403/404 yang jelas, akun tidak cocok, pembatalan, atau pembatasan laju tidak boleh diubah menjadi keberhasilan lisensi offline. Aktivasi pertama dan kebijakan yang melarang offline tetap memerlukan jaringan. Jika domain/IP server tidak dapat diakses, tampilkan masalah koneksi dan jangan diam-diam terhubung ke situs lain.

## Penerimaan dan referensi

Verifikasi login nyata, lisensi milik akun tersebut, operasi yang dilindungi, pemulihan setelah mulai ulang, offline yang valid dan kedaluwarsanya, manipulasi cache, keluar, pergantian akun, dan pelepasan perangkat. Dokumen ini tidak mengharuskan penggunaan AI. Lihat [acceptance.md](/id/launch-documents/acceptance/) untuk alat pengujian dan batas penerimaan eksternal; lihat [integration-packages.md](/id/launch-documents/integration-packages/) untuk paket lokal dan petunjuk build.

Pemeriksaan konfigurasi, pembuatan kode, dan pengujian lokal tidak secara otomatis membuktikan keberhasilan pembayaran nyata, penerbitan lisensi, atau aktivasi situs resmi. Toko eksternal dan sandbox pembayaran harus dikonfigurasi dan diterima secara terpisah.