tencent cloud

Feedback

Android&iOS&Windows&Mac

Last updated: 2024-08-01 16:19:43

    Overview

    By setting the message receiving options for one-to-one, group chat, or all messages, you can implement a feature similar to WhatsApp where messages do not disturb.
    Note:
    One-to-one and group chat message receiving options are only supported by the Enhanced SDK version 5.3.425 or later.
    Global message receiving options are only supported by the Enhanced SDK version 7.4.4643 or later.
    The SDK offers three types of message receiving options, defined in V2TIMReceiveMessageOpt as follows:
    Message Receiving Option
    Supported Type
    Description
    V2TIM_RECEIVE_MESSAGE
    One-to-one Chat, Group Chat, All Messages
    Receive messages normally when online, and receive offline push notifications when offline
    V2TIM_NOT_RECEIVE_MESSAGE
    One-to-one Chat, Group Chat
    Do not receive messages whether online or offline
    V2TIM_RECEIVE_NOT_NOTIFY_MESSAGE
    One-to-one Chat, Group Chat, All Messages
    Receive messages normally when online, but do not receive offline push notifications when offline
    V2TIM_RECEIVE_NOT_NOTIFY_MESSAGE_EXCEPT_AT
    Group Chat
    Receive messages online, only receive at message pushes when offline
    V2TIM_NOT_RECEIVE_MESSAGE_EXCEPT_AT
    Topic
    Only receive at messages when online or offline
    Setting different V2TIMReceiveMessageOpt options can implement different Do Not Disturb effects:
    Do Not Disturb Effect
    Message Receiving Option
    Description
    Do not receive any messages at all
    V2TIM_NOT_RECEIVE_MESSAGE
    No messages can be received, and the conversation list will not be updated.
    Receive messages but without notifications
    V2TIM_RECEIVE_NOT_NOTIFY_MESSAGE
    At this time, it is recommended to display a red dot on the conversation list (without showing the unread count):
    1. When a new message is received and the conversation list needs to be updated, obtain the message unread count through the unreadCount in the V2TIMConversation of the conversation.
    2. If the unread count is greater than zero, display a red dot instead of the unread number.
    Receive messages but only alert for at messages
    V2TIM_RECEIVE_NOT_NOTIFY_MESSAGE_EXCEPT_AT
    Within a specified time window, all messages for the logged-in account can be received online; there will be no push when offline.
    Only receive at messages
    V2TIM_NOT_RECEIVE_MESSAGE_EXCEPT_AT
    Only receive at messages on a topic when online or offline
    Note:
    In the above implementations, if it requires the unreadCount feature in V2TIMConversation, it applies only to work groups (Work), public groups (Public), and communities (Community), but not to audio-video groups (AVChatRoom) or meeting groups (Meeting). For more information on group types, see Group System.

    Setting One-to-One Chat Option

    Call setC2CReceiveMessageOpt (Android/iOS and macOS/Windows) to set the message receiving option for a one-to-one chat. You can use the userIDList parameter to specify up to 30 users at a time.
    Note:
    This API can be called by a user up to 5 times every second.
    Sample code:
    Android
    iOS and macOS
    Windows
    // Set not to receive messages no matter whether the user is online or offline
    
    List<String> userList = new ArrayList<>();
    userList.add("user1");
    userList.add("user2");
    
    V2TIMManager.getMessageManager().setC2CReceiveMessageOpt(userList, V2TIMMessage.V2TIM_NOT_RECEIVE_MESSAGE, new V2TIMCallback() {
    @Override
    public void onSuccess() {
    Log.i("imsdk", "success");
    }
    
    @Override
    public void onError(int code, String desc) {
    Log.i("imsdk", "failure, code:" + code + ", desc:" + desc);
    }
    });
    // Set not to receive messages no matter whether the user is online or offline
    
    NSArray* array = [NSArray arrayWithObjects:@"user1", @"user2", nil]];
    [[V2TIMManager sharedInstance] setC2CReceiveMessageOpt:array opt:V2TIM_NOT_RECEIVE_MESSAGE succ:^{
    NSLog(@"success");
    } fail:^(int code, NSString *desc) {
    NSLog(@"failure, code:%d, desc:%@", code, desc);
    }];
    class Callback final : public V2TIMCallback {
    public:
    using SuccessCallback = std::function<void()>;
    using ErrorCallback = std::function<void(int, const V2TIMString&)>;
    
    Callback() = default;
    ~Callback() override = default;
    
    void SetCallback(SuccessCallback success_callback, ErrorCallback error_callback) {
    success_callback_ = std::move(success_callback);
    error_callback_ = std::move(error_callback);
    }
    
    void OnSuccess() override {
    if (success_callback_) {
    success_callback_();
    }
    }
    void OnError(int error_code, const V2TIMString& error_message) override {
    if (error_callback_) {
    error_callback_(error_code, error_message);
    }
    }
    
    private:
    SuccessCallback success_callback_;
    ErrorCallback error_callback_;
    };
    
    V2TIMStringVector userIDList;
    userIDList.PushBack("user1");
    userIDList.PushBack("user2");
    V2TIMReceiveMessageOpt opt = V2TIMReceiveMessageOpt::V2TIM_NOT_RECEIVE_MESSAGE;
    
    auto callback = new Callback;
    callback->SetCallback(
    [=]() {
    // Configured successfully
    delete callback;
    },
    [=](int error_code, const V2TIMString& error_message) {
    // Failed to configure
    delete callback;
    });
    
    V2TIMManager::GetInstance()->GetMessageManager()->SetC2CReceiveMessageOpt(userIDList, opt, callback);

    Getting One-to-One Chat Option

    Call getC2CReceiveMessageOpt (Android/iOS and macOS/Windows) to get the message receiving option for a one-to-one chat.
    Sample code:
    Android
    iOS and macOS
    Windows
    List<String> userList = new ArrayList<>();
    userList.add("user1");
    userList.add("user2");
    
    V2TIMManager.getMessageManager().getC2CReceiveMessageOpt(userList, new V2TIMValueCallback<List<V2TIMReceiveMessageOptInfo>>() {
    @Override
    public void onSuccess(List<V2TIMReceiveMessageOptInfo> v2TIMReceiveMessageOptInfos) {
    for (int i = 0; i < v2TIMReceiveMessageOptInfos.size(); i++){
    V2TIMReceiveMessageOptInfo info = v2TIMReceiveMessageOptInfos.get(i);
    Log.i("imsdk", "userId: " + info.getUserID() ", receiveOpt: " + info.getC2CReceiveMessageOpt());
    }
    }
    
    @Override
    public void onError(int code, String desc) {
    Log.i("imsdk", "failure, code:" + code + ", desc:" + desc);
    }
    });
    NSArray* array = [NSArray arrayWithObjects:@"user1", @"user2", nil]];
    [[V2TIMManager sharedInstance] getC2CReceiveMessageOpt:array succ:^(NSArray<V2TIMReceiveMessageOptInfo *> *optList) {
    for (int i = 0; i < optList.count; i++) {
    V2TIMReceiveMessageOptInfo* info = optList[i];
    NSLog(@"userId: %@, receiveOpt: %@", info.userID, info.receiveOpt);
    }
    } fail:^(int code, NSString *desc) {
    NSLog(@"failure, code:%d, desc:%@", code, desc);
    }];
    template <class T>
    class ValueCallback final : public V2TIMValueCallback<T> {
    public:
    using SuccessCallback = std::function<void(const T&)>;
    using ErrorCallback = std::function<void(int, const V2TIMString&)>;
    
    ValueCallback() = default;
    ~ValueCallback() override = default;
    
    void SetCallback(SuccessCallback success_callback, ErrorCallback error_callback) {
    success_callback_ = std::move(success_callback);
    error_callback_ = std::move(error_callback);
    }
    
    void OnSuccess(const T& value) override {
    if (success_callback_) {
    success_callback_(value);
    }
    }
    void OnError(int error_code, const V2TIMString& error_message) override {
    if (error_callback_) {
    error_callback_(error_code, error_message);
    }
    }
    
    private:
    SuccessCallback success_callback_;
    ErrorCallback error_callback_;
    };
    
    V2TIMStringVector userIDList;
    userIDList.PushBack("user1");
    userIDList.PushBack("user2");
    
    auto callback = new ValueCallback<V2TIMReceiveMessageOptInfoVector>{};
    callback->SetCallback(
    [=](const V2TIMReceiveMessageOptInfoVector& receiveMessageOptInfoList) {
    for (size_t i = 0; i < receiveMessageOptInfoList.Size(); ++i) {
    const V2TIMReceiveMessageOptInfo& opt = receiveMessageOptInfoList[i];
    V2TIMString userID = opt.userID;
    V2TIMReceiveMessageOpt receiveOpt = opt.receiveOpt;
    }
    
    delete callback;
    },
    [=](int error_code, const V2TIMString& error_message) {
    // Failed to obtain
    delete callback;
    });
    
    V2TIMManager::GetInstance()->GetMessageManager()->GetC2CReceiveMessageOpt(userIDList, callback);

    Setting Group Chat Option

    Call setGroupReceiveMessageOpt (Android/iOS and macOS/Windows) to set the message receiving option for a group chat.
    Sample code:
    Android
    iOS and macOS
    Windows
    // Set not to receive messages no matter whether the user is online or offline
    
    String groupID = "groupID";
    V2TIMManager.getMessageManager().setGroupReceiveMessageOpt(groupID, V2TIMMessage.V2TIM_NOT_RECEIVE_MESSAGE, new V2TIMCallback() {
    @Override
    public void onSuccess() {
    Log.i("imsdk", "success");
    }
    
    @Override
    public void onError(int code, String desc) {
    Log.i("imsdk", "failure, code:" + code + ", desc:" + desc);
    }
    });
    // Set not to receive messages no matter whether the user is online or offline
    
    NSString *groupID = @"groupID";
    [[V2TIMManager sharedInstance] setGroupReceiveMessageOpt:groupID opt:V2TIM_NOT_RECEIVE_MESSAGE succ:^{
    NSLog(@"success");
    } fail:^(int code, NSString *desc) {
    NSLog(@"failure, code:%d, desc:%@", code, desc);
    }];
    class Callback final : public V2TIMCallback {
    public:
    using SuccessCallback = std::function<void()>;
    using ErrorCallback = std::function<void(int, const V2TIMString&)>;
    
    Callback() = default;
    ~Callback() override = default;
    
    void SetCallback(SuccessCallback success_callback, ErrorCallback error_callback) {
    success_callback_ = std::move(success_callback);
    error_callback_ = std::move(error_callback);
    }
    
    void OnSuccess() override {
    if (success_callback_) {
    success_callback_();
    }
    }
    void OnError(int error_code, const V2TIMString& error_message) override {
    if (error_callback_) {
    error_callback_(error_code, error_message);
    }
    }
    
    private:
    SuccessCallback success_callback_;
    ErrorCallback error_callback_;
    };
    
    V2TIMString groupID = "groupID";
    V2TIMReceiveMessageOpt opt = V2TIMReceiveMessageOpt::V2TIM_NOT_RECEIVE_MESSAGE;
    
    auto callback = new Callback;
    callback->SetCallback(
    [=]() {
    // Configured successfully
    delete callback;
    },
    [=](int error_code, const V2TIMString& error_message) {
    // Failed to configure
    delete callback;
    });
    
    V2TIMManager::GetInstance()->GetMessageManager()->SetGroupReceiveMessageOpt(groupID, opt, callback);

    Getting Group Chat Option

    Call the getGroupsInfo API (Android/iOS and macOS/Windows) to get the list of V2TIMGroupInfo objects in the group profile. Here, the recvOpt field of the object indicates the message receiving option for the group chat.
    Sample code:
    Android
    iOS and macOS
    Windows
    List<String> groupIDList = new ArrayList<>();
    groupIDList.add("groupID1");
    groupIDList.add("groupID2");
    V2TIMManager.getGroupManager().getGroupsInfo(groupIDList, new V2TIMValueCallback<List<V2TIMGroupInfoResult>>() {
    @Override
    public void onSuccess(List<V2TIMGroupInfoResult> v2TIMGroupProfileResults) {
    for (V2TIMGroupInfoResult result : v2TIMGroupProfileResults) {
    V2TIMGroupInfo info = result.getGroupInfo();
    Log.i("imsdk", "recvOpt: " + info.getRecvOpt());
    }
    }
    
    @Override
    public void onError(int code, String desc) {
    Log.i("imsdk", "failure, code:" + code + ", desc:" + desc);
    }
    });
    NSArray* array = [NSArray arrayWithObjects:@"groupID1", @"groupID2", nil]];
    [[V2TIMManager sharedInstance] getGroupsInfo:array succ:^(NSArray<V2TIMGroupInfoResult *> * groupResultList) {
    for (V2TIMGroupInfoResult *result in groupResultList){
    V2TIMGroupInfo *info = result.info;
    NSLog(@"recvOpt, %d", (int)info.recvOpt);
    }
    } fail:^(int code, NSString *desc) {
    NSLog(@"failure, code:%d, desc:%@", code, desc);
    }];
    template <class T>
    class ValueCallback final : public V2TIMValueCallback<T> {
    public:
    using SuccessCallback = std::function<void(const T&)>;
    using ErrorCallback = std::function<void(int, const V2TIMString&)>;
    
    ValueCallback() = default;
    ~ValueCallback() override = default;
    
    void SetCallback(SuccessCallback success_callback, ErrorCallback error_callback) {
    success_callback_ = std::move(success_callback);
    error_callback_ = std::move(error_callback);
    }
    
    void OnSuccess(const T& value) override {
    if (success_callback_) {
    success_callback_(value);
    }
    }
    void OnError(int error_code, const V2TIMString& error_message) override {
    if (error_callback_) {
    error_callback_(error_code, error_message);
    }
    }
    
    private:
    SuccessCallback success_callback_;
    ErrorCallback error_callback_;
    };
    
    V2TIMStringVector groupIDList;
    groupIDList.PushBack("groupID1");
    groupIDList.PushBack("groupID2");
    
    auto callback = new ValueCallback<V2TIMGroupInfoResultVector>{};
    callback->SetCallback(
    [=](const V2TIMGroupInfoResultVector& groupInfoResultList) {
    for (size_t i = 0; i < groupInfoResultList.Size(); ++i) {
    const V2TIMGroupInfo& info = groupInfoResultList[i].info;
    V2TIMReceiveMessageOpt recvOpt = info.recvOpt;
    }
    
    delete callback;
    },
    [=](int error_code, const V2TIMString& error_message) {
    // Failed to obtain
    delete callback;
    });
    
    V2TIMManager::GetInstance()->GetGroupManager()->GetGroupsInfo(groupIDList, callback);

    Setting All Messages Option

    Call the setAllReceiveMessageOpt(Android/iOS & Mac/Windows) to set the message receiving option for all message. Support is provided for setting daily repetition, as well as for specifying a specific time period for activation.
    Sample code:
    Android
    iOS & Mac
    Windows
    // Set the logged-in account to receive messages normally online between 10 PM and 6 AM every day, without receiving push notifications when offline.
    
    V2TIMManager.getMessageManager().setAllReceiveMessageOpt(V2TIMMessage.V2TIM_RECEIVE_NOT_NOTIFY_MESSAGE, 22, 0, 0, 8*60*60, new V2TIMCallback() {
    @Override
    public void onSuccess() {
    Log.d("imsdk", "setAllReceiveMessageOpt onSuccess");
    }
    @Override
    public void onError(int code, String desc) {
    Log.d("imsdk", "setAllReceiveMessageOpt onError code = " + code + ", desc = " + desc);
    }});
    
    
    // Assuming that 10 PM UTC time tonight is 12345678
    // set the logged-in account to receive messages normally online and not receive push notifications when offline for a continuous period of three days starting from 10 PM tonight (12345678 UTC time).
    V2TIMManager.getMessageManager().setAllReceiveMessageOpt(V2TIMMessage.V2TIM_RECEIVE_NOT_NOTIFY_MESSAGE, 12345678, 3*24*60*60, new V2TIMCallback() {
    @Override
    public void onSuccess() {
    Log.d("imsdk", "setAllReceiveMessageOpt onSuccess");
    }
    @Override
    public void onError(int code, String desc) {
    Log.d("imsdk", "setAllReceiveMessageOpt onError code = " + code + ", desc = " + desc);
    }});
    // Set the logged-in account to receive messages normally online between 10 PM and 6 AM every day, without receiving push notifications when offline.
    
    [[V2TIMManager sharedInstance] setAllReceiveMessageOpt:V2TIM_RECEIVE_NOT_NOTIFY_MESSAGE startHour:22 startMinute:0 startSecond:0 duration:8*60*60 succ:^{
    NSLog(@"success");
    } fail:^(int code, NSString *desc) {
    NSLog(@"failure, code:%d, desc:%@", code, desc);
    }];
    
    
    // Assuming that 10 PM UTC time tonight is 12345678
    // set the logged-in account to receive messages normally online and not receive push notifications when offline for a continuous period of three days starting from 10 PM tonight (12345678 UTC time).
    [[V2TIMManager sharedInstance] setAllReceiveMessageOpt:V2TIM_RECEIVE_NOT_NOTIFY_MESSAGE startTimeStamp:12345678 duration:3*24*60*60 succ:^{
    NSLog(@"success");
    } fail:^(int code, NSString *desc) {
    NSLog(@"failure, code:%d, desc:%@", code, desc);
    }];
    class Callback final : public V2TIMCallback {
    public:
    using SuccessCallback = std::function<void()>;
    using ErrorCallback = std::function<void(int, const V2TIMString&)>;
    
    Callback() = default;
    ~Callback() override = default;
    
    void SetCallback(SuccessCallback success_callback, ErrorCallback error_callback) {
    success_callback_ = std::move(success_callback);
    error_callback_ = std::move(error_callback);
    }
    
    void OnSuccess() override {
    if (success_callback_) {
    success_callback_();
    }
    }
    void OnError(int error_code, const V2TIMString& error_message) override {
    if (error_callback_) {
    error_callback_(error_code, error_message);
    }
    }
    
    private:
    SuccessCallback success_callback_;
    ErrorCallback error_callback_;
    };
    
    V2TIMReceiveMessageOpt opt = V2TIMReceiveMessageOpt::V2TIM_RECEIVE_NOT_NOTIFY_MESSAGE;
    
    auto callback = new Callback;
    callback->SetCallback(
    [=]() {
    delete callback;
    },
    [=](int error_code, const V2TIMString& error_message) {
    delete callback;
    });
    
    // Set the logged-in account to receive messages normally online between 10 PM and 6 AM every day, without receiving push notifications when offline.
    V2TIMManager::GetInstance()->GetMessageManager()->SetAllReceiveMessageOpt(opt, 22, 0, 0, 8*60*60, callback);
    
    
    // Assuming that 10 PM UTC time tonight is 12345678
    // set the logged-in account to receive messages normally online and not receive push notifications when offline for a continuous period of three days starting from 10 PM tonight (12345678 UTC time).
    V2TIMManager::GetInstance()->GetMessageManager()->SetAllReceiveMessageOpt(opt, 12345678, 3*24*60*60, callback);

    Getting All Messages Option

    Call the getAllReceiveMessageOpt (Android/iOS and macOS/Windows) to get the message receiving option for all messages, which is V2TIMReceiveMessageOptInfo (Android/iOS & Mac/Windows) .
    Sample code:
    Android
    iOS & Mac
    Windows
    V2TIMManager.getMessageManager().getAllReceiveMessageOpt(new V2TIMValueCallback<V2TIMReceiveMessageOptInfo>() {
    @Override
    public void onSuccess(V2TIMReceiveMessageOptInfo v2TIMReceiveMessageOptInfo) {
    String result = "startHour = " + v2TIMReceiveMessageOptInfo.getStartHour() +
    ", startMinute = " + v2TIMReceiveMessageOptInfo.getStartMinute() +
    ", startSecond = " + v2TIMReceiveMessageOptInfo.getStartSecond() +
    ", startTimeStamp = " + v2TIMReceiveMessageOptInfo.getStartTimeStamp() +
    ", duration = " + v2TIMReceiveMessageOptInfo.getDuration() +
    ", opt = " + v2TIMReceiveMessageOptInfo.getAllReceiveMessageOpt();
    Log.d("imsdk", "getAllReceiveMessageOpt onSuccess = " + result);
    }
    @Override
    public void onError(int code, String desc) {
    Log.d("imsdk", "getAllReceiveMessageOpt onError code = " + code + ", desc = " + desc);
    }});
    [V2TIMManager.sharedInstance getAllReceiveMessageOpt:^(V2TIMReceiveMessageOptInfo *optInfo) {
    NSLog(@"optInfo %@", optInfo);
    } fail:^(int code, NSString *desc) {
    NSLog(@"failure, code:%d, desc:%@", code, desc);
    }];
    template <class T>
    class ValueCallback final : public V2TIMValueCallback<T> {
    public:
    using SuccessCallback = std::function<void(const T&)>;
    using ErrorCallback = std::function<void(int, const V2TIMString&)>;
    
    ValueCallback() = default;
    ~ValueCallback() override = default;
    
    void SetCallback(SuccessCallback success_callback, ErrorCallback error_callback) {
    success_callback_ = std::move(success_callback);
    error_callback_ = std::move(error_callback);
    }
    
    void OnSuccess(const T& value) override {
    if (success_callback_) {
    success_callback_(value);
    }
    }
    void OnError(int error_code, const V2TIMString& error_message) override {
    if (error_callback_) {
    error_callback_(error_code, error_message);
    }
    }
    
    private:
    SuccessCallback success_callback_;
    ErrorCallback error_callback_;
    };
    
    auto callback = new ValueCallback<V2TIMReceiveMessageOptInfo>{};
    callback->SetCallback(
    [=](const V2TIMReceiveMessageOptInfo& receiveMessageOptInfo) {
    delete callback;
    },
    [=](int error_code, const V2TIMString& error_message) {
    delete callback;
    });
    
    V2TIMManager::GetInstance()->GetMessageManager()->GetAllReceiveMessageOpt(callback);
    
    Contact Us

    Contact our sales team or business advisors to help your business.

    Technical Support

    Open a ticket if you're looking for further assistance. Our Ticket is 7x24 avaliable.

    7x24 Phone Support