### Get Group Info - Java

Source: https://context7.com/doocs/qcloud-im-server-sdk-java/llms.txt

Retrieves detailed information about one or more groups using their IDs. The input is a list of group IDs, and the output provides details such as group name, type, and member count for each group.

```java
import io.github.doocs.im.model.request.GetGroupInfoRequest;
import io.github.doocs.im.model.response.GetGroupInfoResult;
import java.util.Arrays;

GetGroupInfoRequest request = new GetGroupInfoRequest(
    Arrays.asList("@TGS#2CLUZEAEJ", "@TGS#2DZUEAXX")
);

try {
    GetGroupInfoResult result = client.group.getGroupInfo(request);
    result.getGroupInfo().forEach(group -> {
        System.out.println("Group: " + group.getName() +
            ", Type: " + group.getType() +
            ", Members: " + group.getMemberNum());
    });
} catch (IOException e) {
    e.printStackTrace();
}
```

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

### Get Friends List in Java

Source: https://context7.com/doocs/qcloud-im-server-sdk-java/llms.txt

Retrieves a paginated list of friends for a specific account, including the total count and individual friend details.

```java
import io.github.doocs.im.model.request.FriendGetRequest;
import io.github.doocs.im.model.response.FriendGetResult;

FriendGetRequest request = FriendGetRequest.builder()
    .fromAccount("user001")
    .startIndex(0)
    .build();

try {
    FriendGetResult result = client.sns.friendGet(request);
    System.out.println("Total friends: " + result.getFriendNum());
    result.getUserDataItem().forEach(friend -> {
        System.out.println("Friend: " + friend.getToAccount());
    });
} catch (IOException e) {
    e.printStackTrace();
}
```

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

### Get Group Member Info - Java

Source: https://context7.com/doocs/qcloud-im-server-sdk-java/llms.txt

Retrieves a paginated list of members for a given group, including detailed information about each member. Supports filtering and pagination with limit and offset parameters.

```java
import io.github.doocs.im.model.request.GetGroupMemberInfoRequest;
import io.github.doocs.im.model.response.GetGroupMemberInfoResult;

GetGroupMemberInfoRequest request = GetGroupMemberInfoRequest.builder()
    .groupId("@TGS#2CLUZEAEJ")
    .limit(100)
    .offset(0)
    .build();

try {
    GetGroupMemberInfoResult result = client.group.getGroupMemberInfo(request);
    System.out.println("Total members: " + result.getMemberNum());
    result.getMemberList().forEach(member -> {
        System.out.println("Member: " + member.getMemberAccount() +
            ", Role: " + member.getRole() +
            ", Join Time: " + member.getJoinTime());
    });
} catch (IOException e) {
    e.printStackTrace();
}
```

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

### Initialize IMClient and Import Account in Java

Source: https://github.com/doocs/qcloud-im-server-sdk-java/blob/dev/README.md

This Java code snippet demonstrates how to initialize the ImClient instance using your application's AppID, admin UserID, and key. It then shows how to import an account with profile information and handle potential IO exceptions.

```java
// sdk appId
long appId = 1400554812;

// admin userId
String userId = "test";

// application key
String key = "60c6c5925f3ae52c7325ac5a8ec78e44c056d1dd84d54e12ffa39911267a2a70";

// create ImClient instance
ImClient client = ImClient.getInstance(appId, userId, key);

// import account
AccountImportRequest request = new AccountImportRequest("doocs");
request.setFaceUrl("https://avatars.githubusercontent.com/u/43716716?s=200&v=4");
request.setNick("Doocs Community");
try {
    AccountImportResult result = client.account.accountImport(request);
    // handle result
} catch (IOException e) {
    // handle exception
}
```

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

### Create Group - Java

Source: https://context7.com/doocs/qcloud-im-server-sdk-java/llms.txt

Creates a new group with specified type, members, and configuration. It requires group details like type, name, owner, and optional settings for introduction, notification, face URL, max member count, join options, and initial members.

```java
import io.github.doocs.im.model.request.CreateGroupRequest;
import io.github.doocs.im.model.response.CreateGroupResult;
import io.github.doocs.im.model.group.MemberProfile;
import io.github.doocs.im.constant.GroupType;
import io.github.doocs.im.constant.ApplyJoinOption;
import java.util.Arrays;

CreateGroupRequest request = CreateGroupRequest.builder()
    .type(GroupType.PUBLIC)
    .name("My Discussion Group")
    .ownerAccount("admin")
    .introduction("A group for project discussions")
    .notification("Welcome to the group!")
    .faceUrl("https://example.com/group-avatar.png")
    .maxMemberCount(500)
    .applyJoinOption(ApplyJoinOption.NEED_PERMISSION)
    .memberList(Arrays.asList(
        new MemberProfile("user001"),
        new MemberProfile("user002")
    ))
    .build();

try {
    CreateGroupResult result = client.group.createGroup(request);
    System.out.println("Group created with ID: " + result.getGroupId());
} catch (IOException e) {
    e.printStackTrace();
}
```

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

### Create Robot Account via Java SDK

Source: https://context7.com/doocs/qcloud-im-server-sdk-java/llms.txt

Initializes a new AI robot account with a nickname and avatar URL. This is useful for automated messaging scenarios within the IM platform.

```java
import io.github.doocs.im.model.request.CreateRobotRequest;
import io.github.doocs.im.model.response.CreateRobotResult;

CreateRobotRequest request = CreateRobotRequest.builder()
    .userId("robot001")
    .nick("Customer Service Bot")
    .faceUrl("https://example.com/robot-avatar.png")
    .build();

try {
    CreateRobotResult result = client.robot.createRobot(request);
    if ("OK".equals(result.getActionStatus())) {
        System.out.println("Robot created: " + request.getUserId());
    }
} catch (IOException e) {
    e.printStackTrace();
}
```

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

