客户端对接 API

复制<?php
/**
 * 米多多授权中心 - PHP 对接示例（依赖 php-curl，宝塔默认已开）
 * 令牌落盘持久化，重启后直接续期，不会重复占用设备额度。
 */
class MdLicenseClient
{
    private string $base;
    private string $cardKey;
    private string $deviceId;
    private string $app = '';      // 应用标识（后台「应用管理」里的 code，必传）：一张卡只对本应用有效
    private ?string $token = null;
    private int $interval = 300;

    public function __construct(string $base, string $cardKey, string $deviceId, string $app = 'mdduotw')
    {
        $this->base     = rtrim($base, '/');
        $this->cardKey  = $cardKey;
        $this->deviceId = $deviceId;   // 首次运行生成 UUID 并持久化，之后固定不变
        $this->app      = $app;        // 一张卡只对本应用有效
        $this->token    = (@file_get_contents($this->tokenFile())) ?: null;
    }

    private function tokenFile(): string
    {
        return sys_get_temp_dir() . '/md_license_' . md5($this->cardKey) . '.token';
    }

    private function post(string $path, array $body): array
    {
        $ch = curl_init($this->base . '/api/' . $path);
        curl_setopt_array($ch, [
            CURLOPT_POST           => true,
            CURLOPT_RETURNTRANSFER => true,
            CURLOPT_TIMEOUT        => 10,
            CURLOPT_HTTPHEADER     => ['Content-Type: application/json'],
            CURLOPT_POSTFIELDS     => json_encode($body, JSON_UNESCAPED_UNICODE),
        ]);
        $raw = curl_exec($ch);
        curl_close($ch);
        return json_decode((string) $raw, true) ?: ['status' => 'error', 'message' => 'bad response'];
    }

    /** @return string ok | locked | error */
    public function activate(string $deviceName = '', string $clientVersion = '1.0.0'): string
    {
        return $this->handle($this->post('activate.php', [
            'card_key'       => $this->cardKey,
            'device_id'      => $this->deviceId,
            'device_name'    => $deviceName,
            'client_version' => $clientVersion,
            'app'            => $this->app,     // 应用隔离：一张卡只对本应用有效
            'token'          => $this->token,   // 有令牌即为续期
        ]));
    }

    public function heartbeat(string $clientVersion = '1.0.0'): string
    {
        return $this->handle($this->post('heartbeat.php', [
            'card_key'       => $this->cardKey,
            'device_id'      => $this->deviceId,
            'token'          => $this->token,
            'client_version' => $clientVersion,
        ]));
    }

    public function verify(): string
    {
        return $this->handle($this->post('verify.php', [
            'card_key'  => $this->cardKey,
            'device_id' => $this->deviceId,
            'token'     => $this->token,
        ]));
    }

    /**
     * 应用展示信息（无需卡密，未激活也能调）
     * 返回：contact / contact_info 应用自己的联系人与联系方式（供应商/代理的后台联系方式不会下发）/
     *      notice 公告 / buy_url 购买链接 / qrcode 客服二维码 / update_url 更新下载链接 / app.latest_version 最新版本。
     *      owner 为兼容字段，内容同样来自应用自身
     */
    public function appInfo(string $clientVersion = '1.0.0'): array
    {
        return $this->post('info.php', [
            'app'            => $this->app,
            'client_version' => $clientVersion,
        ]);
    }

    private function handle(array $res): string
    {
        $st = $res['status'] ?? 'error';
        if ($st === 'ok') {
            if (!empty($res['token'])) {
                $this->token = $res['token'];
                file_put_contents($this->tokenFile(), $this->token);
            }
            $this->interval = (int) ($res['heartbeat_interval'] ?? $this->interval); // 别写死间隔
        } elseif ($st === 'locked') {
            // 已无人工审核：设备满且未开互顶时 reason = device_limit，提示用户联系发卡方解绑
            echo '已锁定：' . ($res['reason'] ?? '') . PHP_EOL;
        }
        return $st;
    }

    public function interval(): int { return $this->interval; }
}

// ---------------- 使用 ----------------
$cli = new MdLicenseClient('https://k.mdduo.cn', 'MDT-XXXXX-XXXXX-XXXXX', 'b7f1c0d2e5a94f13');
if ($cli->activate(gethostname()) === 'ok') {
    while (true) {
        sleep($cli->interval());
        if (in_array($cli->heartbeat(), ['locked', 'error'], true)) {
            break; // 已锁定 / 服务异常：关闭功能或提示续费
        }
    }
}

复制# 米多多授权中心 - Python 对接示例
# 依赖：pip install requests
import json
import time
import uuid

import requests

BASE = "https://k.mdduo.cn/api"
CARD_KEY = "MDT-XXXXX-XXXXX-XXXXX"
APP_CODE = "mdduotw"   # 应用标识（后台「应用管理」里的 code，必传）：一张卡只对本应用有效
DEV_FILE = "device_id.txt"
TOKEN_FILE = "license.token"


def device_id() -> str:
    """设备标识：首次运行生成并持久化，之后固定不变"""
    try:
        return open(DEV_FILE, encoding="utf-8").read().strip()
    except FileNotFoundError:
        did = uuid.uuid4().hex
        open(DEV_FILE, "w", encoding="utf-8").write(did)
        return did


