WuKongIM

https://github.com/wukongim/wukongimdocs
Admin
WuKongIM is a high-performance, distributed instant messaging service designed to be as simple as...
Tokens:615,515
Snippets:4,274
Trust Score:7.2
Update:2 months ago
Show doc for...
Tokens:
Raw
### Setup()

Source: https://github.com/wukongim/wukongimdocs/blob/main/zh/getting-started/learning/plugin-development.mdx

Initializes plugin resources and establishes connections when the plugin starts.

```APIDOC
## Setup()

### Description
Called when the plugin starts. Used for initializing plugin resources and establishing database connections.

### Signature
`func (a *AIExample) Setup()`
```

--------------------------------

### Complete Channel Information Implementation Example

Source: https://github.com/wukongim/wukongimdocs/blob/main/en/sdk/wukongim/javascript/channel.mdx

A comprehensive example demonstrating how to manage channel information, including listener setup, cache checking, and UI updates.

```javascript
class ChannelInfoManager {
    constructor() {
        this.setupChannelListener();
    }
    
    setupChannelListener() {
        // Listen for channel information updates
        const channelInfoListener = (channelInfo) => {
            this.handleChannelInfoUpdate(channelInfo);
        };
        
        WKSDK.shared().channelManager.addListener(channelInfoListener);
        
        // Store listener reference for cleanup
        this.channelInfoListener = channelInfoListener;
    }
    
    async loadChannelInfo(channel) {
        // First try to get from cache
        let channelInfo = WKSDK.shared().channelManager.getChannelInfo(channel);
        
        if (channelInfo) {
            // Use cached data
            this.updateUI(channelInfo);
        } else {
            // Fetch from server
            this.showLoading();
            await WKSDK.shared().channelManager.fetchChannelInfo(channel);
            // The listener will handle the update
        }
    }
    
    handleChannelInfoUpdate(channelInfo) {
        console.log('Channel info updated:', channelInfo);
        this.updateUI(channelInfo);
        this.hideLoading();
    }
    
    updateUI(channelInfo) {
        // Update channel title
        document.getElementById('channel-title').textContent = channelInfo.title;
        
        // Update channel avatar
        document.getElementById('channel-avatar').src = channelInfo.logo;
        
        // Update pin status
        const pinButton = document.getElementById('pin-button');
        pinButton.classList.toggle('active', channelInfo.top);
        
        // Update mute status
        const muteButton = document.getElementById('mute-button');
        muteButton.classList.toggle('active', channelInfo.mute);
        
        // Update online status
        const onlineIndicator = document.getElementById('online-indicator');
        onlineIndicator.classList.toggle('online', channelInfo.online);
    }
    
    cleanup() {
        if (this.channelInfoListener) {
            WKSDK.shared().channelManager.removeListener(this.channelInfoListener);
        }
    }
}
```

--------------------------------

### Install and Start Grafana

Source: https://github.com/wukongim/wukongimdocs/blob/main/en/installation/linux/monitoring.mdx

Commands to add the Grafana repository, install the server, and enable it on Linux systems.

```bash
# Add Grafana repository
sudo apt-get install -y software-properties-common
sudo add-apt-repository "deb https://packages.grafana.com/oss/deb stable main"
wget -q -O - https://packages.grafana.com/gpg.key | sudo apt-key add -

# Install Grafana
sudo apt-get update
sudo apt-get install grafana

# Start Grafana
sudo systemctl enable grafana-server
sudo systemctl start grafana-server
```

--------------------------------

### Run Installation Command

Source: https://github.com/wukongim/wukongimdocs/blob/main/en/sdk/wukongim/ios/integration.mdx

Execute the installation command in your terminal.

```bash
pod install
```

--------------------------------

### Start Services

Source: https://github.com/wukongim/wukongimdocs/blob/main/zh/installation/docker/multi-node.mdx

Commands to start the gateway and WuKongIM nodes.

```bash
# 在 gateway 节点
cd ~/gateway
docker-compose up -d
```

```bash
# 在每个 WuKongIM 节点
cd ~/wukongim
docker-compose up -d
```

--------------------------------

### Complete WuKongIM Configuration Example

Source: https://github.com/wukongim/wukongimdocs/blob/main/en/installation/linux/monitoring.mdx

A full example of a wk.yaml configuration file including cluster, external, monitoring, and logging settings.

```yaml
mode: "release"
rootDir: "./wukongim_data"

# Cluster configuration (for multi-node)
cluster:
  nodeId: 1001
  serverAddr: "10.206.0.13:11110"
  apiUrl: "http://10.206.0.13:5001"
  initNodes:
    - "1001@10.206.0.13:11110"
    - "1002@10.206.0.14:11110"
    - "1003@10.206.0.8:11110"

# External configuration
external:
  ip: "119.45.229.172"
  tcpAddr: "119.45.229.172:15100"
  wsAddr: "ws://119.45.229.172:15200"

# Monitoring configuration
trace:
  prometheusApiUrl: "http://10.206.0.13:9090"
  
# Logging configuration
logger:
  level: "info"
  dir: "./logs"
```

--------------------------------

### Create Installation Directory

Source: https://github.com/wukongim/wukongimdocs/blob/main/en/installation/docker/single-node.mdx

Commands to create and enter the directory for WuKongIM installation.

```bash
# Create directory
mkdir ~/wukongim
cd ~/wukongim
```

--------------------------------

### Install via NPM

Source: https://github.com/wukongim/wukongimdocs/blob/main/en/sdk/wukongim/javascript/intro.mdx

Use this command to install the SDK package in your project.

```bash
npm install wukongim-js-sdk
```

--------------------------------

### Start Services

Source: https://github.com/wukongim/wukongimdocs/blob/main/en/installation/docker/multi-node.mdx

Commands to start the gateway and WuKongIM nodes using Docker Compose.