### Initialize ImClient for Tencent Cloud IM

Source: https://context7.com/doocs/qcloud-im-server-sdk-java/llms.txt

Initialize the ImClient instance using your Tencent Cloud IM application ID, user ID, and key. Supports basic initialization and custom configurations for HTTP client settings like retries, timeouts, and signature renewal.

```java
import io.github.doocs.im.ImClient;
import io.github.doocs.im.ClientConfiguration;

// Basic initialization
long appId = 1400554812;
String userId = "admin";
String key = "60c6c5925f3ae52c7325ac5a8ec78e44c056d1dd84d54e12ffa39911267a2a70";

ImClient client = ImClient.getInstance(appId, userId, key);

// With custom configuration
ClientConfiguration config = ClientConfiguration.builder()
    .maxRetries(5)
    .retryIntervalMs(300)
    .connectTimeout(15000)
    .readTimeout(15000)
    .writeTimeout(15000)
    .callTimeout(60000)
    .expireTime(86400)
    .autoRenewSig(true)
    .build();

ImClient clientWithConfig = ImClient.getInstance(appId, userId, key, config);
```

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

### Add Maven Dependency for IM Server SDK Java

Source: https://github.com/doocs/qcloud-im-server-sdk-java/blob/dev/README.md

This snippet shows how to add the Tencent Cloud IM Server SDK for Java as a dependency in a Maven project's pom.xml file. Ensure you are using JDK 1.8 or later.

```xml
<dependency>
  <groupId>io.github.doocs</groupId>
  <artifactId>im-server-sdk-java</artifactId>
  <version>0.4.20</version>
</dependency>
```

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

### Import Multiple User Accounts to Tencent Cloud IM

Source: https://context7.com/doocs/qcloud-im-server-sdk-java/llms.txt

Efficiently import multiple user accounts in a single API call using the SDK. This method takes a list of user IDs and processes them in batch, returning the number of failed imports.

```java
import io.github.doocs.im.model.request.MultiAccountImportRequest;
import io.github.doocs.im.model.response.MultiAccountImportResult;
import java.io.IOException;
import java.util.Arrays;

MultiAccountImportRequest request = new MultiAccountImportRequest(
    Arrays.asList("user001", "user002", "user003", "user004", "user005")
);

try {
    MultiAccountImportResult result = client.account.multiAccountImport(request);
    System.out.println("Successfully imported: " + result.getFailAccounts().size() + " failures");
} catch (IOException e) {
    e.printStackTrace();
}
```

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

### Send Custom Structured Messages

Source: https://context7.com/doocs/qcloud-im-server-sdk-java/llms.txt

Shows how to send custom messages containing application-specific data. The implementation uses TIMCustomMsgElement to encapsulate JSON-formatted data, description, and extension fields.

```java
import io.github.doocs.im.model.request.SendMsgRequest;
import io.github.doocs.im.model.response.SendMsgResult;
import io.github.doocs.im.model.message.TIMCustomMsgElement;
import java.util.Collections;

TIMCustomMsgElement customMsg = new TIMCustomMsgElement();
customMsg.setMsgContent(TIMCustomMsgElement.CustomMsgContent.builder()
    .data("{\"type\":\"order\",\"orderId\":\"12345\",\"status\":\"shipped\"}")
    .desc("Order Status Update")
    .ext("order_notification")
    .build());

SendMsgRequest request = SendMsgRequest.builder()
    .fromAccount("system")
    .toAccount("user001")
    .msgRandom(System.currentTimeMillis())
    .msgBody(Collections.singletonList(customMsg))
    .build();

try {
    SendMsgResult result = client.message.sendMsg(request);
    System.out.println("Custom message sent: " + result.getMsgKey());
} catch (IOException e) {
    e.printStackTrace();
}
```

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

### Retrieve App Statistics via Java SDK

Source: https://context7.com/doocs/qcloud-im-server-sdk-java/llms.txt

Fetches operational metrics such as active users and message counts. It accepts a list of requested fields and returns the corresponding statistics for the application.

```java
import io.github.doocs.im.model.request.GetAppInfoRequest;
import io.github.doocs.im.model.response.GetAppInfoResult;
import java.util.Arrays;

GetAppInfoRequest request = GetAppInfoRequest.builder()
    .requestField(Arrays.asList(
        "ActiveUserNum",
        "AppNewUserNum",
        "C2CSendMsgUserNum",
        "GroupCreateNum"
    ))
    .build();

try {
    GetAppInfoResult result = client.operation.getAppInfo(request);
    result.getResult().forEach(item -> {
        System.out.println("Date: " + item.getTimeKey() +
            ", Active Users: " + item.getActiveUserNum());
    });
} catch (IOException e) {
    e.printStackTrace();
}
```

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

### Import Single User Account to Tencent Cloud IM

Source: https://context7.com/doocs/qcloud-im-server-sdk-java/llms.txt

Import a single user account into Tencent Cloud IM using the SDK. This operation allows setting optional profile information such as nickname and avatar URL. It handles API requests and response parsing for account import.

```java
import io.github.doocs.im.model.request.AccountImportRequest;
import io.github.doocs.im.model.response.AccountImportResult;
import java.io.IOException;

AccountImportRequest request = new AccountImportRequest("user001");
request.setNick("John Doe");
request.setFaceUrl("https://example.com/avatar.png");

try {
    AccountImportResult result = client.account.accountImport(request);
    if ("OK".equals(result.getActionStatus())) {
        System.out.println("Account imported successfully");
    } else {
        System.out.println("Error: " + result.getErrorInfo());
    }
} catch (IOException e) {
    e.printStackTrace();
}
```

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

### POST /v4/im_open_login_svc/kick