def read_token():
    try:
        return open(TOKEN_FILE, encoding="utf-8").read().strip() or None
    except FileNotFoundError:
        return None


def post(path: str, body: dict) -> dict:
    r = requests.post(f"{BASE}/{path}", json=body, timeout=10)
    try:
        res = r.json()
    except ValueError:
        return {"status": "error", "message": f"http {r.status_code}"}
    if res.get("token"):
        open(TOKEN_FILE, "w", encoding="utf-8").write(res["token"])
    return res


def activate(version: str = "1.0.0") -> dict:
    return post("activate.php", {
        "card_key": CARD_KEY,
        "device_id": device_id(),
        "device_name": "PC-01",
        "client_version": version,
        "app": APP_CODE,                # 应用标识（必传）：一张卡只对本应用有效
        "token": read_token(),          # 有令牌即为续期
    })


def heartbeat(version: str = "1.0.0") -> dict:
    return post("heartbeat.php", {
        "card_key": CARD_KEY,
        "device_id": device_id(),
        "token": read_token(),
        "client_version": version,
    })


def verify() -> dict:
    return post("verify.php", {
        "card_key": CARD_KEY,
        "device_id": device_id(),
        "token": read_token(),
    })


def app_info(version: str = "1.0.0") -> dict:
    """应用展示信息（无需卡密，未激活也能调）：
    contact / contact_info 应用自己的联系人与联系方式（供应商/代理的后台联系方式不会下发）/
    notice 公告 / buy_url 购买链接 / qrcode 客服二维码 / update_url 更新下载链接 / app.latest_version 最新版本。
    owner 为兼容字段，内容同样来自应用自身"""
    return post("info.php", {"app": APP_CODE, "client_version": version})


if __name__ == "__main__":
    # 启动先拉展示信息：还没激活（没卡）时也要告诉客户找谁买卡
    info = app_info()
    if info.get("status") == "ok":
        if info.get("contact") or info.get("contact_info"):
            print("客服：", info.get("contact", ""), info.get("contact_info", ""))
        for label, key in (("公告", "notice"), ("购买卡密", "buy_url"), ("客服二维码", "qrcode")):
            if info.get(key):
                print(f"{label}：{info[key]}")
        latest = (info.get("app") or {}).get("latest_version", "")
        if latest and latest != "1.0.0":
            print("发现新版本", latest, "→", info.get("update_url"))

    res = activate()
    print("activate:", json.dumps(res, ensure_ascii=False))

    # 已无人工审核；设备满且未开互顶时 reason = "device_limit"（提示用户联系发卡方解绑旧设备）
    if res["status"] != "ok":
        print("未授权：", res.get("reason") or res.get("message"))
    else:
        interval = int(res.get("heartbeat_interval", 300))   # 用服务器下发间隔
        while True:
            time.sleep(interval)
            hb = heartbeat()
            if hb["status"] != "ok":
                print("授权失效：", hb.get("reason"), "- 请降级或退出")
                break

复制// 米多多授权中心 - Node.js 对接示例（Node 18+ 自带 fetch）
const fs = require('fs');
const crypto = require('crypto');

const BASE = 'https://k.mdduo.cn/api';
const CARD_KEY = 'MDT-XXXXX-XXXXX-XXXXX';
const APP_CODE = 'mdduotw';   // 应用标识（后台「应用管理」里的 code，必传）：一张卡只对本应用有效
const VER = '1.0.0';
const DEV_FILE = './device_id.txt';
const TOKEN_FILE = './license.token';

// 设备标识：首次运行生成并持久化，之后固定不变
function deviceId() {
  if (!fs.existsSync(DEV_FILE)) {
    fs.writeFileSync(DEV_FILE, crypto.randomUUID().replace(/-/g, ''));
  }
  return fs.readFileSync(DEV_FILE, 'utf8').trim();
}

const readToken = () =>
  fs.existsSync(TOKEN_FILE) ? fs.readFileSync(TOKEN_FILE, 'utf8').trim() || null : null;

async function post(path, body) {
  const res = await fetch(`${BASE}/${path}`, {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify(body),
  });
  const data = await res.json().catch(() => ({ status: 'error', message: `http ${res.status}` }));
  if (data.token) fs.writeFileSync(TOKEN_FILE, data.token);
  return data;
}

const activate = () => post('activate.php', {
  card_key: CARD_KEY,
  device_id: deviceId(),
  device_name: 'PC-01',
  client_version: VER,
  app: APP_CODE,                 // 应用标识：一张卡只对本应用有效
  token: readToken(),            // 有令牌即为续期
});

const heartbeat = () => post('heartbeat.php', {
  card_key: CARD_KEY,
  device_id: deviceId(),
  token: readToken(),
  client_version: VER,
});

const verify = () => post('verify.php', {
  card_key: CARD_KEY,
  device_id: deviceId(),
  token: readToken(),
});

