多语言客户端实现

以下是常用编程语言的官方库，用于连接和调用 iClick API。

快速安装

Node.js、Python 和 C# 用户可以直接通过包管理器安装，无需手动实现客户端：

• Node.js: npm install iclick-auto - 🔗 NPM
• Python: pip install iclick-auto - 🔗 PyPI
• C#: Install-Package iclick-auto - 🔗 NuGet

以上包都实现了API调用和事件监听以及带MetaData二进制流解析

其他语言

以下代码示例可能未经充分验证，仅供参考学习。在生产环境使用前，请务必进行充分的测试和验证。

const wserverPort = 23188
const wsevents = {}
let wsclient = null
let reconnectTimer = null

export function reconnect() {
    if( reconnectTimer || wsclient?.readyState === WebSocket.CONNECTING ){
        return
    }
    reconnectTimer = setTimeout(() => {
        console.log('API服务重连中...')
        connectServer().finally(() => reconnectTimer = null)
    }, 1000 * 3)
}

export function connectServer() {
    return new Promise((_resolve) => {
        
        if( wsclient ){
            return
        }

        wsclient = new WebSocket(`ws://127.0.0.1:${wserverPort}`)
        wsclient.binaryType = 'arraybuffer'

        wsclient.onopen = () => {
            console.log('API服务连接成功')
            _resolve()
        }

        wsclient.onmessage = (_message) => {
     
            let _payload = _message.data,
                _bindata = null

            if( typeof _payload === 'string' ){

                _payload = JSON.parse(_payload)

            }else{

                // 部分接口返回的是二进制数据，需要解析 [metaDataLength][metaData][binary]
                const _decoder = new TextDecoder('utf-8')   
                const _metaLength = _decoder.decode(_payload.slice(0, 6))
                                    _bindata = _payload.slice(6 + parseInt(_metaLength))
                                    _payload = JSON.parse(_decoder.decode(_payload.slice(6, 6 + parseInt(_metaLength))))
                _payload.data = _bindata
                _bindata = null
            }
            
            const _eventId = _payload.evtid
            const _event = wsevents[ _eventId ]
  
            if( _event ){

                if( _payload.type === 'error' ){
                    _event.reject(new Error(_payload.error))
                }else{
                    _event.resolve( _payload.data )
                }

                delete wsevents[ _eventId ]

            }else if( _payload.event ){

                //你可以根据不同语言派发事件
            }
        }
        
        wsclient.onclose = (code) => {

            wsclient = null
            console.log('API服务连接关闭:', code)
            reconnect()
        }
        
        wsclient.onerror = (err) => {
            console.error('API服务连接错误:', err)
        }
    })
}


export function apiInvoke(type, _params = {}, _timeout = 18) {

    return new Promise((resolve, reject) => {

        if( !wsclient || wsclient.readyState !== WebSocket.OPEN ){

            reject( new Error('API服务连接未就绪') )

        }else{

            const _eventId = Math.random().toString(36).substring(2, 12)
            const _payload = {
                ..._params,
                type,
                evtid: _eventId,
                timeout: _timeout
            }

            wsevents[_payload.evtid] = { resolve, reject }

            wsclient.send(JSON.stringify(_payload))

            if( _timeout > 0 ){
                setTimeout(() => {

                    reject(new Error(`API服务: ${_payload.evtid} Invoke Timeout !`))

                    delete wsevents[_payload.evtid]

                }, _timeout * 1000)
            }
        }
    })
}

// 使用示例
await connectServer()
const result = await apiInvoke('click', { x: 100, y: 200, deviceId: 'XXXXXXXXXX' })

import org.java_websocket.client.WebSocketClient;
import org.java_websocket.handshake.ServerHandshake;
import com.google.gson.Gson;
import com.google.gson.JsonObject;
import java.net.URI;
import java.nio.ByteBuffer;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.*;
import java.util.concurrent.atomic.AtomicBoolean;
import java.security.SecureRandom;

public class IClient {
    private static final int PORT = 23188;
    private static final SecureRandom RANDOM = new SecureRandom();
    private static final String CHARS = "abcdefghijklmnopqrstuvwxyz0123456789";
    
    private WebSocketClient wsClient;
    private final ConcurrentHashMap<String, CompletableFuture<Object>> events = new ConcurrentHashMap<>();
    private final Gson gson = new Gson();
    private final ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();
    private final AtomicBoolean isReconnecting = new AtomicBoolean(false);
    