```bash
# On gateway node
cd ~/gateway
docker-compose up -d
```

```bash
# On each WuKongIM node
cd ~/wukongim
docker-compose up -d
```

--------------------------------

### Create Installation Directory

Source: https://github.com/wukongim/wukongimdocs/blob/main/en/installation/docker/scaling.mdx

Commands to prepare the directory structure on the new node.

```bash
mkdir ~/wukongim
```

```bash
cd ~/wukongim
```

--------------------------------

### Install EasyJSSDK

Source: https://github.com/wukongim/wukongimdocs/blob/main/en/sdk/easy/javascript/getting-started.mdx

Methods to install the SDK via package managers or CDN.

```bash
npm install easyjssdk
```

```bash
yarn add easyjssdk
```

```html
<script src="https://unpkg.com/easyjssdk@latest/dist/easyjssdk.min.js"></script>
```

--------------------------------

### Start WuKongIM Service

Source: https://github.com/wukongim/wukongimdocs/blob/main/en/installation/linux/scaling.mdx

Start the WuKongIM process using the generated configuration file.

```bash
./wukongim --config wk.yaml -d
```

--------------------------------

### Install WuKongIM SDK

Source: https://github.com/wukongim/wukongimdocs/blob/main/en/sdk/wukongim/javascript/integration.mdx

Commands to install the SDK using common JavaScript package managers.

```bash
npm i wukongimjssdk
```

```bash
yarn add wukongimjssdk
```

```bash
pnpm add wukongimjssdk
```

```bash
bun add wukongimjssdk
```

--------------------------------

### Quick Start Initialization and Messaging

Source: https://github.com/wukongim/wukongimdocs/blob/main/en/sdk/wukongim/javascript/intro.mdx

Configure the SDK, set up a message listener, and connect to the server to send messages.

```javascript
// Initialize SDK
const sdk = WKSDK.shared();

// Configure connection
sdk.config({
  addr: "ws://your-server.com:5200",
  apiURL: "http://your-api-server.com",
  uid: "user123",
  token: "user-token"
});

// Listen for messages
sdk.chatManager.addMessageListener((message) => {
  console.log('New message:', message);
});

// Connect to server
await sdk.connectionManager.connect();

// Send message
await sdk.chatManager.send({
  channel_id: "friend_user_id",
  channel_type: 1,
  content: "Hello from JavaScript SDK!"
});
```

--------------------------------

### Initialize Plugin Project

Source: https://github.com/wukongim/wukongimdocs/blob/main/en/getting-started/learning/plugin-development.mdx

Create a new Go module and install the WuKongIM PDK dependency.

```bash
mkdir my-plugin
cd my-plugin
go mod init my-plugin
go get github.com/WuKongIM/go-pdk
```

--------------------------------

### WKIM.shared.setup

Source: https://github.com/wukongim/wukongimdocs/blob/main/en/sdk/wukongim/flutter/base.mdx

Initializes the SDK with user authentication credentials.

```APIDOC
## WKIM.shared.setup

### Description
Initializes the SDK instance using the provided user ID and token obtained from your business server.

### Parameters
- **options** (Options) - Required - An options object created via `Options.newDefault(uid, token)`.
```

--------------------------------

### Get Migration Result API Requests

Source: https://github.com/wukongim/wukongimdocs/blob/main/en/api/system/migrate.mdx

Examples of how to query the migration status endpoint using various programming languages.

```bash
curl -X GET "http://localhost:5001/migrate/result"
```

```javascript
const response = await fetch('http://localhost:5001/migrate/result');
const data = await response.json();
console.log(data);
```

```python
import requests

response = requests.get('http://localhost:5001/migrate/result')
data = response.json()
print(data)
```

```go
package main

import (
    "encoding/json"
    "fmt"
    "net/http"
)

func main() {
    resp, err := http.Get("http://localhost:5001/migrate/result")
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    
    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)
    fmt.Printf("%+v\n", result)
}
```

--------------------------------

### Get IM Address via API

Source: https://github.com/wukongim/wukongimdocs/blob/main/en/api/route/get-address.mdx

Examples for retrieving the IM connection address using various programming languages.

```bash
curl -X GET "http://localhost:5001/route?intranet=0"
```

```javascript
const response = await fetch('http://localhost:5001/route?intranet=0');
const data = await response.json();
console.log(data);
```

```python
import requests

response = requests.get('http://localhost:5001/route', params={'intranet': 0})
data = response.json()
print(data)
```

```go
package main

import (
    "encoding/json"
    "fmt"
    "net/http"
)

func main() {
    resp, err := http.Get("http://localhost:5001/route?intranet=0")
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    
    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)
    fmt.Printf("%+v\n", result)
}
```

--------------------------------

### Implement WuKongIM Plugins

Source: https://github.com/wukongim/wukongimdocs/blob/main/en/getting-started/learning/plugin-development.mdx

Examples demonstrating the structure for user-specific and global plugins using the WuKongIM PDK.