// 应用展示信息（无需卡密，未激活也能调）：
// contact / contact_info 应用自己的联系人与联系方式（供应商/代理的后台联系方式不会下发）/
// notice 公告 / buy_url 购买链接 / qrcode 客服二维码 / update_url 更新下载链接 / app.latest_version 最新版本。
// owner 为兼容字段，内容同样来自应用自身
const appInfo = () => post('info.php', { app: APP_CODE, client_version: VER });

// ---------------- 使用 ----------------
(async () => {
  // 启动先拉展示信息：还没激活（没卡）时也要告诉客户找谁买卡
  const info = await appInfo();
  if (info.status === 'ok') {
    if (info.contact || info.contact_info) console.log('客服：', info.contact, info.contact_info);
    if (info.notice) console.log('公告：', info.notice);
    if (info.buy_url) console.log('购买卡密：', info.buy_url);
    if (info.qrcode) console.log('客服二维码：', info.qrcode);
    const latest = info.app && info.app.latest_version;
    if (latest && latest !== VER) console.log('发现新版本', latest, '→', info.update_url);
  }

  const res = await activate();
  console.log('activate:', res);

  // reason=device_limit：设备数已满（经销商后台或门户「设备列表」解绑旧设备后重试）
  if (res.status !== 'ok') return console.log('未授权：', res.reason || res.message);

  const interval = (res.heartbeat_interval || 300) * 1000;   // 用服务器下发间隔
  setInterval(async () => {
    const hb = await heartbeat();
    if (hb.status !== 'ok') console.log('授权失效：', hb.reason, '- 请降级或退出');
  }, interval);
})();

复制// 米多多授权中心 - Go 对接示例（仅标准库）
package main

import (
	"bytes"
	"crypto/rand"
	"encoding/hex"
	"encoding/json"
	"fmt"
	"io"
	"net/http"
	"os"
	"time"
)

const (
	baseURL = "https://k.mdduo.cn/api"
	cardKey = "MDT-XXXXX-XXXXX-XXXXX"
	appCode = "mdduotw" // 应用标识（后台「应用管理」里的 code，必传）：一张卡只对本应用有效
	ver     = "1.0.0"
	devFile = "device_id.txt"
	tokFile = "license.token"
)

// 设备标识：首次运行生成并持久化，之后固定不变
func DeviceID() string {
	if b, err := os.ReadFile(devFile); err == nil && len(b) > 0 {
		return string(b)
	}
	buf := make([]byte, 16)
	_, _ = rand.Read(buf)
	id := hex.EncodeToString(buf)
	_ = os.WriteFile(devFile, []byte(id), 0600)
	return id
}

func readToken() string {
	if b, err := os.ReadFile(tokFile); err == nil {
		return string(b)
	}
	return ""
}

type Resp struct {
	Status            string `json:"status"`
	Token             string `json:"token"`
	Reason            string `json:"reason"`
	Message           string `json:"message"`
	HeartbeatInterval int    `json:"heartbeat_interval"`
}

func Post(path string, body map[string]any) (*Resp, error) {
	b, _ := json.Marshal(body)
	res, err := http.Post(baseURL+"/"+path, "application/json", bytes.NewReader(b))
	if err != nil {
		return nil, err
	}
	defer res.Body.Close()
	raw, _ := io.ReadAll(res.Body)

	var r Resp
	if err := json.Unmarshal(raw, &r); err != nil {
		return &Resp{Status: "error", Message: string(raw)}, nil
	}
	if r.Token != "" {
		_ = os.WriteFile(tokFile, []byte(r.Token), 0600)
	}
	return &r, nil
}

func Activate() (*Resp, error) {
	return Post("activate.php", map[string]any{
		"card_key": cardKey, "device_id": DeviceID(),
		"device_name": "PC-01", "client_version": ver,
		"app": appCode, // 应用标识（必传）：一张卡只对本应用有效
		"token": readToken(), // 有令牌即为续期
	})
}

func Heartbeat() (*Resp, error) {
	return Post("heartbeat.php", map[string]any{
		"card_key": cardKey, "device_id": DeviceID(),
		"token": readToken(), "client_version": ver,
	})
}

func Verify() (*Resp, error) {
	return Post("verify.php", map[string]any{
		"card_key": cardKey, "device_id": DeviceID(), "token": readToken(),
	})
}

// InfoResp 应用展示信息（无需卡密，未激活也能调）
type InfoResp struct {
	Status string `json:"status"`
	App    struct {
		Name          string `json:"name"`
		LatestVersion string `json:"latest_version"` // 最新版本号，空 = 未配置
		UpdateNote    string `json:"update_note"`    // 更新说明
	} `json:"app"`
	// 应用自己的联系人与联系方式：供应商 / 代理的后台联系方式不会下发
	Contact     string `json:"contact"`
	ContactInfo string `json:"contact_info"`
	Owner *struct { // 兼容字段：内容同样来自应用自身，type 固定 app
		Type string `json:"type"`
		Name string `json:"name"`
	} `json:"owner"`
	Notice    string `json:"notice"`     // 公告（该应用配置的）
	BuyURL    string `json:"buy_url"`    // 购买链接
	QRCode    string `json:"qrcode"`     // 客服二维码图片地址（完整 URL）
	UpdateURL string `json:"update_url"` // 更新下载链接（该应用自己的下载页）
}

