dependencies {
    // 核心SDK
    implementation 'com.miluosdk:core:5.0.0'
    // 支付模块（可选）
    implementation 'com.miluosdk:payment:5.0.0'
    // 数据统计模块（可选）
    implementation 'com.miluosdk:analytics:5.0.0'
}

public class MyApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        
        // 初始化配置
        MiluoConfig config = new MiluoConfig.Builder()
            .appId("YOUR_APP_ID")
            .appKey("YOUR_APP_KEY")
            .channelId("default")
            .debug(BuildConfig.DEBUG)
            .build();
        
        // 初始化SDK
        MiluoSDK.init(this, config);
    }
}

// 发起登录
MiluoSDK.login(new MiluoCallback<MiluoUser>() {
    @Override
    public void onSuccess(MiluoUser user) {
        // 登录成功
        String userId = user.getUserId();
        String token = user.getToken();
        // 将token发送到您的游戏服务器验证
    }
    
    @Override
    public void onError(int code, String message) {
        // 登录失败
        Log.e("MiluoSDK", "Login failed: " + message);
    }
    
    @Override
    public void onCancel() {
        // 用户取消登录
    }
});

// 创建支付订单
MiluoPayOrder order = new MiluoPayOrder.Builder()
    .productId("product_001")
    .productName("100钻石")
    .amount(1000) // 单位：分
    .roleId("player_123")
    .roleName("玩家昵称")
    .serverId("server_01")
    .callbackUrl("https://your-server.com/pay/callback")
    .build();

// 发起支付
MiluoSDK.pay(order, new MiluoCallback<MiluoPayResult>() {
    @Override
    public void onSuccess(MiluoPayResult result) {
        // 支付成功
        Toast.makeText(context, "支付成功", Toast.LENGTH_SHORT).show();
    }
    
    @Override
    public void onError(int code, String message) {
        // 支付失败
        Toast.makeText(context, "支付失败: " + message, Toast.LENGTH_SHORT).show();
    }
    
    @Override
    public void onCancel() {
        // 用户取消支付
    }
});

// 自定义事件
MiluoAnalytics.trackEvent("level_complete", 
    new HashMap<String, Object>() {{
        put("level", 10);
        put("score", 5000);
        put("time", 120);
    }}
);

// 用户属性设置
MiluoAnalytics.setUserProperty("vip_level", "5");
MiluoAnalytics.setUserProperty("total_pay", "10000");

platform :ios, '12.0'

target 'YourApp' do
  use_frameworks!
  
  pod 'MiluoSDK', '~> 5.0.0'
  pod 'MiluoSDK/Payment', '~> 5.0.0'
  pod 'MiluoSDK/Analytics', '~> 5.0.0'
end

import MiluoSDK

func application(_ application: UIApplication,
    didFinishLaunchingWithOptions launchOptions: 
    [UIApplication.LaunchOptionsKey: Any]?) -> Bool {
    
    let config = MiluoConfig(
        appId: "YOUR_APP_ID",
        appKey: "YOUR_APP_KEY",
        channelId: "default",
        debug: true
    )
    
    MiluoSDK.initialize(config: config)
    
    return true
}

// 登录
MiluoSDK.login { result in
    switch result {
    case .success(let user):
        print("登录成功: \(user.userId)")
        // 发送token到游戏服务器
    case .failure(let error):
        print("登录失败: \(error.localizedDescription)")
    case .cancelled:
        print("用户取消登录")
    }
}

// 支付
let order = MiluoPayOrder(
    productId: "product_001",
    productName: "100钻石",
    amount: 1000,
    roleId: "player_123",
    roleName: "玩家昵称"
)

MiluoSDK.pay(order: order) { result in
    switch result {
    case .success:
        print("支付成功")
    case .failure(let error):
        print("支付失败: \(error.localizedDescription)")
    case .cancelled:
        print("用户取消支付")
    }
}

using MiluoSDK;