```go
package main

import (
    "encoding/json"
    "fmt"
    "github.com/WuKongIM/go-pdk"
)

// Define plugin configuration struct
type Config struct {
    Name string `json:"name" label:"AI Name"` // json is config item name, label is display name in WuKongIM backend
}

// Plugin struct
type AIExample struct {
    Config Config // Plugin configuration, name must be Config
}

// Plugin initialization
func (a *AIExample) Init() error {
    pdk.Log.Info("AI plugin initialized", pdk.Any("config", a.Config))
    return nil
}

// Plugin information
func (a *AIExample) Info() pdk.PluginInfo {
    return pdk.PluginInfo{
        Uid:         "ai_example",           // Plugin unique ID
        Name:        "AI Example Plugin",    // Plugin name
        Description: "AI chat example plugin", // Plugin description
        Version:     "1.0.0",               // Plugin version
        Type:        pdk.PluginTypeUser,    // Plugin type: user plugin
    }
}

// Receive message processing
func (a *AIExample) Receive(message pdk.Message) error {
    // Parse message content
    var content map[string]interface{}
    if err := json.Unmarshal([]byte(message.Payload), &content); err != nil {
        return err
    }
    
    // Get message text
    text, ok := content["content"].(string)
    if !ok {
        return fmt.Errorf("invalid message content")
    }
    
    // AI processing logic (simplified example)
    response := fmt.Sprintf("AI %s replies: I received your message '%s'", a.Config.Name, text)
    
    // Send reply message
    replyContent := map[string]interface{}{
        "type":    "text",
        "content": response,
    }
    
    replyPayload, _ := json.Marshal(replyContent)
    
    return pdk.SendMessage(pdk.SendMessageReq{
        ChannelId:   message.ChannelId,
        ChannelType: message.ChannelType,
        Payload:     string(replyPayload),
    })
}

// Plugin entry point
func main() {
    plugin := &AIExample{}
    pdk.Run(plugin)
}
```

```go
package main

import (
    "encoding/json"
    "strings"
    "github.com/WuKongIM/go-pdk"
)

type SensitiveWordFilter struct {
    Config struct {
        Words []string `json:"words" label:"Sensitive Words"`
    }
}

func (s *SensitiveWordFilter) Init() error {
    pdk.Log.Info("Sensitive word filter initialized")
    return nil
}

func (s *SensitiveWordFilter) Info() pdk.PluginInfo {
    return pdk.PluginInfo{
        Uid:         "sensitive_filter",
        Name:        "Sensitive Word Filter",
        Description: "Filter sensitive words in messages",
        Version:     "1.0.0",
        Type:        pdk.PluginTypeGlobal, // Global plugin
    }
}

func (s *SensitiveWordFilter) Receive(message pdk.Message) error {
    var content map[string]interface{}
    if err := json.Unmarshal([]byte(message.Payload), &content); err != nil {
        return err
    }
    
    text, ok := content["content"].(string)
    if !ok {
        return nil
    }
    
    // Check for sensitive words
    for _, word := range s.Config.Words {
        if strings.Contains(text, word) {
            pdk.Log.Warn("Sensitive word detected", 
                pdk.String("word", word),
                pdk.String("message", text))
            
            // Block message or replace with ***
            content["content"] = strings.ReplaceAll(text, word, "***")
            newPayload, _ := json.Marshal(content)
            
            // Update message content
            return pdk.UpdateMessage(pdk.UpdateMessageReq{
                MessageId: message.MessageId,
                Payload:   string(newPayload),
            })
        }
    }
    
    return nil
}

func main() {
    plugin := &SensitiveWordFilter{}
    pdk.Run(plugin)
}
```

--------------------------------

### Get Channel Whitelist API Requests

Source: https://github.com/wukongim/wukongimdocs/blob/main/en/api/channel/get-whitelist.mdx

Examples of how to query the channel whitelist endpoint using various programming languages.

```bash
curl -X GET "http://localhost:5001/channel/whitelist?channel_id=group123&channel_type=2"
```

```javascript
const response = await fetch('http://localhost:5001/channel/whitelist?channel_id=group123&channel_type=2');
const data = await response.json();
console.log(data);
```

```python
import requests

params = {
    'channel_id': 'group123',
    'channel_type': 2
}

response = requests.get('http://localhost:5001/channel/whitelist', params=params)
data = response.json()
print(data)
```

```go
package main

import (
    "encoding/json"
    "fmt"
    "net/http"
    "net/url"
)

func main() {
    baseURL := "http://localhost:5001/channel/whitelist"
    params := url.Values{}
    params.Add("channel_id", "group123")
    params.Add("channel_type", "2")
    
    fullURL := baseURL + "?" + params.Encode()
    
    resp, err := http.Get(fullURL)
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    
    var result []string
    json.NewDecoder(resp.Body).Decode(&result)
    fmt.Printf("%+v\n", result)
}
```

--------------------------------

### Get Max Message Sequence API Requests

Source: https://github.com/wukongim/wukongimdocs/blob/main/en/api/message/max-message-seq.mdx

Examples of how to query the max_message_seq endpoint using various programming languages and tools.

```bash
curl -X GET "http://localhost:5001/channel/max_message_seq?channel_id=group123&channel_type=2&login_uid=user123"
```

```javascript
const response = await fetch('http://localhost:5001/channel/max_message_seq?channel_id=group123&channel_type=2&login_uid=user123');
const data = await response.json();
console.log(data);
```

```python
import requests

params = {
    'channel_id': 'group123',
    'channel_type': 2
}

response = requests.get('http://localhost:5001/channel/max_message_seq&login_uid=user123', params=params)
data = response.json()
print(data)
```

```go
package main

import (
    "encoding/json"
    "fmt"
    "net/http"
)

func main() {
    resp, err := http.Get("http://localhost:5001/channel/max_message_seq?channel_id=group123&channel_type=2&login_uid=user123")
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    
    var result map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)
    fmt.Printf("%+v\n", result)
}
```

--------------------------------

### Quick Start with Docker Compose

Source: https://github.com/wukongim/wukongimdocs/blob/main/en/installation/overview.mdx

Commands to download the configuration file and launch the service for local development.

```bash
# Get started in minutes
curl -O https://raw.githubusercontent.com/WuKongIM/WuKongIM/main/docker-compose.yml
docker-compose up -d
```

--------------------------------

### Initialize SDK

Source: https://github.com/wukongim/wukongimdocs/blob/main/zh/sdk/easy/ios/getting-started.mdx

Configure the SDK with server URL, user ID, and authentication token.

