Basic Features

/**
 * Initialize IM
 * @param context Application Context
 * @param uid Login user ID (uid registered with IM communication end by business server)
 * @param token Login user token (token registered with IM communication end by business server)
 */
WKIM.getInstance().init(context, uid, token);

WKIM.getInstance().init(context, uid, token)

WKIMOptions options = new WKIMOptions();
options.setLogLevel(WKLogLevel.DEBUG);
options.setDbPassword("your_db_password");
options.setFileUploadUrl("https://your-upload-server.com/upload");

WKIM.getInstance().init(context, uid, token, options);

val options = WKIMOptions().apply {
    logLevel = WKLogLevel.DEBUG
    dbPassword = "your_db_password"
    fileUploadUrl = "https://your-upload-server.com/upload"
}

WKIM.getInstance().init(context, uid, token, options)

WKIM.getInstance().getConnectionManager().addOnGetIpAndPortListener(new IGetIpAndPort() {
    @Override
    public void getIP(IGetSocketIpAndPortListener iGetSocketIpAndPortListener) {
        // Return connection IP and port
        iGetSocketIpAndPortListener.onGetSocketIpAndPort("xxx.xxx.xxx.xxx", 5100);
    }
});

WKIM.getInstance().connectionManager.addOnGetIpAndPortListener { listener ->
    listener?.onGetSocketIpAndPort(
        "172.0.0.1",
        5100
    )
}

// Connect to IM
WKIM.getInstance().getConnectionManager().connection();

// Connect to IM
WKIM.getInstance().connectionManager.connection()

// Disconnect IM
WKIM.getInstance().getConnectionManager().disconnect(isLogout);

// Disconnect IM
WKIM.getInstance().connectionManager.disconnect(isLogout)

WKIM.getInstance().getConnectionManager().addOnConnectionStatusListener("key", new IConnectionStatus() {
    @Override
    public void onStatus(int status, String reason) {
        switch (status) {
            case WKConnectStatus.success:
                // Connection successful
                break;
            case WKConnectStatus.failed:
                // Connection failed
                break;
            case WKConnectStatus.connecting:
                // Connecting
                break;
            case WKConnectStatus.syncMsg:
                // Syncing messages
                break;
            case WKConnectStatus.noNetwork:
                // No network
                break;
            case WKConnectStatus.kicked:
                // Kicked offline - need to exit app and return to login page
                break;
        }
    }
});

WKIM.getInstance().connectionManager.addOnConnectionStatusListener("key") { status, reason ->
    when (status) {
        WKConnectStatus.success -> {
            // Connection successful
        }
        WKConnectStatus.failed -> {
            // Connection failed
        }
        WKConnectStatus.connecting -> {
            // Connecting
        }
        WKConnectStatus.syncMsg -> {
            // Syncing messages
        }
        WKConnectStatus.noNetwork -> {
            // No network
        }
        WKConnectStatus.kicked -> {
            // Kicked offline
        }
    }
}

// Remove specific listener
WKIM.getInstance().getConnectionManager().removeOnConnectionStatusListener("key");

// Remove all listeners
WKIM.getInstance().getConnectionManager().removeAllOnConnectionStatusListener();

// Remove specific listener
WKIM.getInstance().connectionManager.removeOnConnectionStatusListener("key")

// Remove all listeners
WKIM.getInstance().connectionManager.removeAllOnConnectionStatusListener()

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);
    }
}

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)
    }
}

public class MainActivity extends AppCompatActivity {
    @Override
    protected void onResume() {
        super.onResume();
        
        // Connect when app comes to foreground
        if (!WKIM.getInstance().getConnectionManager().isConnected()) {
            WKIM.getInstance().getConnectionManager().connection();
        }
    }
    
    @Override
    protected void onPause() {
        super.onPause();
        
        // Optionally disconnect when app goes to background
        // WKIM.getInstance().getConnectionManager().disconnect(false);
    }
}

class MainActivity : AppCompatActivity() {
    override fun onResume() {
        super.onResume()
        
        // Connect when app comes to foreground
        if (!WKIM.getInstance().connectionManager.isConnected()) {
            WKIM.getInstance().connectionManager.connection()
        }
    }
    
    override fun onPause() {
        super.onPause()
        
        // Optionally disconnect when app goes to background
        // WKIM.getInstance().connectionManager.disconnect(false)
    }
}

public class NetworkMonitor extends BroadcastReceiver {
    @Override
    public void onReceive(Context context, Intent intent) {
        ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo activeNetwork = cm.getActiveNetworkInfo();
        boolean isConnected = activeNetwork != null && activeNetwork.isConnectedOrConnecting();
        
        if (isConnected) {
            // Network available, try to connect
            WKIM.getInstance().getConnectionManager().connection();
        } else {
            // Network unavailable
            Log.d("WuKongIM", "Network unavailable");
        }
    }
}

class NetworkMonitor : BroadcastReceiver() {
    override fun onReceive(context: Context, intent: Intent) {
        val cm = context.getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
        val activeNetwork = cm.activeNetworkInfo
        val isConnected = activeNetwork?.isConnectedOrConnecting == true
        
        if (isConnected) {
            // Network available, try to connect
            WKIM.getInstance().connectionManager.connection()
        } else {
            // Network unavailable
            Log.d("WuKongIM", "Network unavailable")
        }
    }
}