Docs Overview/
Chat/
SDK/
Android/
Message/
Do not Notify/

Do not Notify

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