```swift
// 1. 初始化 SDK
let config = WuKongConfig(
    serverUrl: "ws://your-wukongim-server.com:5200",
    uid: "your_user_id",        // 您的用户 ID
    token: "your_auth_token"    // 您的认证 Token
    // deviceId: "optional_device_id", // 可选：设备 ID
    // deviceFlag: .APP // 可选：设备标识，默认为 .APP
)

let easySDK = WuKongEasySDK(config: config)
```

--------------------------------

### Get User Online Status API Requests

Source: https://github.com/wukongim/wukongimdocs/blob/main/en/api/user/online-status.mdx

Examples of how to query user online status using various programming languages.

```bash
curl -X POST "http://localhost:5001/user/onlinestatus" \
  -H "Content-Type: application/json" \
  -d '["user1", "user2", "user3"]'
```

```javascript
const userIds = ["user1", "user2", "user3"];

const response = await fetch('http://localhost:5001/user/onlinestatus', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify(userIds)
});

const data = await response.json();
console.log(data);
```

```python
import requests

user_ids = ["user1", "user2", "user3"]

response = requests.post('http://localhost:5001/user/onlinestatus', json=user_ids)
data = response.json()
print(data)
```

```go
package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
)

func main() {
    userIds := []string{"user1", "user2", "user3"}
    jsonData, _ := json.Marshal(userIds)
    
    resp, err := http.Post(
        "http://localhost:5001/user/onlinestatus",
        "application/json",
        bytes.NewBuffer(jsonData),
    )
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    
    var result []map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)
    fmt.Printf("%+v\n", result)
}
```

--------------------------------

### Animation System Initialization Methods

Source: https://github.com/wukongim/wukongimdocs/blob/main/home/index.html

These methods handle the setup of the canvas, DOM elements, and the asynchronous loading of assets required for the animation to start.

```javascript
/** * Initialize the animation system * Sets up canvas, elements, event listeners, and starts animation */ async init() { this.setupCanvas(); this.setupElements(); this.setupEventListeners(); // Preload icons before starting animation - CRITICAL for strict error handling try { await this.preloadIcons(); console.log('[DEBUG] Icons preloaded successfully'); // Only start animation after icons are loaded this.startAnimation(); console.log('[DEBUG] WuKongIM animation initialized with high-quality icons'); } catch (error) { console.error('[ERROR] Failed to preload icons:', error); throw new Error(`Animation initialization failed: ${error.message}`); } }
```

```javascript
/** * Set up canvas element and rendering context * @returns {boolean} True if setup successful, false otherwise */ setupCanvas() { this.canvas = document.getElementById('wukongim-canvas'); if (!this.canvas) { console.error('[ERROR] Canvas element with id "wukongim-canvas" not found'); return false; } this.ctx = this.canvas.getContext('2d'); if (!this.ctx) { console.error('[ERROR] Failed to get 2D rendering context'); return false; } this.resizeCanvas(); return true; }
```

```javascript
/** * Resize canvas to match container size with device pixel ratio support * Ensures crisp rendering on high-DPI displays */ resizeCanvas() { const rect = this.canvas.getBoundingClientRect(); const devicePixelRatio = window.devicePixelRatio || 1; this.canvas.width = rect.width * devicePixelRatio; this.canvas.height = rect.height * devicePixelRatio; this.ctx.scale(devicePixelRatio, devicePixelRatio); this.canvas.style.width = rect.width + 'px'; this.canvas.style.height = rect.height + 'px'; this.width = rect.width; this.height = rect.height; console.log(`[DEBUG] Canvas resized to ${this.width}x${this.height} (DPR: ${devicePixelRatio})`); }
```

```javascript
/** * Set up all animation elements (message source, channel hub, receivers) */ setupElements() { this.createMessageSource(); this.createChannelHub(); this.updateReceivers(); // Initialize UI elements to match current channel this.initializeUI(); console.log('[DEBUG] Animation elements created'); }
```

--------------------------------

### Implement Environment-Specific Setup

Source: https://github.com/wukongim/wukongimdocs/blob/main/en/sdk/wukongim/harmonyos/integration.mdx

Demonstrates how to switch between development and production configurations, including server address management.

```typescript
class EnvironmentConfig {
  static setupForEnvironment(): void {
    if (this.isDevelopment()) {
      this.setupDevelopment();
    } else {
      this.setupProduction();
    }
  }
  
  private static setupDevelopment(): void {
    const options = new WKOptions();
    options.uid = 'dev_user';
    options.token = 'dev_token';
    options.debugMode = true;
    options.logLevel = WKLogLevel.DEBUG;
    
    WKIM.shared.setup(options);
    WKIM.shared.connectionManager().setServerAddress('dev-server.com', 5100);
  }
  
  private static setupProduction(): void {
    const options = new WKOptions();
    options.uid = await this.getUserId();
    options.token = await this.getAuthToken();
    options.debugMode = false;
    options.logLevel = WKLogLevel.ERROR;
    
    WKIM.shared.setup(options);
    WKIM.shared.connectionManager().setServerAddress('prod-server.com', 5100);
  }
  
  private static isDevelopment(): boolean {
    // Determine if running in development mode
    return true; // Replace with actual logic
  }
  
  private static async getUserId(): Promise<string> {
    // Get user ID from secure storage
    return 'user123';
  }
  
  private static async getAuthToken(): Promise<string> {
    // Get auth token from secure storage
    return 'auth_token';
  }
}
```

--------------------------------

### Batch Get User IM Addresses Request

Source: https://github.com/wukongim/wukongimdocs/blob/main/en/api/route/batch-address.mdx

Examples for requesting IM connection addresses for a list of user IDs across different programming languages.

```bash
curl -X POST "http://localhost:5001/route/batch?intranet=0" \
  -H "Content-Type: application/json" \
  -d '["user1", "user2", "user3"]'
```