Source: https://context7.com/doocs/qcloud-im-server-sdk-java/llms.txt

Invalidates a user's login session to force them offline from all connected devices.

```APIDOC
## POST /v4/im_open_login_svc/kick

### Description
Invalidate a user's login session to force them offline from all devices.

### Method
POST

### Endpoint
/v4/im_open_login_svc/kick

### Request Body
- **UserID** (string) - Required - The ID of the user to kick.

### Request Example
{
  "UserID": "user001"
}

### Response
#### Success Response (200)
- **ActionStatus** (string) - Status of the operation (e.g., "OK").

#### Response Example
{
  "ActionStatus": "OK"
}
```

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

### Retrieve User Profile Information

Source: https://context7.com/doocs/qcloud-im-server-sdk-java/llms.txt

Fetches profile data for one or more users based on specified tags. The request requires a list of accounts and the specific profile tags to be returned in the response.

```java
import io.github.doocs.im.model.request.PortraitGetRequest;
import io.github.doocs.im.model.response.PortraitGetResult;
import io.github.doocs.im.constant.TagProfile;
import java.util.Arrays;

PortraitGetRequest request = PortraitGetRequest.builder()
    .toAccount(Arrays.asList("user001", "user002"))
    .tagList(Arrays.asList(
        TagProfile.IM_NICK,
        TagProfile.IM_IMAGE,
        TagProfile.IM_GENDER
    ))
    .build();

try {
    PortraitGetResult result = client.profile.portraitGet(request);
    result.getUserProfileItem().forEach(profile -> {
        System.out.println("User: " + profile.getToAccount());
        profile.getProfileItem().forEach(item -> {
            System.out.println("  " + item.getTag() + ": " + item.getValue());
        });
    });
} catch (IOException e) {
    e.printStackTrace();
}
```

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

### Check User Account Status in Tencent Cloud IM

Source: https://context7.com/doocs/qcloud-im-server-sdk-java/llms.txt

Check the import status of one or more user accounts in Tencent Cloud IM. The SDK processes a list of account check items and returns their status, indicating whether they have been imported.

```java
import io.github.doocs.im.model.request.AccountCheckRequest;
import io.github.doocs.im.model.request.AccountCheckItem;
import io.github.doocs.im.model.response.AccountCheckResult;
import java.io.IOException;
import java.util.Arrays;

AccountCheckRequest request = new AccountCheckRequest(Arrays.asList(
    new AccountCheckItem("user001"),
    new AccountCheckItem("user002")
));

try {
    AccountCheckResult result = client.account.accountCheck(request);
    result.getResultItem().forEach(item -> {
        System.out.println("User: " + item.getUserId() +
            ", Status: " + (item.getAccountStatus() == 0 ? "Imported" : "Not imported"));
    });
} catch (IOException e) {
    e.printStackTrace();
}
```

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

### Moderate Content via Java SDK

Source: https://context7.com/doocs/qcloud-im-server-sdk-java/llms.txt

Performs cloud-based moderation on user-generated content to ensure compliance with policies. It accepts a list of content items and returns the moderation results.

```java
import io.github.doocs.im.model.request.ContentModerationRequest;
import io.github.doocs.im.model.request.AuditContentItem;
import io.github.doocs.im.model.response.ContentModerationResult;
import io.github.doocs.im.constant.AuditContentType;
import java.util.Collections;

ContentModerationRequest request = ContentModerationRequest.builder()
    .contentList(Collections.singletonList(
        AuditContentItem.builder()
            .contentType(AuditContentType.TEXT)
            .content("Message content to check for violations")
            .build()
    ))
    .build();

try {
    ContentModerationResult result = client.audit.contentModeration(request);
    result.getContentResultList().forEach(item -> {
        System.out.println("Content Type: " + item.getContentType() +
            ", Result: " + item.getResult());
    });
} catch (IOException e) {
    e.printStackTrace();
}
```

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

### Query User Online Status in Tencent Cloud IM

Source: https://context7.com/doocs/qcloud-im-server-sdk-java/llms.txt

Query the online status of specified user accounts, with an option to include detailed device platform information. The SDK handles the request and provides a list of user statuses.

```java
import io.github.doocs.im.model.request.QueryOnlineStatusRequest;
import io.github.doocs.im.model.response.QueryOnlineStatusResult;
import java.io.IOException;
import java.util.Arrays;

QueryOnlineStatusRequest request = new QueryOnlineStatusRequest(
    Arrays.asList("user001", "user002", "user003")
);
request.setIsNeedDetail(1); // Include device details

try {
    QueryOnlineStatusResult result = client.account.queryOnlineStatus(request);
    result.getQueryResult().forEach(item -> {
        System.out.println("User: " + item.getUserId() + ", Status: " + item.getStatus());
    });
} catch (IOException e) {
    e.printStackTrace();
}
```

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

### Send Image Messages

Source: https://context7.com/doocs/qcloud-im-server-sdk-java/llms.txt

Illustrates sending image messages including both original and thumbnail versions. It utilizes TIMImageMsgElement to structure image metadata such as URL, dimensions, and file size.