// AppInfo 拉取展示信息：未激活（还没有卡密）时也要能告诉客户「找谁买卡」
func AppInfo() (*InfoResp, error) {
	url := baseURL + "/info.php?app=" + appCode + "&client_version=" + ver
	res, err := http.Get(url)
	if err != nil {
		return nil, err
	}
	defer res.Body.Close()
	raw, _ := io.ReadAll(res.Body)
	var r InfoResp
	if err := json.Unmarshal(raw, &r); err != nil {
		return nil, err
	}
	return &r, nil
}

func main() {
	if info, err := AppInfo(); err == nil && info.Status == "ok" {
		if info.Contact != "" || info.ContactInfo != "" {
			fmt.Printf("客服：%s %s\n", info.Contact, info.ContactInfo)
		}
		if info.Notice != "" {
			fmt.Println("公告：", info.Notice)
		}
		if info.BuyURL != "" {
			fmt.Println("购买卡密：", info.BuyURL)
		}
		if info.QRCode != "" {
			fmt.Println("客服二维码：", info.QRCode)
		}
		if info.App.LatestVersion != "" && info.App.LatestVersion != ver {
			fmt.Println("发现新版本：", info.App.LatestVersion, info.App.UpdateNote, "→", info.UpdateURL)
		}
	}

	r, err := Activate()
	if err != nil {
		fmt.Println("网络错误：", err)
		return
	}
	switch r.Status {
	case "ok":
		fmt.Println("授权成功")
	case "locked":
		fmt.Println("已锁定：", r.Reason) // device_limit=设备数已满，需在经销商后台解绑旧设备
		return
	default:
		fmt.Println("失败：", r.Message)
		return
	}

	// 心跳间隔用服务器下发值，别写死
	for range time.Tick(time.Duration(r.HeartbeatInterval) * time.Second) {
		hb, err := Heartbeat()
		if err != nil {
			continue // 网络抖动：下一轮再试
		}
		if hb.Status != "ok" {
			fmt.Println("授权失效：", hb.Reason)
			return
		}
	}
}

复制// 米多多授权中心 - Java 对接示例（JDK 11+，仅标准库）
// 说明：为演示简洁用正则取字段，生产建议引入 Jackson / Gson。
import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.nio.file.Files;
import java.nio.file.Path;
import java.time.Duration;
import java.util.UUID;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class MdLicense {
    static final String BASE = "https://k.mdduo.cn/api";
    static final String CARD_KEY = "MDT-XXXXX-XXXXX-XXXXX";
    static final String APP = "mdduotw";   // 应用标识（后台「应用管理」里的 code），必传，留空会返回 app_required
    static final String VER = "1.0.0";
    static final Path DEV_FILE = Path.of("device_id.txt");
    static final Path TOKEN_FILE = Path.of("license.token");
    static final HttpClient HTTP = HttpClient.newBuilder()
            .connectTimeout(Duration.ofSeconds(10)).build();

    /** 设备标识：首次运行生成并持久化，之后固定不变 */
    static String deviceId() throws Exception {
        if (Files.exists(DEV_FILE)) return Files.readString(DEV_FILE).trim();
        String id = UUID.randomUUID().toString().replace("-", "");
        Files.writeString(DEV_FILE, id);
        return id;
    }

    static String readToken() {
        try {
            return Files.exists(TOKEN_FILE) ? Files.readString(TOKEN_FILE).trim() : null;
        } catch (Exception e) {
            return null;
        }
    }

    static String field(String key, String json) {
        Matcher m = Pattern.compile("\"" + key + "\"\\s*:\\s*\"?([^,\"}]*)\"?").matcher(json);
        return m.find() ? m.group(1) : null;
    }

    static String post(String path, String json) throws Exception {
        HttpRequest req = HttpRequest.newBuilder(URI.create(BASE + "/" + path))
                .timeout(Duration.ofSeconds(10))
                .header("Content-Type", "application/json")
                .POST(HttpRequest.BodyPublishers.ofString(json))
                .build();
        String body = HTTP.send(req, HttpResponse.BodyHandlers.ofString()).body();
        String token = field("token", body);
        if (token != null && !token.isEmpty()) Files.writeString(TOKEN_FILE, token);
        return body;
    }

    static String tokenJson() {
        String t = readToken();
        return t == null ? "" : t;
    }

    static String activate() throws Exception {
        return post("activate.php", "{"
                + "\"card_key\":\"" + CARD_KEY + "\","
                + "\"device_id\":\"" + deviceId() + "\","
                + "\"device_name\":\"PC-01\","
                + "\"client_version\":\"" + VER + "\","
                + "\"app\":\"" + APP + "\","                // 应用隔离：一张卡只对本应用有效
                + "\"token\":\"" + tokenJson() + "\"}");   // 有令牌即为续期
    }

    static String heartbeat() throws Exception {
        return post("heartbeat.php", "{"
                + "\"card_key\":\"" + CARD_KEY + "\","
                + "\"device_id\":\"" + deviceId() + "\","
                + "\"token\":\"" + tokenJson() + "\","
                + "\"client_version\":\"" + VER + "\"}");
    }

    static String verify() throws Exception {
        return post("verify.php", "{"
                + "\"card_key\":\"" + CARD_KEY + "\","
                + "\"device_id\":\"" + deviceId() + "\","
                + "\"token\":\"" + tokenJson() + "\"}");
    }

    /**
     * 应用展示信息（无需卡密，未激活也能调）：
     * contact / contact_info 应用自己的联系人与联系方式（供应商/代理的后台联系方式不会下发）/
     * notice 公告 / buy_url 购买链接 / qrcode 客服二维码 / update_url 更新下载链接 / app.latest_version 最新版本。
     * owner 为兼容字段，内容同样来自应用自身
     */
    static String appInfo() throws Exception {
        HttpRequest req = HttpRequest.newBuilder(URI.create(BASE + "/info.php?app=" + APP + "&client_version=" + VER))
                .timeout(Duration.ofSeconds(10))
                .GET().build();
        return HTTP.send(req, HttpResponse.BodyHandlers.ofString()).body();
    }

    public static void main(String[] args) throws Exception {
        // 启动先拉展示信息：还没激活（没卡）时也要告诉客户找谁买卡
        String info = appInfo();
        if ("ok".equals(field("status", info))) {
            // 联系人 / 联系方式直接读顶层字段（全部来自应用自身）
            String contact = field("contact", info), contactInfo = field("contact_info", info);
            if ((contact != null && !contact.isEmpty()) || (contactInfo != null && !contactInfo.isEmpty())) {
                System.out.println("客服：" + contact + " " + contactInfo);
            }
            for (String k : new String[]{"notice", "buy_url", "qrcode"}) {
                String v = field(k, info);
                if (v != null && !v.isEmpty()) System.out.println(k + ": " + v);
            }
            String latest = field("latest_version", info);
            if (latest != null && !latest.isEmpty() && !latest.equals(VER)) {
                System.out.println("发现新版本 " + latest + " -> " + field("update_url", info));
            }
        }

        String res = activate();
        System.out.println("activate: " + res);

        String status = field("status", res);
        if (!"ok".equals(status)) {
            // reason=device_limit 时表示设备数已满，需在经销商后台解绑旧设备
            System.out.println("未授权：" + field("reason", res));
            return;
        }

        String iv = field("heartbeat_interval", res);
        long interval = iv == null ? 300 : Long.parseLong(iv);
        while (true) {
            Thread.sleep(interval * 1000);
            String hb = heartbeat();
            if (!"ok".equals(field("status", hb))) {
                System.out.println("授权失效：" + field("reason", hb));
                return;
            }
        }
    }
}