    public synchronized void connect() throws Exception {
        // 关闭旧连接
        if (wsClient != null) {
            wsClient.close();
        }
        
        URI uri = new URI("ws://127.0.0.1:" + PORT);
        wsClient = new WebSocketClient(uri) {
            @Override
            public void onOpen(ServerHandshake handshake) {
                System.out.println("API服务连接成功");
                isReconnecting.set(false);
            }
            
            @Override
            public void onMessage(String message) {
                handleMessage(gson.fromJson(message, JsonObject.class));
            }
            
            @Override
            public void onMessage(ByteBuffer bytes) {
                byte[] data = bytes.array();
                int metaLength = Integer.parseInt(new String(data, 0, 6, StandardCharsets.UTF_8).trim());
                String metaJson = new String(data, 6, metaLength, StandardCharsets.UTF_8);
                handleMessage(gson.fromJson(metaJson, JsonObject.class));
            }
            
            @Override
            public void onClose(int code, String reason, boolean remote) {
                System.out.println("API服务连接关闭: " + code);
                reconnect();
            }
            
            @Override
            public void onError(Exception ex) {
                System.err.println("API服务连接错误: " + ex.getMessage());
            }
        };
        
        wsClient.connect();
    }
    
    private void handleMessage(JsonObject payload) {
        if (!payload.has("evtid")) return;
        
        String evtid = payload.get("evtid").getAsString();
        CompletableFuture<Object> future = events.remove(evtid);
        
        if (future != null) {
            if (payload.has("type") && "error".equals(payload.get("type").getAsString())) {
                future.completeExceptionally(new Exception(payload.get("error").getAsString()));
            } else {
                future.complete(payload.get("data"));
            }
        }
    }
    
    private void reconnect() {
        if (!isReconnecting.compareAndSet(false, true)) return;
        
        scheduler.schedule(() -> {
            try {
                System.out.println("API服务重连中...");
                connect();
            } catch (Exception e) {
                System.err.println("重连失败: " + e.getMessage());
                isReconnecting.set(false);
            }
        }, 3, TimeUnit.SECONDS);
    }
    
    private static String generateEventId() {
        StringBuilder sb = new StringBuilder(10);
        for (int i = 0; i < 10; i++) {
            sb.append(CHARS.charAt(RANDOM.nextInt(CHARS.length())));
        }
        return sb.toString();
    }
    
    public CompletableFuture<Object> invoke(String type, Map<String, Object> params, int timeout) {
        CompletableFuture<Object> future = new CompletableFuture<>();
        
        if (wsClient == null || !wsClient.isOpen()) {
            future.completeExceptionally(new Exception("API服务连接未就绪"));
            return future;
        }
        
        String evtid = generateEventId();
        Map<String, Object> payload = new HashMap<>(params != null ? params : new HashMap<>());
        payload.put("type", type);
        payload.put("evtid", evtid);
        payload.put("timeout", timeout);
        
        events.put(evtid, future);
        wsClient.send(gson.toJson(payload));
        
        // 设置超时
        scheduler.schedule(() -> {
            CompletableFuture<Object> f = events.remove(evtid);
            if (f != null) {
                f.completeExceptionally(new TimeoutException("API服务超时"));
            }
        }, timeout, TimeUnit.SECONDS);
        
        return future;
    }
    
    public void close() {
        scheduler.shutdown();
        if (wsClient != null) {
            wsClient.close();
        }
    }
    
    // 使用示例
    public static void main(String[] args) throws Exception {
        IClient client = new IClient();
        client.connect();
        Thread.sleep(1000);
        
        Map<String, Object> params = new HashMap<>();
        params.put("x", 100);
        params.put("y", 200);
        params.put("deviceId", "XXXXXXXXXX");
        
        client.invoke("click", params, 18)
            .thenAccept(result -> System.out.println("点击结果: " + result))
            .exceptionally(ex -> {
                System.err.println("调用失败: " + ex.getMessage());
                return null;
            })
            .thenRun(client::close);
    }
}

package main

import (
    "encoding/json"
    "fmt"
    "math/rand"
    "sync"
    "time"
    
    "github.com/gorilla/websocket"
)

type IClient struct {
    port            int
    conn            *websocket.Conn
    events          map[string]chan Response
    eventsMutex     sync.RWMutex
    reconnectMutex  sync.Mutex
    isReconnecting  bool
}

type Response struct {
    Data  interface{}
    Error error
}

type Payload struct {
    Type    string                 `json:"type,omitempty"`
    EvtID   string                 `json:"evtid,omitempty"`
    Timeout int                    `json:"timeout,omitempty"`
    Event   string                 `json:"event,omitempty"`
    Data    interface{}            `json:"data,omitempty"`
    Error   string                 `json:"error,omitempty"`
}

func NewIClient() *IClient {
    return &IClient{
        port:   23188,
        events: make(map[string]chan Response),
    }
}