```java
import io.github.doocs.im.model.request.SendMsgRequest;
import io.github.doocs.im.model.response.SendMsgResult;
import io.github.doocs.im.model.message.TIMImageMsgElement;
import java.util.Arrays;
import java.util.Collections;

TIMImageMsgElement imageMsg = new TIMImageMsgElement();
imageMsg.setMsgContent(TIMImageMsgElement.ImageMsgContent.builder()
    .uuid("image_uuid_12345")
    .imageFormat(1) // JPG
    .imageInfoArray(Arrays.asList(
        TIMImageMsgElement.ImageInfo.builder()
            .type(1) // Original
            .url("https://example.com/images/original.jpg")
            .width(1920)
            .height(1080)
            .size(204800)
            .build(),
        TIMImageMsgElement.ImageInfo.builder()
            .type(2) // Thumbnail
            .url("https://example.com/images/thumb.jpg")
            .width(200)
            .height(112)
            .size(10240)
            .build()
    ))
    .build());

SendMsgRequest request = SendMsgRequest.builder()
    .fromAccount("user001")
    .toAccount("user002")
    .msgRandom(System.currentTimeMillis())
    .msgBody(Collections.singletonList(imageMsg))
    .build();

try {
    SendMsgResult result = client.message.sendMsg(request);
    System.out.println("Image message sent");
} catch (IOException e) {
    e.printStackTrace();
}
```

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

### Download Message History via Java SDK

Source: https://context7.com/doocs/qcloud-im-server-sdk-java/llms.txt

Retrieves compressed message history files for a specific date and chat type. It requires a valid GetHistoryRequest object and outputs the download URLs and expiration times.

```java
import io.github.doocs.im.model.request.GetHistoryRequest;
import io.github.doocs.im.model.response.GetHistoryResult;

GetHistoryRequest request = GetHistoryRequest.builder()
    .chatType("C2C") // or "Group"
    .msgTime("2024010112") // YYYYMMDDHH format
    .build();

try {
    GetHistoryResult result = client.operation.getHistory(request);
    result.getFile().forEach(file -> {
        System.out.println("Download URL: " + file.getUrl() +
            ", Expire: " + file.getExpireTime());
    });
} catch (IOException e) {
    e.printStackTrace();
}
```

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

### Manage Conversations via Java SDK

Source: https://context7.com/doocs/qcloud-im-server-sdk-java/llms.txt

Provides methods to retrieve a user's recent conversation list with pagination and to delete specific conversations. These operations help maintain user contact lists.

```java
import io.github.doocs.im.model.request.GetRecentContactListRequest;
import io.github.doocs.im.model.response.GetRecentContactListResult;

GetRecentContactListRequest request = GetRecentContactListRequest.builder()
    .fromAccount("user001")
    .count(50)
    .build();

try {
    GetRecentContactListResult result = client.recentContact.recentContactList(request);
    result.getSessionItem().forEach(session -> {
        System.out.println("Contact: " + session.getToAccount() +
            ", Type: " + session.getType() +
            ", Last Msg Time: " + session.getMsgTime());
    });
} catch (IOException e) {
    e.printStackTrace();
}
```

```java
import io.github.doocs.im.model.request.DeleteRecentContactRequest;
import io.github.doocs.im.model.response.DeleteRecentContactResult;
import io.github.doocs.im.constant.RecentContactType;

DeleteRecentContactRequest request = DeleteRecentContactRequest.builder()
    .fromAccount("user001")
    .toAccount("user002")
    .type(RecentContactType.C2C)
    .clearRamble(1) // Also clear roaming messages
    .build();

try {
    DeleteRecentContactResult result = client.recentContact.deleteRecentContact(request);
    if ("OK".equals(result.getActionStatus())) {
        System.out.println("Conversation deleted");
    }
} catch (IOException e) {
    e.printStackTrace();
}
```

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

### Add Sensitive Keywords for Content Moderation

Source: https://context7.com/doocs/qcloud-im-server-sdk-java/llms.txt

Demonstrates how to add custom sensitive keywords to the local moderation dictionary. It uses the AddLocalAuditKeywordsRequest builder to define the list of keywords and processes the result via the client.audit module.

```java
import io.github.doocs.im.model.request.AddLocalAuditKeywordsRequest;
import io.github.doocs.im.model.response.AddLocalAuditKeywordsResult;
import java.util.Arrays;

AddLocalAuditKeywordsRequest request = AddLocalAuditKeywordsRequest.builder()
    .keywords(Arrays.asList("spam", "advertisement", "prohibited"))
    .build();

try {
    AddLocalAuditKeywordsResult result = client.audit.addLocalAuditKeywords(request);
    if ("OK".equals(result.getActionStatus())) {
        System.out.println("Keywords added to moderation dictionary");
    }
} catch (IOException e) {
    e.printStackTrace();
}
```

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

### POST /v4/openim/batchsendmsg

Source: https://context7.com/doocs/qcloud-im-server-sdk-java/llms.txt

Sends the same message to multiple recipients in a single API request.

```APIDOC
## POST /v4/openim/batchsendmsg

### Description
Send the same message to multiple recipients in a single API call.

### Method
POST

### Endpoint
/v4/openim/batchsendmsg

### Request Body
- **From_Account** (string) - Required - Sender ID.
- **To_Account** (array) - Required - List of recipient IDs.
- **MsgRandom** (integer) - Required - Random number.
- **MsgBody** (array) - Required - Message content.

### Request Example
{
  "From_Account": "admin",
  "To_Account": ["user001", "user002"],
  "MsgRandom": 123456789,
  "MsgBody": [{"MsgType": "TIMTextElem", "MsgContent": {"Text": "Broadcast"}}]
}

### Response
#### Success Response (200)
- **ErrorList** (array) - List of failed recipients.

#### Response Example
{
  "ErrorList": []
}
```

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

### Manage User Tags for Push

Source: https://context7.com/doocs/qcloud-im-server-sdk-java/llms.txt

Associates custom tags with specific users to facilitate targeted push notifications. This allows for segmenting users based on attributes like subscription status or device type.