复制// 米多多授权中心 - C# 对接示例（.NET 6+）
using System.Net.Http.Json;
using System.Text.Json.Nodes;

class MdLicense
{
    const string Base = "https://k.mdduo.cn/api";
    const string CardKey = "MDT-XXXXX-XXXXX-XXXXX";
    const string AppCode = "mdduotw";   // 应用标识（后台「应用管理」里的 code，必传）：一张卡只对本应用有效
    const string Ver = "1.0.0";
    static readonly HttpClient Http = new() { Timeout = TimeSpan.FromSeconds(10) };
    static string DevFile => Path.Combine(AppContext.BaseDirectory, "device_id.txt");
    static string TokenFile => Path.Combine(AppContext.BaseDirectory, "license.token");

    /// 设备标识：首次运行生成并持久化，之后固定不变
    static string DeviceId()
    {
        if (File.Exists(DevFile)) return File.ReadAllText(DevFile).Trim();
        var id = Guid.NewGuid().ToString("N");
        File.WriteAllText(DevFile, id);
        return id;
    }

    static string? ReadToken() => File.Exists(TokenFile) ? File.ReadAllText(TokenFile).Trim() : null;

    static async Task<JsonNode> PostAsync(string path, object body)
    {
        var res = await Http.PostAsJsonAsync($"{Base}/{path}", body);
        var json = await res.Content.ReadAsStringAsync();
        var node = JsonNode.Parse(json) ?? new JsonObject { ["status"] = "error" };
        var token = node["token"]?.GetValue<string>();
        if (!string.IsNullOrEmpty(token)) File.WriteAllText(TokenFile, token);
        return node;
    }

    static Task<JsonNode> ActivateAsync() => PostAsync("activate.php", new
    {
        card_key = CardKey,
        device_id = DeviceId(),
        device_name = Environment.MachineName,
        client_version = Ver,
        app = AppCode,                  // 应用标识（必传）：一张卡只对本应用有效
        token = ReadToken(),            // 有令牌即为续期
    });

    static Task<JsonNode> HeartbeatAsync() => PostAsync("heartbeat.php", new
    {
        card_key = CardKey,
        device_id = DeviceId(),
        token = ReadToken(),
        client_version = Ver,
    });

    static Task<JsonNode> VerifyAsync() => PostAsync("verify.php", new
    {
        card_key = CardKey,
        device_id = DeviceId(),
        token = ReadToken(),
    });