public class GameManager : MonoBehaviour
{
    void Start()
    {
        // 初始化配置
        MiluoConfig config = new MiluoConfig
        {
            AppId = "YOUR_APP_ID",
            AppKey = "YOUR_APP_KEY",
            ChannelId = "default",
            Debug = true
        };
        
        // 初始化SDK
        MiluoSDK.Initialize(config);
    }
}

// 登录
public void OnLoginButton()
{
    MiluoSDK.Login(
        onSuccess: (user) => {
            Debug.Log($"登录成功: {user.UserId}");
            // 处理登录成功逻辑
        },
        onError: (code, message) => {
            Debug.LogError($"登录失败: {message}");
        },
        onCancel: () => {
            Debug.Log("用户取消登录");
        }
    );
}

// 支付
public void OnPayButton()
{
    var order = new MiluoPayOrder
    {
        ProductId = "product_001",
        ProductName = "100钻石",
        Amount = 1000,
        RoleId = "player_123",
        RoleName = "玩家昵称"
    };
    
    MiluoSDK.Pay(order,
        onSuccess: (result) => {
            Debug.Log("支付成功");
        },
        onError: (code, message) => {
            Debug.LogError($"支付失败: {message}");
        },
        onCancel: () => {
            Debug.Log("用户取消支付");
        }
    );
}

{
  "dependencies": {
    "@miluosdk/core": "^5.0.0",
    "@miluosdk/payment": "^5.0.0"
  }
}

import { MiluoSDK, MiluoConfig } from '@miluosdk/core';

// 初始化
let config = new MiluoConfig({
  appId: 'YOUR_APP_ID',
  appKey: 'YOUR_APP_KEY',
  channelId: 'default',
  debug: true
});

MiluoSDK.initialize(config);

// 登录
MiluoSDK.login({
  onSuccess: (user) => {
    console.log('登录成功:', user.userId);
  },
  onError: (code, message) => {
    console.error('登录失败:', message);
  }
});

<dependency>
    <groupId>com.miluosdk</groupId>
    <artifactId>server-sdk</artifactId>
    <version>5.0.0</version>
</dependency>

import com.miluosdk.server.MiluoServerSDK;
import com.miluosdk.server.config.MiluoConfig;

public class MiluoInitializer {
    public static void init() {
        // 配置参数
        MiluoConfig config = new MiluoConfig();
        config.setAppId("YOUR_APP_ID");
        config.setAppKey("YOUR_APP_KEY");
        config.setServerKey("YOUR_SERVER_KEY");
        config.setNotifyUrl("https://your-server.com/api/miluo/callback");
        
        // 初始化SDK
        MiluoServerSDK.initialize(config);
    }
}

composer require miluosdk/server-sdk

<?php
require_once 'vendor/autoload.php';

use MiluoSDK\ServerSDK;
use MiluoSDK\Config\MiluoConfig;

$config = new MiluoConfig([
    'app_id' => 'YOUR_APP_ID',
    'app_key' => 'YOUR_APP_KEY',
    'server_key' => 'YOUR_SERVER_KEY',
    'notify_url' => 'https://your-server.com/api/miluo/callback'
]);

ServerSDK::initialize($config);
?>

pip install miluosdk-server

from miluosdk import MiluoServerSDK
from miluosdk.config import MiluoConfig

config = MiluoConfig(
    app_id='YOUR_APP_ID',
    app_key='YOUR_APP_KEY',
    server_key='YOUR_SERVER_KEY',
    notify_url='https://your-server.com/api/miluo/callback'
)

MiluoServerSDK.initialize(config)

npm install @miluosdk/server-sdk

const MiluoServerSDK = require('@miluosdk/server-sdk');

const config = {
    appId: 'YOUR_APP_ID',
    appKey: 'YOUR_APP_KEY',
    serverKey: 'YOUR_SERVER_KEY',
    notifyUrl: 'https://your-server.com/api/miluo/callback'
};

MiluoServerSDK.initialize(config);

import javax.crypto.Mac;
import javax.crypto.spec.SecretKeySpec;
import java.nio.charset.StandardCharsets;
import java.util.Map;
import java.util.TreeMap;