```java
import io.github.doocs.im.model.request.ImAddTagRequest;
import io.github.doocs.im.model.request.UserTagItem;
import io.github.doocs.im.model.response.ImAddTagResult;
import java.util.Arrays;

ImAddTagRequest request = ImAddTagRequest.builder()
    .userTags(Arrays.asList(
        UserTagItem.builder()
            .toAccount("user001")
            .tags(Arrays.asList("premium", "active"))
            .build(),
        UserTagItem.builder()
            .toAccount("user002")
            .tags(Arrays.asList("new_user", "mobile"))
            .build()
    ))
    .build();

try {
    ImAddTagResult result = client.member.imAddTag(request);
    if ("OK".equals(result.getActionStatus())) {
        System.out.println("Tags added successfully");
    }
} catch (IOException e) {
    e.printStackTrace();
}
```

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

### Add to Blacklist in Java

Source: https://context7.com/doocs/qcloud-im-server-sdk-java/llms.txt

Adds one or more users to a specific account's blacklist, preventing them from sending messages or friend requests.

```java
import io.github.doocs.im.model.request.BlackListAddRequest;
import io.github.doocs.im.model.response.BlackListAddResult;
import java.util.Arrays;

BlackListAddRequest request = BlackListAddRequest.builder()
    .fromAccount("user001")
    .toAccount(Arrays.asList("user005", "user006"))
    .build();

try {
    BlackListAddResult result = client.sns.blackListAdd(request);
    result.getResultItem().forEach(item -> {
        System.out.println("Blocked: " + item.getToAccount() +
            ", Result: " + item.getResultCode());
    });
} catch (IOException e) {
    e.printStackTrace();
}
```

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

### Add Group Members - Java

Source: https://context7.com/doocs/qcloud-im-server-sdk-java/llms.txt

Adds new members to an existing group. This operation supports adding multiple members at once and can optionally notify existing members or keep the addition silent.

```java
import io.github.doocs.im.model.request.AddGroupMemberRequest;
import io.github.doocs.im.model.response.AddGroupMemberResult;
import io.github.doocs.im.model.group.MemberProfile;
import java.util.Arrays;

AddGroupMemberRequest request = AddGroupMemberRequest.builder()
    .groupId("@TGS#2CLUZEAEJ")
    .memberList(Arrays.asList(
        new MemberProfile("user003"),
        new MemberProfile("user004")
    ))
    .silence(1) // Don't notify other members
    .build();

try {
    AddGroupMemberResult result = client.group.addGroupMember(request);
    result.getMemberList().forEach(member -> {
        System.out.println("User: " + member.getMemberAccount() +
            ", Result: " + member.getResult());
    });
} catch (IOException e) {
    e.printStackTrace();
}
```

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

### Single Chat: Send Message (Java)

Source: https://context7.com/doocs/qcloud-im-server-sdk-java/llms.txt

Sends a one-to-one chat message with various content types like text, images, or custom data. It requires sender and receiver account identifiers, message content, and optional parameters like message random number and synchronization settings. The response includes the message key and timestamp.

```Java
import io.github.doocs.im.model.request.SendMsgRequest;
import io.github.doocs.im.model.response.SendMsgResult;
import io.github.doocs.im.model.message.TIMTextMsgElement;
import io.github.doocs.im.constant.SyncOtherMachine;
import java.util.Collections;

SendMsgRequest request = SendMsgRequest.builder()
    .fromAccount("admin")
    .toAccount("user001")
    .msgRandom(System.currentTimeMillis())
    .msgBody(Collections.singletonList(new TIMTextMsgElement("Hello, this is a test message!")))
    .syncOtherMachine(SyncOtherMachine.YES)
    .msgLifeTime(604800) // 7 days
    .build();

try {
    SendMsgResult result = client.message.sendMsg(request);
    System.out.println("Message sent, MsgKey: " + result.getMsgKey() +
        ", MsgTime: " + result.getMsgTime());
} catch (IOException e) {
    e.printStackTrace();
}
```

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

### Add Friend in Java

Source: https://context7.com/doocs/qcloud-im-server-sdk-java/llms.txt

Sends a friend request to a user, optionally including a verification message, remark, and group assignment.

```java
import io.github.doocs.im.model.request.FriendAddRequest;
import io.github.doocs.im.model.request.AddFriendItem;
import io.github.doocs.im.model.response.FriendAddResult;
import io.github.doocs.im.constant.AddType;
import java.util.Collections;

FriendAddRequest request = FriendAddRequest.builder()
    .fromAccount("user001")
    .addFriendItem(Collections.singletonList(
        AddFriendItem.builder()
            .toAccount("user002")
            .addSource("AddSource_Type_Web")
            .addWording("Hi, let's be friends!")
            .remark("Colleague")
            .groupName(Collections.singletonList("Work"))
            .build()
    ))
    .addType(AddType.ADD_TYPE_BOTH)
    .forceAddFlags(0)
    .build();

try {
    FriendAddResult result = client.sns.friendAdd(request);
    result.getResultItem().forEach(item -> {
        System.out.println("To: " + item.getToAccount() + ", Result: " + item.getResultCode());
    });
} catch (IOException e) {
    e.printStackTrace();
}
```

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

### Account Management: Kick User Offline (Java)

Source: https://context7.com/doocs/qcloud-im-server-sdk-java/llms.txt

Forces a user offline by invalidating their login session across all devices. This is useful for security or administrative purposes. It takes a user identifier as input and returns a status indicating success or failure.

```Java
import io.github.doocs.im.model.request.KickRequest;
import io.github.doocs.im.model.response.KickResult;

KickRequest request = new KickRequest("user001");

try {
    KickResult result = client.account.kick(request);
    if ("OK".equals(result.getActionStatus())) {
        System.out.println("User kicked successfully");
    }
} catch (IOException e) {
    e.printStackTrace();
}
```

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

### Single Chat: Batch Send Messages (Java)

Source: https://context7.com/doocs/qcloud-im-server-sdk-java/llms.txt