    /// 应用展示信息（无需卡密，未激活也能调）：
    /// contact / contact_info 应用自己的联系人与联系方式（供应商/代理的后台联系方式不会下发）/
    /// notice 公告 / buy_url 购买链接 / qrcode 客服二维码 / update_url 更新下载链接 / app.latest_version 最新版本。
    /// owner 为兼容字段，内容同样来自应用自身
    static async Task<JsonNode> AppInfoAsync()
    {
        var res = await Http.GetAsync($"{Base}/info.php?app={AppCode}&client_version={Ver}");
        var json = await res.Content.ReadAsStringAsync();
        return JsonNode.Parse(json) ?? new JsonObject { ["status"] = "error" };
    }

    static async Task Main()
    {
        // 启动先拉展示信息：还没激活（没卡）时也要告诉客户找谁买卡
        var info = await AppInfoAsync();
        if (info["status"]?.GetValue<string>() == "ok")
        {
            var contact = info["contact"]?.GetValue<string>() ?? "";
            var contactInfo = info["contact_info"]?.GetValue<string>() ?? "";
            if (contact != "" || contactInfo != "") Console.WriteLine($"客服：{contact} {contactInfo}");
            foreach (var k in new[] { "notice", "buy_url", "qrcode" })
            {
                var v = info[k]?.GetValue<string>();
                if (!string.IsNullOrEmpty(v)) Console.WriteLine($"{k}: {v}");
            }
            var latest = info["app"]?["latest_version"]?.GetValue<string>();
            if (!string.IsNullOrEmpty(latest) && latest != Ver)
            {
                Console.WriteLine($"发现新版本 {latest}：{info["app"]?["update_note"]} → {info["update_url"]}");
            }
        }

        var r = await ActivateAsync();
        var status = r["status"]?.GetValue<string>();
        Console.WriteLine($"activate: {r.ToJsonString()}");

        // 已无人工审核；设备满且未开互顶时 reason = "device_limit"（提示用户联系发卡方解绑旧设备）
        if (status != "ok")
        {
            Console.WriteLine($"未授权：{r["reason"] ?? r["message"]}");
            return;
        }

        var interval = r["heartbeat_interval"]?.GetValue<int>() ?? 300;   // 用服务器下发间隔
        while (true)
        {
            await Task.Delay(TimeSpan.FromSeconds(interval));
            var hb = await HeartbeatAsync();
            if (hb["status"]?.GetValue<string>() != "ok")
            {
                Console.WriteLine($"授权失效：{hb["reason"]} - 请降级或退出");
                return;
            }
        }
    }
}

复制// 米多多授权中心 - Rust 对接示例
// Cargo.toml:
//   serde = { version = "1", features = ["derive"] }
//   serde_json = "1"
//   reqwest = { version = "0.11", features = ["blocking", "json"] }
//   uuid = { version = "1", features = ["v4"] }

use serde::{Deserialize, Serialize};
use std::fs;
use std::time::Duration;

const BASE: &str = "https://k.mdduo.cn/api";
const CARD_KEY: &str = "MDT-XXXXX-XXXXX-XXXXX";
// 应用标识（后台「应用管理」里的 code，必传）：一张卡只对本应用有效，
// 同时也是「展示信息」的查询键 —— 打包时注入（如构建脚本替换本行 / 环境变量），
// 每个渠道一份专属包 → 客户端显示该应用自己的联系人 / 联系方式 / 公告 / 购买链接 / 二维码 / 更新链接。
const APP_CODE: &str = "mdduotw";
const VER: &str = "1.0.0";
const DEV_FILE: &str = "device_id.txt";
const TOKEN_FILE: &str = "license.token";

#[derive(Serialize)]
struct ActivateReq<'a> {
    card_key: &'a str,
    device_id: &'a str,
    device_name: &'a str,
    client_version: &'a str,
    app: &'a str,               // 应用标识（必传）：一张卡只对本应用有效
    token: Option<String>,
}

#[derive(Serialize)]
struct HeartbeatReq<'a> {
    card_key: &'a str,
    device_id: &'a str,
    token: Option<String>,
    client_version: &'a str,
}

#[derive(Serialize)]
struct VerifyReq<'a> {
    card_key: &'a str,
    device_id: &'a str,
    token: Option<String>,
}

// 自助解绑（「注销本机」）：无需令牌，删除「该卡密 + 本机」这条激活记录、释放设备名额
#[derive(Serialize)]
struct UnbindReq<'a> {
    card_key: &'a str,
    device_id: &'a str,
    app: &'a str,               // 可选：传了服务端会校验它与卡密所属应用一致
}

#[derive(Deserialize, Debug)]
struct Resp {
    status: String,
    token: Option<String>,
    reason: Option<String>,
    message: Option<String>,
    heartbeat_interval: Option<u64>,
    lock_on_invalid: Option<u8>,   // 网络异常是否锁端：1=锁 0=按离线宽限期
    offline_grace: Option<u64>,    // 离线宽限期(秒)，0=不限时；仅 lock_on_invalid=0 时生效
}

/* ---------- 应用信息与展示信息（未激活也能调，无需卡密） ---------- */