public class SignatureUtil {
    
    /**
     * 验证签名
     */
    public static boolean verifySignature(Map<String, String> params, String serverKey, String sign) {
        // 生成签名
        String calculatedSign = generateSignature(params, serverKey);
        // 比较签名（不区分大小写）
        return calculatedSign.equalsIgnoreCase(sign);
    }
    
    /**
     * 生成签名
     */
    public static String generateSignature(Map<String, String> params, String serverKey) {
        try {
            // 1. 参数按字母顺序排序（使用TreeMap自动排序）
            Map<String, String> sortedParams = new TreeMap<>(params);
            
            // 2. 拼接参数
            StringBuilder sb = new StringBuilder();
            for (Map.Entry<String, String> entry : sortedParams.entrySet()) {
                if (sb.length() > 0) {
                    sb.append("&");
                }
                sb.append(entry.getKey()).append("=").append(entry.getValue());
            }
            
            // 3. 追加ServerKey
            sb.append("&server_key=").append(serverKey);
            String stringToSign = sb.toString();
            
            // 4. HMAC-SHA256加密
            Mac mac = Mac.getInstance("HmacSHA256");
            SecretKeySpec secretKeySpec = new SecretKeySpec(
                serverKey.getBytes(StandardCharsets.UTF_8), 
                "HmacSHA256"
            );
            mac.init(secretKeySpec);
            byte[] hash = mac.doFinal(stringToSign.getBytes(StandardCharsets.UTF_8));
            
            // 5. 转换为小写十六进制
            return bytesToHex(hash).toLowerCase();
        } catch (Exception e) {
            throw new RuntimeException("签名生成失败", e);
        }
    }
    
    private static String bytesToHex(byte[] bytes) {
        StringBuilder hexString = new StringBuilder();
        for (byte b : bytes) {
            String hex = Integer.toHexString(0xff & b);
            if (hex.length() == 1) hexString.append('0');
            hexString.append(hex);
        }
        return hexString.toString();
    }
}

@PostMapping("/api/miluo/callback")
public String handlePaymentCallback(HttpServletRequest request) {
    // 1. 获取所有参数
    Map<String, String> params = new HashMap<>();
    Enumeration<String> parameterNames = request.getParameterNames();
    while (parameterNames.hasMoreElements()) {
        String name = parameterNames.nextElement();
        params.put(name, request.getParameter(name));
    }
    
    // 2. 获取签名
    String sign = params.get("sign");
    if (sign == null) {
        return "fail: signature missing";
    }
    
    // 3. 验证时间戳（防止重放攻击）
    long timestamp = Long.parseLong(params.get("timestamp"));
    long currentTime = System.currentTimeMillis() / 1000;
    if (Math.abs(currentTime - timestamp) > 300) { // 5分钟有效期
        return "fail: timestamp expired";
    }
    
    // 4. 验证签名
    String serverKey = "YOUR_SERVER_KEY";
    if (!SignatureUtil.verifySignature(params, serverKey, sign)) {
        return "fail: invalid signature";
    }
    
    // 5. 处理业务逻辑
    String orderId = params.get("order_id");
    String status = params.get("status");
    
    if ("success".equals(status)) {
        // 更新订单状态，发货等
        processOrderSuccess(orderId);
    }
    
    // 6. 返回成功响应
    return "success";
}

<?php
class SignatureUtil {
    
    /**
     * 验证签名
     */
    public static function verifySignature($params, $serverKey, $sign) {
        $calculatedSign = self::generateSignature($params, $serverKey);
        return strcasecmp($calculatedSign, $sign) === 0;
    }
    
    /**
     * 生成签名
     */
    public static function generateSignature($params, $serverKey) {
        // 1. 参数按字母顺序排序
        ksort($params);
        
        // 2. 拼接参数
        $stringToSign = '';
        foreach ($params as $key => $value) {
            if ($stringToSign !== '') {
                $stringToSign .= '&';
            }
            $stringToSign .= $key . '=' . $value;
        }
        
        // 3. 追加ServerKey
        $stringToSign .= '&server_key=' . $serverKey;
        
        // 4. HMAC-SHA256加密
        $hash = hash_hmac('sha256', $stringToSign, $serverKey);
        
        // 5. 返回小写十六进制
        return strtolower($hash);
    }
}
?>