```javascript
const userIds = ["user1", "user2", "user3"];

const response = await fetch('http://localhost:5001/route/batch?intranet=0', {
  method: 'POST',
  headers: {
    'Content-Type': 'application/json'
  },
  body: JSON.stringify(userIds)
});

const data = await response.json();
console.log(data);
```

```python
import requests

user_ids = ["user1", "user2", "user3"]

response = requests.post(
    'http://localhost:5001/route/batch',
    params={'intranet': 0},
    json=user_ids
)

data = response.json()
print(data)
```

```go
package main

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
)

func main() {
    userIds := []string{"user1", "user2", "user3"}
    jsonData, _ := json.Marshal(userIds)
    
    resp, err := http.Post(
        "http://localhost:5001/route/batch?intranet=0",
        "application/json",
        bytes.NewBuffer(jsonData),
    )
    if err != nil {
        panic(err)
    }
    defer resp.Body.Close()
    
    var result []map[string]interface{}
    json.NewDecoder(resp.Body).Decode(&result)
    fmt.Printf("%+v\n", result)
}
```

--------------------------------

### Initialize SDK with Custom Configuration

Source: https://github.com/wukongim/wukongimdocs/blob/main/en/sdk/wukongim/android/integration.mdx

Use WKIMOptions to provide custom settings like log levels, database passwords, and server URLs during initialization.

```kotlin
// Kotlin
class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        
        // Initialize with custom configuration
        val options = WKIMOptions().apply {
            logLevel = WKLogLevel.DEBUG
            dbPassword = "your_db_password"
            fileUploadUrl = "https://your-upload-server.com/upload"
            apiUrl = "https://your-api-server.com"
        }
        
        WKIM.getInstance().init(this, options)
    }
}
```

```java
// Java
public class MyApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        
        // Initialize with custom configuration
        WKIMOptions options = new WKIMOptions();
        options.setLogLevel(WKLogLevel.DEBUG);
        options.setDbPassword("your_db_password");
        options.setFileUploadUrl("https://your-upload-server.com/upload");
        options.setApiUrl("https://your-api-server.com");
        
        WKIM.getInstance().init(this, options);
    }
}
```

--------------------------------

### Install TypeScript Definitions

Source: https://github.com/wukongim/wukongimdocs/blob/main/en/sdk/wukongim/javascript/integration.mdx

Install type definitions for TypeScript projects.

```bash
npm install --save-dev @types/wukongimjssdk
```

--------------------------------

### Initialize SDK

Source: https://github.com/wukongim/wukongimdocs/blob/main/en/sdk/easy/javascript/getting-started.mdx

Initialize the SDK with server URL and user credentials.

```javascript
// 1. Initialize SDK
const im = WKIM.init("ws://your-wukongim-server.com:5200", {
    uid: "your_user_id",        // Your user ID
    token: "your_auth_token"    // Your authentication token
    // deviceId: "optional_device_id", // Optional: Device ID
    // deviceFlag: 2 // Optional: Device flag (1:APP, 2:WEB, default is 2)
});
```

--------------------------------

### Complete File Management Example

Source: https://github.com/wukongim/wukongimdocs/blob/main/en/sdk/wukongim/android/datasource.mdx

A comprehensive implementation demonstrating how to route different message types to specific upload handlers.

```java
public class FileManager {
    
    private static final String TAG = "FileManager";
    
    public void initialize() {
        // Set file upload listener
        WKIM.getInstance().getMsgManager().addOnUploadAttachListener(this::handleFileUpload);
    }
    
    private void handleFileUpload(WKMsg wkMsg, IUploadAttacResultListener listener) {
        switch (wkMsg.type) {
            case WKMsgContentType.WK_IMAGE:
                uploadImage(wkMsg, listener);
                break;
            case WKMsgContentType.WK_VIDEO:
                uploadVideo(wkMsg, listener);
                break;
            case WKMsgContentType.WK_VOICE:
                uploadVoice(wkMsg, listener);
                break;
            case WKMsgContentType.WK_FILE:
                uploadFile(wkMsg, listener);
                break;
            default:
                listener.onUploadResult(false, null);
                break;
        }
    }
    
    private void uploadImage(WKMsg wkMsg, IUploadAttacResultListener listener) {
        WKImageContent imageContent = (WKImageContent) wkMsg.baseContentMsgModel;
        
        if (!TextUtils.isEmpty(imageContent.url)) {
            // Already has network address, return directly
            listener.onUploadResult(true, imageContent);
            return;
        }
        
        // Upload image to server
        String localPath = imageContent.localPath;
        if (TextUtils.isEmpty(localPath)) {
            listener.onUploadResult(false, null);
            return;
        }
        
        // Async upload
        uploadFileToServer(localPath, "image", new UploadCallback() {
            @Override
            public void onSuccess(String url) {
                imageContent.url = url;
                listener.onUploadResult(true, imageContent);
            }
            
            @Override
            public void onError(String error) {
                Log.e(TAG, "Image upload failed: " + error);
                listener.onUploadResult(false, null);
            }
        });
    }
    
    private void uploadVideo(WKMsg wkMsg, IUploadAttacResultListener listener) {
```

--------------------------------

### WKIM.getInstance().init

Source: https://github.com/wukongim/wukongimdocs/blob/main/en/sdk/wukongim/android/base.mdx

Initializes the WuKongIM SDK with user credentials and optional configuration settings.

```APIDOC
## WKIM.getInstance().init(context, uid, token, [options])

### Description
Initializes the IM SDK instance. This should be called in the Application's onCreate method.

### Parameters
- **context** (Context) - Required - The application context.
- **uid** (String) - Required - The login user ID registered with the IM communication end.
- **token** (String) - Required - The login user token registered with the IM communication end.
- **options** (WKIMOptions) - Optional - Custom configuration options including log level, database password, and file upload URL.
```

--------------------------------

### Basic SDK Configuration