Enables sending the same message to multiple recipients simultaneously in a single API call. This is efficient for broadcasting messages. It requires the sender, a list of recipient account identifiers, and the message content. The result indicates any errors encountered during the batch send operation.

```Java
import io.github.doocs.im.model.request.BatchSendMsgRequest;
import io.github.doocs.im.model.response.BatchSendMsgResult;
import io.github.doocs.im.model.message.TIMTextMsgElement;
import java.util.Arrays;
import java.util.Collections;

BatchSendMsgRequest request = BatchSendMsgRequest.builder()
    .fromAccount("admin")
    .toAccount(Arrays.asList("user001", "user002", "user003"))
    .msgRandom(System.currentTimeMillis())
    .msgBody(Collections.singletonList(new TIMTextMsgElement("Broadcast message to all users")))
    .build();

try {
    BatchSendMsgResult result = client.message.batchSendMsg(request);
    System.out.println("Batch send completed, errors: " + result.getErrorList().size());
} catch (IOException e) {
    e.printStackTrace();
}
```

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

### Single Chat: Withdraw Message (Java)

Source: https://context7.com/doocs/qcloud-im-server-sdk-java/llms.txt

Recalls a previously sent message within the allowed time window. This is useful for correcting mistakes or retracting messages. It requires the sender, receiver, and the message key of the message to be withdrawn. The result indicates if the withdrawal was successful.

```Java
import io.github.doocs.im.model.request.AdminMsgWithdrawRequest;
import io.github.doocs.im.model.response.AdminMsgWithdrawResult;

AdminMsgWithdrawRequest request = AdminMsgWithdrawRequest.builder()
    .fromAccount("user001")
    .toAccount("user002")
    .msgKey("msg_key_from_send_result")
    .build();

try {
    AdminMsgWithdrawResult result = client.message.msgWithdraw(request);
    if ("OK".equals(result.getActionStatus())) {
        System.out.println("Message withdrawn successfully");
    }
} catch (IOException e) {
    e.printStackTrace();
}
```

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

### Configure Global User Mute

Source: https://context7.com/doocs/qcloud-im-server-sdk-java/llms.txt

Sets a mute status for a user, preventing them from sending messages in C2C or group contexts. The mute duration can be specified as permanent or for a set time in seconds.

```java
import io.github.doocs.im.model.request.SetNoSpeakingRequest;
import io.github.doocs.im.model.response.SetNoSpeakingResult;
import io.github.doocs.im.constant.NoSpeakingTime;

SetNoSpeakingRequest request = SetNoSpeakingRequest.builder()
    .setAccount("user001")
    .c2cMsgNoSpeakingTime(NoSpeakingTime.FOREVER) // Permanent mute for C2C
    .groupMsgNoSpeakingTime(3600) // Mute for 1 hour in groups
    .build();

try {
    SetNoSpeakingResult result = client.operation.setNoSpeaking(request);
    if ("OK".equals(result.getActionStatus())) {
        System.out.println("Global mute set successfully");
    }
} catch (IOException e) {
    e.printStackTrace();
}
```

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

### Single Chat: Set Message Read (Java)

Source: https://context7.com/doocs/qcloud-im-server-sdk-java/llms.txt

Marks all messages from a specific sender as read for a particular user. This is typically used to update the read status of messages. It requires the account reporting the read status and the peer account whose messages are being marked as read. The response confirms the action's status.

```Java
import io.github.doocs.im.model.request.AdminSetMsgReadRequest;
import io.github.doocs.im.model.response.AdminSetMsgReadResult;

AdminSetMsgReadRequest request = AdminSetMsgReadRequest.builder()
    .reportAccount("user001")
    .peerAccount("user002")
    .build();

try {
    AdminSetMsgReadResult result = client.message.setMsgRead(request);
    if ("OK".equals(result.getActionStatus())) {
        System.out.println("Messages marked as read");
    }
} catch (IOException e) {
    e.printStackTrace();
}
```

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

### Set User Profile Attributes

Source: https://context7.com/doocs/qcloud-im-server-sdk-java/llms.txt

Updates specific user profile fields such as nickname, avatar, gender, and custom signatures. It utilizes the PortraitSetRequest builder to define the target account and the profile items to be modified.

```java
import io.github.doocs.im.model.request.PortraitSetRequest;
import io.github.doocs.im.model.request.ProfileItem;
import io.github.doocs.im.model.response.PortraitSetResult;
import io.github.doocs.im.constant.TagProfile;
import java.util.Arrays;

PortraitSetRequest request = PortraitSetRequest.builder()
    .fromAccount("user001")
    .profileItem(Arrays.asList(
        new ProfileItem(TagProfile.IM_NICK, "John Doe"),
        new ProfileItem(TagProfile.IM_GENDER, "Gender_Type_Male"),
        new ProfileItem(TagProfile.IM_IMAGE, "https://example.com/avatar.png"),
        new ProfileItem(TagProfile.IM_SELF_SIGNATURE, "Hello, I'm John!")
    ))
    .build();

try {
    PortraitSetResult result = client.profile.portraitSet(request);
    if ("OK".equals(result.getActionStatus())) {
        System.out.println("Profile updated successfully");
    }
} catch (IOException e) {
    e.printStackTrace();
}
```

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

### Single Chat: Query Roaming Messages (Java)

Source: https://context7.com/doocs/qcloud-im-server-sdk-java/llms.txt

Retrieves chat history between two users with support for pagination. This function allows fetching messages within a specified time range. It requires the sender and receiver account identifiers, and time parameters. The output is a list of messages, each containing sender, timestamp, and message key.