<?php
require_once 'vendor/autoload.php';
use MiluoSDK\Util\SignatureUtil;

// 获取所有POST参数
$params = $_POST;

// 获取签名
$sign = $params['sign'] ?? '';
if (empty($sign)) {
    http_response_code(400);
    echo json_encode(['error' => 'signature missing']);
    exit;
}

// 验证时间戳
$timestamp = intval($params['timestamp'] ?? 0);
$currentTime = time();
if (abs($currentTime - $timestamp) > 300) {
    http_response_code(400);
    echo json_encode(['error' => 'timestamp expired']);
    exit;
}

// 验证签名
$serverKey = 'YOUR_SERVER_KEY';
if (!SignatureUtil::verifySignature($params, $serverKey, $sign)) {
    http_response_code(400);
    echo json_encode(['error' => 'invalid signature']);
    exit;
}

// 处理业务逻辑
$orderId = $params['order_id'];
$status = $params['status'];

if ($status === 'success') {
    // 更新订单状态
    processOrderSuccess($orderId);
}

// 返回成功
echo json_encode(['status' => 'success']);
?>

import hmac
import hashlib
import time
from collections import OrderedDict

class SignatureUtil:
    
    @staticmethod
    def verify_signature(params, server_key, sign):
        """验证签名"""
        calculated_sign = SignatureUtil.generate_signature(params, server_key)
        return calculated_sign.lower() == sign.lower()
    
    @staticmethod
    def generate_signature(params, server_key):
        """生成签名"""
        # 1. 参数按字母顺序排序
        sorted_params = OrderedDict(sorted(params.items()))
        
        # 2. 拼接参数
        string_to_sign = '&'.join(
            f"{key}={value}" for key, value in sorted_params.items()
        )
        
        # 3. 追加ServerKey
        string_to_sign += f"&server_key={server_key}"
        
        # 4. HMAC-SHA256加密
        hmac_obj = hmac.new(
            server_key.encode('utf-8'),
            string_to_sign.encode('utf-8'),
            hashlib.sha256
        )
        
        # 5. 返回小写十六进制
        return hmac_obj.hexdigest().lower()
    
    @staticmethod
    def verify_timestamp(timestamp, max_age=300):
        """验证时间戳（防止重放攻击）"""
        current_time = int(time.time())
        return abs(current_time - timestamp) <= max_age

from flask import Flask, request, jsonify
from signature_util import SignatureUtil

app = Flask(__name__)

@app.route('/api/miluo/callback', methods=['POST'])
def handle_callback():
    # 获取所有参数
    params = request.form.to_dict()
    
    # 获取签名
    sign = params.get('sign')
    if not sign:
        return jsonify({'error': 'signature missing'}), 400
    
    # 验证时间戳
    timestamp = int(params.get('timestamp', 0))
    if not SignatureUtil.verify_timestamp(timestamp):
        return jsonify({'error': 'timestamp expired'}), 400
    
    # 验证签名
    server_key = 'YOUR_SERVER_KEY'
    if not SignatureUtil.verify_signature(params, server_key, sign):
        return jsonify({'error': 'invalid signature'}), 400
    
    # 处理业务逻辑
    order_id = params.get('order_id')
    status = params.get('status')
    
    if status == 'success':
        # 更新订单状态
        process_order_success(order_id)
    
    return jsonify({'status': 'success'})

if __name__ == '__main__':
    app.run(port=5000)

const crypto = require('crypto');

class SignatureUtil {
    
    /**
     * 验证签名
     */
    static verifySignature(params, serverKey, sign) {
        const calculatedSign = this.generateSignature(params, serverKey);
        return calculatedSign.toLowerCase() === sign.toLowerCase();
    }
    