Source: https://github.com/wukongim/wukongimdocs/blob/main/en/sdk/wukongim/javascript/integration.mdx

Initializes the SDK with required server addresses, authentication credentials, and connection parameters.

```javascript
const sdk = WKSDK.shared();

sdk.config({
    // Required settings
    addr: "ws://your-server.com:5200",
    uid: "user123",
    token: "user-auth-token",
    
    // Optional settings
    apiURL: "http://your-api-server.com",
    uploadURL: "http://your-upload-server.com",
    
    // Connection settings
    heartbeatInterval: 30000,           // Heartbeat interval (ms)
    reconnectInterval: 5000,            // Reconnect interval (ms)
    maxReconnectAttempts: 10,           // Max reconnect attempts
    
    // Debug settings
    debug: true,                        // Enable debug mode
    logLevel: "debug",                  // Log level: debug, info, warn, error
    
    // Storage settings
    enableLocalStorage: true,           // Enable local storage
    storagePrefix: "wk_",              // Storage key prefix
    
    // Message settings
    messageRetryCount: 3,               // Message retry count
    messageTimeout: 30000,              // Message timeout (ms)
});
```

--------------------------------

### Install SDK via CocoaPods

Source: https://github.com/wukongim/wukongimdocs/blob/main/en/sdk/easy/ios/getting-started.mdx

Add the dependency to your Podfile and execute the installation command.

```ruby
pod 'WuKongEasySDK', '~> 1.0.0'
```

```bash
pod install
```

--------------------------------

### Initialize WuKongIM SDK

Source: https://github.com/wukongim/wukongimdocs/blob/main/en/sdk/easy/flutter/getting-started.mdx

Configure the SDK with server details and user credentials, then initialize the instance.

```dart
// 1. Initialize SDK
final config = WuKongConfig(
  serverUrl: "ws://your-wukongim-server.com:5200",
  uid: "your_user_id",        // Your user ID
  token: "your_auth_token",   // Your authentication token
  // deviceId: "optional_device_id", // Optional: Device ID
  // deviceFlag: WuKongDeviceFlag.app, // Optional: Device flag, default is app
);

final easySDK = WuKongEasySDK.getInstance();
await easySDK.init(config);
```

--------------------------------

### Troubleshoot service startup failures

Source: https://github.com/wukongim/wukongimdocs/blob/main/en/installation/linux/upgrade.mdx

Use these commands to inspect logs, verify file permissions, and check configuration files when a service fails to start.

```bash
# Check logs
tail -f ./wukongim_data/logs/wukongim.log

# Check if executable has proper permissions
ls -la wukongim

# Verify configuration file
cat wk.yaml
```

--------------------------------

### Initialize SDK and Manage Connection Lifecycle

Source: https://github.com/wukongim/wukongimdocs/blob/main/en/sdk/wukongim/android/base.mdx

Demonstrates initializing the SDK within the Application class and setting up listeners for connection status and server configuration.

```java
public class MyApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        
        // Initialize SDK
        WKIM.getInstance().init(this, "user123", "user-token");
        
        // Setup connection listener
        setupConnectionListener();
        
        // Setup server configuration
        setupServerConfig();
    }
    
    private void setupConnectionListener() {
        WKIM.getInstance().getConnectionManager().addOnConnectionStatusListener("app", 
            (status, reason) -> {
                Log.d("WuKongIM", "Connection status: " + status + ", reason: " + reason);
                
                if (status == WKConnectStatus.kicked) {
                    // Handle being kicked offline
                    handleKickedOffline();
                }
            });
    }
    
    private void setupServerConfig() {
        WKIM.getInstance().getConnectionManager().addOnGetIpAndPortListener(listener -> {
            // In production, get from your server
            listener.onGetSocketIpAndPort("your-server.com", 5100);
        });
    }
    
    private void handleKickedOffline() {
        // Redirect to login screen
        Intent intent = new Intent(this, LoginActivity.class);
        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK);
        startActivity(intent);
    }
}
```

```kotlin
class MyApplication : Application() {
    override fun onCreate() {
        super.onCreate()
        
        // Initialize SDK
        WKIM.getInstance().init(this, "user123", "user-token")
        
        // Setup connection listener
        setupConnectionListener()
        
        // Setup server configuration
        setupServerConfig()
    }
    
    private fun setupConnectionListener() {
        WKIM.getInstance().connectionManager.addOnConnectionStatusListener("app") { status, reason ->
            Log.d("WuKongIM", "Connection status: $status, reason: $reason")
            
            if (status == WKConnectStatus.kicked) {
                // Handle being kicked offline
                handleKickedOffline()
            }
        }
    }
    
    private fun setupServerConfig() {
        WKIM.getInstance().connectionManager.addOnGetIpAndPortListener { listener ->
            // In production, get from your server
            listener?.onGetSocketIpAndPort("your-server.com", 5100)
        }
    }
    
    private fun handleKickedOffline() {
        // Redirect to login screen
        val intent = Intent(this, LoginActivity::class.java).apply {
            addFlags(Intent.FLAG_ACTIVITY_NEW_TASK or Intent.FLAG_ACTIVITY_CLEAR_TASK)
        }
        startActivity(intent)
    }
}
```

--------------------------------

### Start and Manage Services

Source: https://github.com/wukongim/wukongimdocs/blob/main/en/installation/docker/single-node.mdx

Commands to start the Docker Compose stack and monitor service status.

```bash
# Start WuKongIM and monitoring
docker-compose up -d

# Check service status
docker-compose ps

# View logs
docker-compose logs -f wukongim
```

--------------------------------

### Webhook Request Body Example

Source: https://github.com/wukongim/wukongimdocs/blob/main/en/api/webhook.mdx

Example of the JSON array format used in the request body.

```json
["uid1-0-1", "uid2-1-0"]
```

--------------------------------