#[derive(Deserialize, Debug)]
struct InfoResp {
    status: String,
    app: Option<InfoApp>,
    contact: Option<String>,        // 应用自己的联系人（客户端展示）
    contact_info: Option<String>,   // 应用自己的联系方式，手机 / 微信 / QQ
    #[allow(dead_code)]
    owner: Option<InfoOwner>,       // 兼容字段：内容同样来自应用自身，新客户端用上面两个顶层字段
    notice: Option<String>,         // 公告（该应用配置的）
    buy_url: Option<String>,        // 购买链接（「购买卡密」按钮）
    qrcode: Option<String>,         // 客服二维码图片地址（完整 URL，可直接加载）
    update_url: Option<String>,     // 更新下载链接（该应用自己的下载页）
}

#[derive(Deserialize, Debug)]
struct InfoApp {
    code: Option<String>,
    name: Option<String>,
    latest_version: Option<String>, // 最新版本号，空字符串 = 未配置
    update_note: Option<String>,    // 更新说明
    contact: Option<String>,
    contact_info: Option<String>,
}

#[derive(Deserialize, Debug)]
#[allow(dead_code)]
struct InfoOwner {
    #[serde(rename = "type")]
    kind: Option<String>,           // 固定为 app
    name: Option<String>,
    contact: Option<String>,
    contact_info: Option<String>,
}

/// 拉取展示信息（应用标识需在打包时注入，见常量 APP_CODE）
fn app_info() -> Result<InfoResp, String> {
    let client = reqwest::blocking::Client::builder()
        .timeout(Duration::from_secs(10))
        .build()
        .map_err(|e| e.to_string())?;
    client
        .get(format!("{BASE}/info.php?app={APP_CODE}&client_version={VER}"))
        .send()
        .map_err(|e| e.to_string())?
        .json::<InfoResp>()
        .map_err(|e| e.to_string())
}

/// 版本比对：本地版本 < 最新版本 时提示更新（按数字段逐位比较，1.10.0 > 1.9.0）
fn version_less(cur: &str, latest: &str) -> bool {
    let parse = |s: &str| -> Vec<u64> {
        s.split(|c: char| !c.is_ascii_digit())
            .filter(|p| !p.is_empty())
            .filter_map(|p| p.parse::<u64>().ok())
            .collect()
    };
    let (a, b) = (parse(cur), parse(latest));
    for i in 0..a.len().max(b.len()) {
        let (x, y) = (a.get(i).copied().unwrap_or(0), b.get(i).copied().unwrap_or(0));
        if x != y {
            return x < y;
        }
    }
    false
}

/// 启动时调用：未激活也能显示「找谁买卡」+ 新版本提示
fn show_app_info() {
    let Ok(info) = app_info() else {
        println!("展示信息拉取失败（可用本地缓存兜底）");
        return;
    };
    if info.status != "ok" {
        return;
    }
    // 联系人 / 联系方式全部来自应用自身：供应商 / 代理的后台联系方式不会下发
    let contact = info.contact.clone().unwrap_or_default();
    let contact_info = info.contact_info.clone().unwrap_or_default();
    if !contact.is_empty() || !contact_info.is_empty() {
        println!("客服：{contact} {contact_info}");
    }
    if let Some(n) = &info.notice { if !n.is_empty() { println!("公告：{n}"); } }
    if let Some(u) = &info.buy_url { if !u.is_empty() { println!("购买卡密：{u}"); } }
    if let Some(q) = &info.qrcode { if !q.is_empty() { println!("客服二维码：{q}"); } }

    // 版本更新：latest_version / update_note / update_url 全部配在应用上
    if let Some(app) = &info.app {
        let latest = app.latest_version.clone().unwrap_or_default();
        if !latest.is_empty() && version_less(VER, &latest) {
            println!("发现新版本 {latest}：{}", app.update_note.clone().unwrap_or_default());
            if let Some(u) = &info.update_url { if !u.is_empty() { println!("下载地址：{u}"); } }
        }
    }
}

/// 设备标识：首次运行生成并持久化，之后固定不变
fn device_id() -> String {
    if let Ok(s) = fs::read_to_string(DEV_FILE) {
        let s = s.trim();
        if !s.is_empty() {
            return s.to_string();
        }
    }
    let id = uuid::Uuid::new_v4().simple().to_string();
    let _ = fs::write(DEV_FILE, &id);
    id
}

fn read_token() -> Option<String> {
    fs::read_to_string(TOKEN_FILE)
        .ok()
        .map(|s| s.trim().to_string())
        .filter(|s| !s.is_empty())
}

/// 清除本地令牌：收到 no_activation（设备被解绑/换绑）后调用，
/// 否则下次 activate 会带旧令牌走「续期」分支，服务端将按重新激活处理
fn clear_token() {
    let _ = fs::remove_file(TOKEN_FILE);
}

fn post(path: &str, body: &impl Serialize) -> Result<Resp, String> {
    let client = reqwest::blocking::Client::builder()
        .timeout(Duration::from_secs(10))
        .build()
        .map_err(|e| e.to_string())?;

    let resp: Resp = client
        .post(format!("{BASE}/{path}"))
        .json(body)
        .send()
        .map_err(|e| e.to_string())?
        .json()
        .map_err(|e| e.to_string())?;

    if let Some(t) = &resp.token {
        let _ = fs::write(TOKEN_FILE, t); // 令牌落盘，重启后直接续期
    }
    Ok(resp)
}