    /**
     * 生成签名
     */
    static generateSignature(params, serverKey) {
        // 1. 参数按字母顺序排序
        const sortedKeys = Object.keys(params).sort();
        
        // 2. 拼接参数
        const stringToSign = sortedKeys
            .map(key => `${key}=${params[key]}`)
            .join('&');
        
        // 3. 追加ServerKey
        const signString = `${stringToSign}&server_key=${serverKey}`;
        
        // 4. HMAC-SHA256加密
        const hmac = crypto.createHmac('sha256', serverKey);
        hmac.update(signString, 'utf8');
        
        // 5. 返回小写十六进制
        return hmac.digest('hex').toLowerCase();
    }
    
    /**
     * 验证时间戳
     */
    static verifyTimestamp(timestamp, maxAge = 300) {
        const currentTime = Math.floor(Date.now() / 1000);
        return Math.abs(currentTime - timestamp) <= maxAge;
    }
}

module.exports = SignatureUtil;

const express = require('express');
const SignatureUtil = require('./signature');

const app = express();
app.use(express.urlencoded({ extended: true }));

app.post('/api/miluo/callback', (req, res) => {
    const params = req.body;
    
    // 获取签名
    const sign = params.sign;
    if (!sign) {
        return res.status(400).json({ error: 'signature missing' });
    }
    
    // 验证时间戳
    const timestamp = parseInt(params.timestamp || 0);
    if (!SignatureUtil.verifyTimestamp(timestamp)) {
        return res.status(400).json({ error: 'timestamp expired' });
    }
    
    // 验证签名
    const serverKey = 'YOUR_SERVER_KEY';
    if (!SignatureUtil.verifySignature(params, serverKey, sign)) {
        return res.status(400).json({ error: 'invalid signature' });
    }
    
    // 处理业务逻辑
    const orderId = params.order_id;
    const status = params.status;
    
    if (status === 'success') {
        // 更新订单状态
        processOrderSuccess(orderId);
    }
    
    res.json({ status: 'success' });
});

app.listen(3000, () => {
    console.log('Server running on port 3000');
});

package miluosdk

import (
	"crypto/hmac"
	"crypto/sha256"
	"encoding/hex"
	"fmt"
	"math"
	"sort"
	"time"
)

type SignatureUtil struct{}

// VerifySignature 验证签名
func (s *SignatureUtil) VerifySignature(params map[string]string, serverKey, sign string) bool {
	calculatedSign := s.GenerateSignature(params, serverKey)
	return calculatedSign == sign
}

// GenerateSignature 生成签名
func (s *SignatureUtil) GenerateSignature(params map[string]string, serverKey string) string {
	// 1. 参数按字母顺序排序
	keys := make([]string, 0, len(params))
	for k := range params {
		keys = append(keys, k)
	}
	sort.Strings(keys)
	
	// 2. 拼接参数
	var stringToSign string
	for i, key := range keys {
		if i > 0 {
			stringToSign += "&"
		}
		stringToSign += fmt.Sprintf("%s=%s", key, params[key])
	}
	
	// 3. 追加ServerKey
	stringToSign += fmt.Sprintf("&server_key=%s", serverKey)
	
	// 4. HMAC-SHA256加密
	mac := hmac.New(sha256.New, []byte(serverKey))
	mac.Write([]byte(stringToSign))
	
	// 5. 返回小写十六进制
	return hex.EncodeToString(mac.Sum(nil))
}

// VerifyTimestamp 验证时间戳
func (s *SignatureUtil) VerifyTimestamp(timestamp int64, maxAge int64) bool {
	currentTime := time.Now().Unix()
	return int64(math.Abs(float64(currentTime-timestamp))) <= maxAge
}

package main

import (
	"net/http"
	"miluosdk"
	"github.com/gin-gonic/gin"
)

var sigUtil = &miluosdk.SignatureUtil{}