### Troubleshoot container startup issues

Source: https://github.com/wukongim/wukongimdocs/blob/main/en/installation/docker/upgrade.mdx

Use these commands to inspect logs, verify image availability, and validate configuration files after an upgrade.

```bash
# Check logs for errors
docker-compose logs wukongim

# Check if image was pulled correctly
docker images | grep wukongim

# Verify configuration compatibility
docker-compose config
```

--------------------------------

### Restart Gateway and Start Node

Source: https://github.com/wukongim/wukongimdocs/blob/main/en/installation/docker/scaling.mdx

Commands to apply configuration changes to the gateway and start the new node.

```bash
sudo docker-compose restart
```

```bash
sudo docker-compose up -d
```

--------------------------------

### Complete Command Management Implementation

Source: https://github.com/wukongim/wukongimdocs/blob/main/en/sdk/wukongim/android/cmd.mdx

A robust example demonstrating how to route different command keys to specific handler methods using a switch statement.

```java
public class CommandManager {
    
    private static final String LISTENER_KEY = "CommandManager";
    
    public void initialize() {
        // Add command listener
        WKIM.getInstance().getCMDManager().addCmdListener(LISTENER_KEY, this::handleCommand);
    }
    
    private void handleCommand(WKCMD cmd) {
        if (cmd == null || cmd.cmdKey == null) {
            return;
        }
        
        Log.d("CommandManager", "Received command: " + cmd.cmdKey);
        
        switch (cmd.cmdKey) {
            case "user_status_change":
                handleUserStatusChange(cmd.paramJsonObject);
                break;
                
            case "group_member_update":
                handleGroupMemberUpdate(cmd.paramJsonObject);
                break;
                
            case "system_notification":
                handleSystemNotification(cmd.paramJsonObject);
                break;
                
            case "force_logout":
                handleForceLogout(cmd.paramJsonObject);
                break;
                
            case "message_recall":
                handleMessageRecall(cmd.paramJsonObject);
                break;
                
            case "typing_status":
                handleTypingStatus(cmd.paramJsonObject);
                break;
                
            case "online_status":
                handleOnlineStatus(cmd.paramJsonObject);
                break;
                
            default:
                Log.w("CommandManager", "Unknown command type: " + cmd.cmdKey);
                handleUnknownCommand(cmd);
                break;
        }
    }
    
    // Handle user status change
    private void handleUserStatusChange(JSONObject params) {
        try {
            String userId = params.getString("user_id");
            int status = params.getInt("status");
            
            // Update user status
            UserStatusManager.updateUserStatus(userId, status);
            
            // Notify UI update
            EventBus.getDefault().post(new UserStatusChangedEvent(userId, status));
            
        } catch (JSONException e) {
            Log.e("CommandManager", "Failed to parse user status change command", e);
        }
    }
    
    // Handle group member update
    private void handleGroupMemberUpdate(JSONObject params) {
        try {
            String groupId = params.getString("group_id");
            String action = params.getString("action"); // add, remove, update
            JSONArray members = params.getJSONArray("members");
            
            switch (action) {
                case "add":
                    // Add group members
                    handleGroupMemberAdd(groupId, members);
                    break;
                case "remove":
                    // Remove group members
                    handleGroupMemberRemove(groupId, members);
                    break;
                case "update":
                    // Update group member info
                    handleGroupMemberInfoUpdate(groupId, members);
                    break;
            }
            
        } catch (JSONException e) {
            Log.e("CommandManager", "Failed to parse group member update command", e);
        }
    }
    
    // Handle system notification
    private void handleSystemNotification(JSONObject params) {
        try {
            String title = params.getString("title");
            String content = params.getString("content");
            String type = params.optString("type", "info");
            
            // Show system notification
            NotificationHelper.showSystemNotification(title, content, type);
            
        } catch (JSONException e) {
            Log.e("CommandManager", "Failed to parse system notification command", e);
        }
    }
    
    // Handle force logout
    private void handleForceLogout(JSONObject params) {
        try {
            String reason = params.optString("reason", "Account logged in from another device");
            
            // Clear local data
```

--------------------------------

### Webhook URL Example

Source: https://github.com/wukongim/wukongimdocs/blob/main/en/api/webhook.mdx

Example of a webhook URL structure using query parameters for event identification.

```text
http://example.com/webhook?event=user.onlinestatus
```

--------------------------------

### Initialize and Connect User with EasySDK

Source: https://github.com/wukongim/wukongimdocs/blob/main/en/getting-started/concepts/user.mdx

Configures the SDK with server credentials and establishes a connection. Requires a valid UID and token for authentication.

```javascript
import { WKIM, WKIMEvent } from 'easyjssdk';

// Initialize SDK
const im = WKIM.init("ws://your-server.com:5200", {
  uid: "user123",                    // User unique identifier
  token: "your_auth_token"           // User authentication token
});

// Listen for connection status
im.on(WKIMEvent.Connect, (result) => {
  console.log('User connected:', result);
});

im.on(WKIMEvent.Disconnect, (disconnectInfo) => {
  console.log('User disconnected:', disconnectInfo);
});

// Connect to server
try {
  await im.connect();
  console.log("Connection successful!");
} catch (error) {
  console.error("Connection failed:", error);
}
```

```swift
import WuKongEasySDK

// Configure user information
let config = WuKongConfig(
    serverUrl: "ws://your-server.com:5200",
    uid: "user123",                 // User unique identifier
    token: "your_auth_token"        // User authentication token
)

// Initialize SDK
let easySDK = WuKongEasySDK(config: config)

// Listen for connection status
easySDK.onConnect { result in
    print("User connected:", result)
}

easySDK.onDisconnect { disconnectInfo in
    print("User disconnected:", disconnectInfo)
}

// Connect to server
Task {
    do {
        try await easySDK.connect()
        print("Connection successful!")
    } catch {
        print("Connection failed:", error)
    }
}
```