```Java
import io.github.doocs.im.model.request.AdminGetRoamMsgRequest;
import io.github.doocs.im.model.response.AdminRoamMsgResult;

AdminGetRoamMsgRequest request = AdminGetRoamMsgRequest.builder()
    .fromAccount("user001")
    .toAccount("user002")
    .maxCnt(20)
    .minTime(System.currentTimeMillis() / 1000 - 86400 * 7) // Last 7 days
    .maxTime(System.currentTimeMillis() / 1000)
    .build();

try {
    AdminRoamMsgResult result = client.message.getRoamMsg(request);
    result.getMsgList().forEach(msg -> {
        System.out.println("From: " + msg.getFromAccount() +
            ", Time: " + msg.getMsgTimeStamp() +
            ", Key: " + msg.getMsgKey());
    });
} catch (IOException e) {
    e.printStackTrace();
}
```

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

### Send Broadcast Push Notifications

Source: https://context7.com/doocs/qcloud-im-server-sdk-java/llms.txt

Sends a broadcast message to all users or a defined set of users. The request includes the message body, sender account, and message lifetime configuration.

```java
import io.github.doocs.im.model.request.ImPushRequest;
import io.github.doocs.im.model.response.ImPushResult;
import io.github.doocs.im.model.message.TIMTextMsgElement;
import java.util.Collections;

ImPushRequest request = ImPushRequest.builder()
    .fromAccount("admin")
    .msgRandom(System.currentTimeMillis())
    .msgBody(Collections.singletonList(new TIMTextMsgElement("System maintenance notice: Server will restart at 3:00 AM")))
    .msgLifeTime(86400)
    .build();

try {
    ImPushResult result = client.member.imPush(request);
    System.out.println("Push task ID: " + result.getTaskId());
} catch (IOException e) {
    e.printStackTrace();
}
```

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

### Content Moderation - Add Sensitive Keywords

Source: https://context7.com/doocs/qcloud-im-server-sdk-java/llms.txt

Adds custom sensitive keywords to the local moderation dictionary to filter out unwanted content.

```APIDOC
## POST /v4/keyword/add_local_audit_keywords

### Description
Adds custom sensitive keywords to the local moderation dictionary.

### Method
POST

### Endpoint
/v4/keyword/add_local_audit_keywords

### Parameters
#### Request Body
- **keywords** (array of strings) - Required - A list of sensitive keywords to add.

### Request Example
```json
{
  "keywords": ["spam", "advertisement", "prohibited"]
}
```

### Response
#### Success Response (200)
- **ActionStatus** (string) - Status of the action (e.g., "OK").
- **ErrorInfo** (string) - Error message if the action failed.
- **ErrorCode** (integer) - Error code if the action failed.

#### Response Example
```json
{
  "ActionStatus": "OK",
  "ErrorInfo": "",
  "ErrorCode": 0
}
```
```

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

### POST /v4/openim/sendmsg

Source: https://context7.com/doocs/qcloud-im-server-sdk-java/llms.txt

Sends a one-to-one chat message to a specific user, supporting various content types.

```APIDOC
## POST /v4/openim/sendmsg

### Description
Send a one-to-one chat message with various content types including text, images, and custom data.

### Method
POST

### Endpoint
/v4/openim/sendmsg

### Request Body
- **From_Account** (string) - Required - Sender ID.
- **To_Account** (string) - Required - Recipient ID.
- **MsgRandom** (integer) - Required - Random number for message identification.
- **MsgBody** (array) - Required - List of message elements.

### Request Example
{
  "From_Account": "admin",
  "To_Account": "user001",
  "MsgRandom": 123456789,
  "MsgBody": [{"MsgType": "TIMTextElem", "MsgContent": {"Text": "Hello"}}]
}

### Response
#### Success Response (200)
- **MsgKey** (string) - Unique identifier for the message.
- **MsgTime** (integer) - Timestamp of the message.

#### Response Example
{
  "MsgKey": "12345",
  "MsgTime": 1672531200
}
```

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

### Send Group Message - Java

Source: https://context7.com/doocs/qcloud-im-server-sdk-java/llms.txt

Sends a message to a specified group chat. The message is visible to all group members and can contain various content types, such as text.

```java
import io.github.doocs.im.model.request.SendGroupMsgRequest;
import io.github.doocs.im.model.response.SendGroupMsgResult;
import io.github.doocs.im.model.message.TIMTextMsgElement;
import java.util.Collections;

SendGroupMsgRequest request = SendGroupMsgRequest.builder()
    .groupId("@TGS#2CLUZEAEJ")
    .fromAccount("admin")
    .msgRandom(System.currentTimeMillis())
    .msgBody(Collections.singletonList(new TIMTextMsgElement("Hello group members!")))
    .build();

try {
    SendGroupMsgResult result = client.group.sendGroupMsg(request);
    System.out.println("Group message sent, MsgSeq: " + result.getMsgSeq());
} catch (IOException e) {
    e.printStackTrace();
}
```

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

### Message Types - Image Message

Source: https://context7.com/doocs/qcloud-im-server-sdk-java/llms.txt

Sends image messages, including original and thumbnail image details.