func handleCallback(c *gin.Context) {
	// 获取所有参数
	params := make(map[string]string)
	for key, values := range c.Request.Form {
		if len(values) > 0 {
			params[key] = values[0]
		}
	}
	
	// 获取签名
	sign, exists := params["sign"]
	if !exists {
		c.JSON(http.StatusBadRequest, gin.H{"error": "signature missing"})
		return
	}
	
	// 验证时间戳
	timestamp := parseInt64(params["timestamp"])
	if !sigUtil.VerifyTimestamp(timestamp, 300) {
		c.JSON(http.StatusBadRequest, gin.H{"error": "timestamp expired"})
		return
	}
	
	// 验证签名
	serverKey := "YOUR_SERVER_KEY"
	if !sigUtil.VerifySignature(params, serverKey, sign) {
		c.JSON(http.StatusBadRequest, gin.H{"error": "invalid signature"})
		return
	}
	
	// 处理业务逻辑
	orderId := params["order_id"]
	status := params["status"]
	
	if status == "success" {
		// 更新订单状态
		processOrderSuccess(orderId)
	}
	
	c.JSON(http.StatusOK, gin.H{"status": "success"})
}

func main() {
	r := gin.Default()
	r.POST("/api/miluo/callback", handleCallback)
	r.Run(":8080")
}

{
    "status": "success"
}

{
    "status": "fail",
    "error": "错误描述"
}

@RestController
@RequestMapping("/api/miluo")
public class PaymentCallbackController {
    
    @Autowired
    private OrderService orderService;
    
    @Value("${miluo.server-key}")
    private String serverKey;
    
    @PostMapping("/callback")
    public String handleCallback(HttpServletRequest request) {
        try {
            // 1. 获取参数
            Map<String, String> params = getParams(request);
            
            // 2. 验证签名
            String sign = params.get("sign");
            if (sign == null || !SignatureUtil.verifySignature(params, serverKey, sign)) {
                log.error("签名验证失败");
                return buildResponse("fail", "invalid signature");
            }
            
            // 3. 验证时间戳
            long timestamp = Long.parseLong(params.get("timestamp"));
            if (!isTimestampValid(timestamp)) {
                log.error("时间戳过期");
                return buildResponse("fail", "timestamp expired");
            }
            
            // 4. 处理订单（保证幂等性）
            String orderId = params.get("order_id");
            String status = params.get("status");
            
            if ("success".equals(status)) {
                orderService.processPaymentSuccess(
                    orderId,
                    params.get("miluo_order_id"),
                    Integer.parseInt(params.get("amount")),
                    params.get("pay_channel"),
                    params.get("pay_time")
                );
            } else {
                orderService.processPaymentFailed(orderId);
            }
            
            // 5. 返回成功
            return buildResponse("success", null);
            
        } catch (Exception e) {
            log.error("处理回调异常", e);
            return buildResponse("fail", "internal error");
        }
    }
    
    private Map<String, String> getParams(HttpServletRequest request) {
        Map<String, String> params = new HashMap<>();
        Enumeration<String> names = request.getParameterNames();
        while (names.hasMoreElements()) {
            String name = names.nextElement();
            params.put(name, request.getParameter(name));
        }
        return params;
    }
    
    private boolean isTimestampValid(long timestamp) {
        long currentTime = System.currentTimeMillis() / 1000;
        return Math.abs(currentTime - timestamp) <= 300; // 5分钟
    }
    
    private String buildResponse(String status, String error) {
        if ("success".equals(status)) {
            return "{\"status\":\"success\"}";
        }
        return "{\"status\":\"fail\",\"error\":\"" + error + "\"}";
    }
}

URL: https://api.miluosdk.com/v1/order/query
Method: POST
Content-Type: application/json

{
    "code": 200,
    "message": "success",
    "data": {
        "order_id": "ORDER_20241215001",
        "miluo_order_id": "ML202412150001",
        "amount": 1000,
        "status": "paid",
        "pay_channel": "wechat",
        "pay_time": "2024-12-15 10:30:00"
    }
}

URL: https://api.miluosdk.com/v1/order/refund
Method: POST
Content-Type: application/json

URL: https://api.miluosdk.com/v1/user/info
Method: POST
Content-Type: application/json