```kotlin
import com.githubim.easysdk.WuKongEasySDK
import com.githubim.easysdk.WuKongConfig
import com.githubim.easysdk.WuKongEvent
import com.githubim.easysdk.listener.WuKongEventListener

// Configure user information
val config = WuKongConfig.Builder()
    .serverUrl("ws://your-server.com:5200")
    .uid("user123")                // User unique identifier
    .token("your_auth_token")      // User authentication token
    .build()

// Initialize SDK
val easySDK = WuKongEasySDK.getInstance()
easySDK.init(this, config)

// Listen for connection status
easySDK.addEventListener(WuKongEvent.CONNECT, object : WuKongEventListener<ConnectResult> {
    override fun onEvent(result: ConnectResult) {
        Log.d("WuKong", "User connected: $result")
    }
})

easySDK.addEventListener(WuKongEvent.DISCONNECT, object : WuKongEventListener<DisconnectInfo> {
    override fun onEvent(disconnectInfo: DisconnectInfo) {
        Log.d("WuKong", "User disconnected: $disconnectInfo")
    }
})

// Connect to server
lifecycleScope.launch {
    try {
        easySDK.connect()
        Log.d("WuKong", "Connection successful!")
    } catch (e: Exception) {
        Log.e("WuKong", "Connection failed: $e")
    }
}
```

```dart
import 'package:wukong_easy_sdk/wukong_easy_sdk.dart';

// Configure user information
final config = WuKongConfig(
  serverUrl: "ws://your-server.com:5200",
  uid: "user123",                   // User unique identifier
  token: "your_auth_token",         // User authentication token
);

// Initialize SDK
final easySDK = WuKongEasySDK.getInstance();
await easySDK.init(config);

// Listen for connection status
easySDK.addEventListener(WuKongEvent.connect, (ConnectResult result) {
  print('User connected: $result');
});

easySDK.addEventListener(WuKongEvent.disconnect, (DisconnectInfo disconnectInfo) {
  print('User disconnected: $disconnectInfo');
});

// Connect to server
try {
  await easySDK.connect();
  print("Connection successful!");
} catch (e) {
  print("Connection failed: $e");
}
```

--------------------------------

### Online Status Response Example

Source: https://github.com/wukongim/wukongimdocs/blob/main/en/api/users.mdx

Example JSON response body returned when checking online status.

```json
["user123", "user456"]
```

--------------------------------

### Installing with Helm

Source: https://github.com/wukongim/wukongimdocs/blob/main/en/installation/k8s/multi-node.mdx

Deploy WukongIM using Helm with custom configuration parameters for replicas, persistence, and resources.

```bash
helm install wkim wukongim/wukongim \
  -n wukongim \
  --create-namespace \
  --version 0.1.0 \
  --set replicaCount=3 \
  --set image.tag=v2.0.0 \
  --set service.type=LoadBalancer \
  --set persistence.enabled=true \
  --set persistence.size=50Gi \
  --set resources.requests.memory=4Gi \
  --set resources.requests.cpu=2000m
```

--------------------------------

### Remaining Length Encoding Example

Source: https://github.com/wukongim/wukongimdocs/blob/main/en/getting-started/learning/protocol.mdx

Example demonstrating the variable-length encoding for the value 321, which requires two bytes.

```text
First byte 193 (11000001):
  - Most significant bit is 1, indicating subsequent bytes
  - Lower 7 bits are 1000001 (65)

Second byte 2 (00000010):
  - Most significant bit is 0, indicating end
  - Lower 7 bits are 0000010 (2)

Calculation: 321 = 65 + 2 × 128 = 65 + 256
```

--------------------------------

### Complete Message Sending Example

Source: https://github.com/wukongim/wukongimdocs/blob/main/en/sdk/wukongim/android/message.mdx

A comprehensive example demonstrating how to send text, image, voice, and location messages within an Activity.

```java
public class ChatActivity extends AppCompatActivity {
    
    private String channelID;
    private byte channelType;
    
    // Send text message
    private void sendTextMessage(String content) {
        WKTextContent textContent = new WKTextContent(content);
        WKIM.getInstance().getMsgManager().send(textContent, channelID, channelType);
    }
    
    // Send image message
    private void sendImageMessage(String imagePath) {
        WKImageContent imageContent = new WKImageContent(imagePath);
        WKIM.getInstance().getMsgManager().send(imageContent, channelID, channelType);
    }
    
    // Send voice message
    private void sendVoiceMessage(String voicePath, int duration) {
        WKVoiceContent voiceContent = new WKVoiceContent(voicePath, duration);
        WKIM.getInstance().getMsgManager().send(voiceContent, channelID, channelType);
    }
    
    // Send location message
    private void sendLocationMessage(double latitude, double longitude, String address) {
        WKLocationContent locationContent = new WKLocationContent(latitude, longitude, address);
        WKIM.getInstance().getMsgManager().send(locationContent, channelID, channelType);
    }
}
```

--------------------------------

### SDK Initialization and Connection

Source: https://github.com/wukongim/wukongimdocs/blob/main/en/getting-started/concepts/user.mdx

Initializes the SDK with server URL, UID, and token, then establishes a connection to the server while listening for connection events.

```APIDOC
## SDK Initialization and Connection

### Description
Initializes the SDK instance with user credentials and connects to the messaging server.

### Methods
- **init(config)**: Configures the SDK with server URL, UID, and token.
- **connect()**: Establishes the WebSocket connection to the server.
- **on(event, callback)**: Registers listeners for connection and disconnection events.

### Parameters
- **serverUrl** (string) - Required - The WebSocket server address.
- **uid** (string) - Required - The unique identifier for the user.
- **token** (string) - Required - The authentication token for the user.
```
Tokens:
Raw