```APIDOC
## POST /v4/msg_online_status/send_msg

### Description
Sends an image message with details for both the original image and its thumbnail.

### Method
POST

### Endpoint
/v4/msg_online_status/send_msg

### Parameters
#### Request Body
- **From_Account** (string) - Required - The sender's account ID.
- **To_Account** (string) - Required - The recipient's account ID.
- **MsgRandom** (integer) - Required - A random number generated by the client to prevent message duplication.
- **MsgBody** (array of objects) - Required - An array containing message elements. For image messages, this includes `TIMImageMsgElement`.
  - **MsgType** (string) - Required - Type of the message, should be "TIMImageElem".
  - **MsgContent** (object) - Required - Content of the image message.
    - **UUID** (string) - Required - Unique identifier for the image.
    - **ImageFormat** (integer) - Required - Format of the image (e.g., 1 for JPG, 2 for GIF, 3 for PNG).
    - **ImageInfoArray** (array of objects) - Required - An array containing information about different image versions.
      - **Type** (integer) - Required - Type of the image version (e.g., 1 for Original, 2 for Thumbnail).
      - **URL** (string) - Required - URL of the image.
      - **Width** (integer) - Required - Width of the image in pixels.
      - **Height** (integer) - Required - Height of the image in pixels.
      - **Size** (integer) - Required - Size of the image in bytes.

### Request Example
```json
{
  "From_Account": "user001",
  "To_Account": "user002",
  "MsgRandom": 1678886401,
  "MsgBody": [
    {
      "MsgType": "TIMImageElem",
      "MsgContent": {
        "UUID": "image_uuid_12345",
        "ImageFormat": 1,
        "ImageInfoArray": [
          {
            "Type": 1,
            "URL": "https://example.com/images/original.jpg",
            "Width": 1920,
            "Height": 1080,
            "Size": 204800
          },
          {
            "Type": 2,
            "URL": "https://example.com/images/thumb.jpg",
            "Width": 200,
            "Height": 112,
            "Size": 10240
          }
        ]
      }
    }
  ]
}
```

### Response
#### Success Response (200)
- **MsgKey** (string) - The unique key of the sent message.

#### Response Example
```json
{
  "MsgKey": "message_key_67890"
}
```
```

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

### Mute Group Members in Java

Source: https://context7.com/doocs/qcloud-im-server-sdk-java/llms.txt

Temporarily restricts specific group members from sending messages by setting a mute duration. It requires a group ID and a list of member accounts.

```java
import io.github.doocs.im.model.request.ForbidSendMsgRequest;
import io.github.doocs.im.model.response.ForbidSendMsgResult;
import java.util.Arrays;

ForbidSendMsgRequest request = ForbidSendMsgRequest.builder()
    .groupId("@TGS#2CLUZEAEJ")
    .membersAccount(Arrays.asList("user001", "user002"))
    .muteTime(3600) // Mute for 1 hour, 0 to unmute
    .build();

try {
    ForbidSendMsgResult result = client.group.forbidSendMsg(request);
    if ("OK".equals(result.getActionStatus())) {
        System.out.println("Members muted successfully");
    }
} catch (IOException e) {
    e.printStackTrace();
}
```

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

### Destroy Group in Java

Source: https://context7.com/doocs/qcloud-im-server-sdk-java/llms.txt

Permanently deletes a specified group and all associated data from the IM server.

```java
import io.github.doocs.im.model.request.DestroyGroupRequest;
import io.github.doocs.im.model.response.DestroyGroupResult;

DestroyGroupRequest request = new DestroyGroupRequest("@TGS#2CLUZEAEJ");

try {
    DestroyGroupResult result = client.group.destroyGroup(request);
    if ("OK".equals(result.getActionStatus())) {
        System.out.println("Group destroyed successfully");
    }
} catch (IOException e) {
    e.printStackTrace();
}
```

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

### Recall Group Message in Java

Source: https://context7.com/doocs/qcloud-im-server-sdk-java/llms.txt

Removes a previously sent message from a group using its sequence number. The result provides the status code for each recalled message.

```java
import io.github.doocs.im.model.request.GroupMsgRecallRequest;
import io.github.doocs.im.model.response.GroupMsgRecallResult;
import io.github.doocs.im.model.request.MsgSeqItem;
import java.util.Collections;

GroupMsgRecallRequest request = GroupMsgRecallRequest.builder()
    .groupId("@TGS#2CLUZEAEJ")
    .msgSeqList(Collections.singletonList(new MsgSeqItem(12345L)))
    .build();

try {
    GroupMsgRecallResult result = client.group.groupMsgRecall(request);
    result.getRecallRetList().forEach(item -> {
        System.out.println("MsgSeq: " + item.getMsgSeq() + ", RetCode: " + item.getRetCode());
    });
} catch (IOException e) {
    e.printStackTrace();
}
```

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

### Message Types - Custom Message

Source: https://context7.com/doocs/qcloud-im-server-sdk-java/llms.txt

Sends custom structured messages containing application-specific data, useful for notifications or structured events.

```APIDOC
## POST /v4/msg_online_status/send_msg

### Description
Sends a custom structured message with application-specific data.

### Method
POST

### Endpoint
/v4/msg_online_status/send_msg

### Parameters
#### Request Body
- **From_Account** (string) - Required - The sender's account ID.
- **To_Account** (string) - Required - The recipient's account ID.
- **MsgRandom** (integer) - Required - A random number generated by the client to prevent message duplication.
- **MsgBody** (array of objects) - Required - An array containing message elements. For custom messages, this includes `TIMCustomMsgElement`.
  - **MsgType** (string) - Required - Type of the message, should be "TIMCustomElem".
  - **MsgContent** (object) - Required - Content of the custom message.
    - **Data** (string) - Required - The custom data payload, typically a JSON string.
    - **Desc** (string) - Optional - A description of the custom message.
    - **Ext** (string) - Optional - Extended information for the custom message.

### Request Example
```json
{
  "From_Account": "system",
  "To_Account": "user001",
  "MsgRandom": 1678886400,
  "MsgBody": [
    {
      "MsgType": "TIMCustomElem",
      "MsgContent": {
        "Data": "{\"type\":\"order\",\"orderId\":\"12345\",\"status\":\"shipped\"}",
        "Desc": "Order Status Update",
        "Ext": "order_notification"
      }
    }
  ]
}
```

### Response
#### Success Response (200)
- **MsgKey** (string) - The unique key of the sent message.

#### Response Example
```json
{
  "MsgKey": "message_key_12345"
}
```
```

=== COMPLETE CONTENT === This response contains all available snippets from this library. No additional content exists. Do not make further requests.