func (c *IClient) Connect() error {
    // 关闭旧连接
    if c.conn != nil {
        c.conn.Close()
    }
    
    url := fmt.Sprintf("ws://127.0.0.1:%d", c.port)
    
    conn, _, err := websocket.DefaultDialer.Dial(url, nil)
    if err != nil {
        return fmt.Errorf("连接失败: %w", err)
    }
    
    c.conn = conn
    fmt.Println("API服务连接成功")
    
    go c.messageHandler()
    
    return nil
}

func (c *IClient) messageHandler() {
    defer func() {
        fmt.Println("API服务连接关闭")
        c.reconnect()
    }()
    
    for {
        messageType, message, err := c.conn.ReadMessage()
        if err != nil {
            return
        }
        
        var payload Payload
        
        switch messageType {
        case websocket.TextMessage:
            if err := json.Unmarshal(message, &payload); err != nil {
                fmt.Printf("解析JSON错误: %v\n", err)
                continue
            }
        case websocket.BinaryMessage:
            // 解析二进制消息
            var metaLength int
            fmt.Sscanf(string(message[:6]), "%d", &metaLength)
            if err := json.Unmarshal(message[6:6+metaLength], &payload); err != nil {
                fmt.Printf("解析元数据错误: %v\n", err)
                continue
            }
            payload.Data = message[6+metaLength:]
        }
        
        c.processPayload(payload)
    }
}

func (c *IClient) processPayload(payload Payload) {
    if payload.EvtID != "" {
        c.eventsMutex.RLock()
        ch, exists := c.events[payload.EvtID]
        c.eventsMutex.RUnlock()
        
        if exists {
            response := Response{Data: payload.Data}
            if payload.Type == "error" {
                response.Error = fmt.Errorf("%s", payload.Error)
            }
            
            ch <- response
            
            c.eventsMutex.Lock()
            delete(c.events, payload.EvtID)
            c.eventsMutex.Unlock()
        }
    }
}

func (c *IClient) reconnect() {
    c.reconnectMutex.Lock()
    if c.isReconnecting {
        c.reconnectMutex.Unlock()
        return
    }
    c.isReconnecting = true
    c.reconnectMutex.Unlock()
    
    time.Sleep(3 * time.Second)
    fmt.Println("API服务重连中...")
    
    if err := c.Connect(); err != nil {
        fmt.Printf("重连失败: %v\n", err)
    }
    
    c.reconnectMutex.Lock()
    c.isReconnecting = false
    c.reconnectMutex.Unlock()
}

func (c *IClient) generateEventID() string {
    return fmt.Sprintf("%d%03d", time.Now().UnixNano()%1000000000, rand.Intn(1000))
}

func (c *IClient) Invoke(apiType string, params map[string]interface{}, timeout int) (interface{}, error) {
    if c.conn == nil {
        return nil, fmt.Errorf("API服务连接未就绪")
    }
    
    evtID := c.generateEventID()
    payload := map[string]interface{}{
        "type":    apiType,
        "evtid":   evtID,
        "timeout": timeout,
    }
    for k, v := range params {
        payload[k] = v
    }
    
    ch := make(chan Response, 1)
    c.eventsMutex.Lock()
    c.events[evtID] = ch
    c.eventsMutex.Unlock()
    
    data, _ := json.Marshal(payload)
    if err := c.conn.WriteMessage(websocket.TextMessage, data); err != nil {
        c.eventsMutex.Lock()
        delete(c.events, evtID)
        c.eventsMutex.Unlock()
        return nil, fmt.Errorf("发送消息失败: %w", err)
    }
    
    select {
    case response := <-ch:
        return response.Data, response.Error
    case <-time.After(time.Duration(timeout) * time.Second):
        c.eventsMutex.Lock()
        delete(c.events, evtID)
        c.eventsMutex.Unlock()
        return nil, fmt.Errorf("API服务超时")
    }
}

func (c *IClient) Close() error {
    if c.conn != nil {
        return c.conn.Close()
    }
    return nil
}

// 使用示例
func main() {
    client := NewIClient()
    if err := client.Connect(); err != nil {
        fmt.Printf("连接失败: %v\n", err)
        return
    }
    defer client.Close()
    
    time.Sleep(time.Second)
    
    params := map[string]interface{}{
        "x": 100,
        "y": 200,
        "deviceId": "XXXXXXXXXX",
    }
    
    result, err := client.Invoke("click", params, 18)
    if err != nil {
        fmt.Printf("调用失败: %v\n", err)
        return
    }
    
    fmt.Printf("点击结果: %v\n", result)
}

下一步

• 阅读更具体的 API 使用示例