fn activate() -> Result<Resp, String> {
    let did = device_id();
    post(
        "activate.php",
        &ActivateReq {
            card_key: CARD_KEY,
            device_id: &did,
            device_name: "PC-01",
            client_version: VER,
            app: APP_CODE,       // 应用标识：一张卡只对本应用有效
            token: read_token(), // 有令牌即为续期
        },
    )
}

fn heartbeat() -> Result<Resp, String> {
    let did = device_id();
    post(
        "heartbeat.php",
        &HeartbeatReq {
            card_key: CARD_KEY,
            device_id: &did,
            token: read_token(),
            client_version: VER,
        },
    )
}

fn verify() -> Result<Resp, String> {
    let did = device_id();
    post(
        "verify.php",
        &VerifyReq {
            card_key: CARD_KEY,
            device_id: &did,
            token: read_token(),
        },
    )
}

/// 客户端自助解绑（「注销本机」）：删除「该卡密 + 本机」这一条激活记录，立刻释放一个设备名额。
/// 无需令牌、不校验卡密状态（禁用 / 吊销 / 过期都能解），只能解自己这一台；
/// 成功后应回到未激活界面（本例先清掉本地令牌，避免带着旧令牌走续期分支）。
/// 平台在系统设置里关闭该功能时返回 400 code=unbind_disabled。
fn unbind() -> Result<Resp, String> {
    let did = device_id();
    clear_token();
    post(
        "unbind.php",
        &UnbindReq {
            card_key: CARD_KEY,
            device_id: &did,
            app: APP_CODE,
        },
    )
}

fn main() {
    // 先拉展示信息：未激活（还没有卡密）时也要能告诉客户「找谁买卡」
    show_app_info();

    match activate() {
        Err(e) => println!("网络错误：{e}"),
        Ok(r) => match r.status.as_str() {
            "ok" => {
                // 授权策略：服务端按应用下发，心跳成功时动态更新
                let mut interval = r.heartbeat_interval.unwrap_or(300);
                let mut lock_on_invalid = r.lock_on_invalid.unwrap_or(1) == 1;
                let mut grace = r.offline_grace.unwrap_or(0);
                println!(
                    "授权成功，心跳间隔 {interval}s，网络异常策略：{}",
                    if lock_on_invalid { "锁端".to_string() } else { format!("宽限 {grace}s（0=不限时）") }
                );
                let mut last_ok = std::time::Instant::now(); // 最后一次成功响应时刻
                loop {
                    std::thread::sleep(Duration::from_secs(interval));
                    match heartbeat() {
                        Ok(hb) if hb.status == "ok" => {
                            last_ok = std::time::Instant::now();
                            interval = hb.heartbeat_interval.unwrap_or(interval);
                            lock_on_invalid = hb.lock_on_invalid.unwrap_or(lock_on_invalid as u8) == 1;
                            grace = hb.offline_grace.unwrap_or(grace);
                        }
                        // 设备被后台解绑 / 换绑（激活记录已删除）：清掉本地令牌后重新激活，
                        // 服务端会重走完整校验（额度满且未开互顶时返回 device_limit）
                        Ok(hb) if hb.reason.as_deref() == Some("no_activation") => {
                            println!("设备已被解绑，尝试重新激活…");
                            clear_token();
                            match activate() {
                                Ok(a) if a.status == "ok" => {
                                    last_ok = std::time::Instant::now();
                                    interval = a.heartbeat_interval.unwrap_or(interval);
                                    lock_on_invalid = a.lock_on_invalid.unwrap_or(lock_on_invalid as u8) == 1;
                                    grace = a.offline_grace.unwrap_or(grace);
                                    println!("重新激活成功");
                                }
                                Ok(a) => {
                                    println!("重新激活失败：{:?}", a.reason.or(a.message));
                                    break;
                                }
                                Err(e) => println!("重新激活网络错误（下轮重试）：{e}"),
                            }
                        }
                        // 服务端明确拒绝：一律立即停用（不受网络异常策略影响）
                        Ok(hb) => {
                            println!("授权失效：{:?} - 请降级或退出", hb.reason);
                            break;
                        }
                        // 连不上服务器：按 lock_on_invalid / offline_grace 处理
                        Err(e) => {
                            if lock_on_invalid {
                                println!("网络异常且策略为「锁端」：立即停用（{e}）");
                                break;
                            }
                            if grace > 0 && last_ok.elapsed().as_secs() > grace {
                                println!("网络异常已超过宽限期 {grace}s：停用（{e}）");
                                break;
                            }
                            println!("网络异常（宽限中，距上次成功 {}s）：{e}", last_ok.elapsed().as_secs());
                        }
                    }
                }
            }
            // 已无人工审核：设备满且未开互顶时 reason = "device_limit"（提示用户联系发卡方解绑旧设备）
            "locked" => println!("已锁定：{:?}", r.reason),
            _ => println!("失败：{:?}", r.message),
        },
    }
    let _ = verify(); // 只读校验：需要时可单独调用
}