Javavoid addSettingListener(V2NIMSettingListener listener);

Objective-C- (void)addSettingListener:(id<V2NIMSettingListener>)listener;

C++virtual void addSettingListener(V2NIMSettingListener listener) = 0;

JavaNIMClient.getService(V2NIMSettingService.class).addSettingListener(new V2NIMSettingListener() {
    @Override
    public void onTeamMessageMuteModeChanged(String teamId, V2NIMTeamType teamType, V2NIMTeamMessageMuteMode muteMode) {

    }

    @Override
    public void onP2PMessageMuteModeChanged(String accountId, V2NIMP2PMessageMuteMode muteMode) {

    }
});

Objective-C[[[NIMSDK sharedSDK] v2SettingService] addSettingListener:self];

C++V2NIMTeamListener listener;
listener.onTeamMessageMuteModeChanged = [](std::string teamId, V2NIMTeamType teamType, V2NIMTeamMessageMuteMode muteMode) {
    // handle team message mute mode changed
};
listener.onP2PMessageMuteModeChanged = [](std::string accountId, V2NIMP2PMessageMuteMode muteMode) {
    // handle p2p message mute mode changed
};
settingService.addSettingListener(listener);

Javavoid removeSettingListener(V2NIMSettingListener listener);

Objective-C- (void)removeSettingListener:(id<V2NIMSettingListener>)listener;

C++ virtual void removeSettingListener(V2NIMSettingListener listener) = 0;

JavaNIMClient.getService(V2NIMSettingService.class).removeSettingListener(listener);

Objective-C[[[NIMSDK sharedSDK] v2SettingService] removeSettingListener:self];

C++V2NIMTeamListener listener;
// ...
settingService.removeSettingListener(listener);

TypeScriptexport interface NIMEBaseServiceInterface<I extends NIMEBaseListener> {
  /**
   * 继承自 EventEmitter3 的监听事件方法。
   */
  on<T extends keyof I>(eventName: T, fn: (...args: I[T]) => void): void;
  /**
   * 继承自 EventEmitter3 的监听事件方法。
   */
  once<T extends keyof I>(eventName: T, fn: (...args: I[T]) => void): void;
}

TypeScripton<T extends keyof I>(eventName: T, fn: (...args: I[T]) => void): void
export type V2NIMSettingListener = {

  onTeamMessageMuteModeChanged: [teamId: string, teamType: V2NIMTeamType, muteMode: V2NIMTeamMessageMuteMode]

  onP2PMessageMuteModeChanged: [accountId: string, muteMode: V2NIMP2PMessageMuteMode]
}

TypeScriptnim.V2NIMSettingService.on("onTeamMessageMuteModeChanged", function (teamId: string, teamType: V2NIMTeamType, muteMode: V2NIMTeamMessageMuteMode)
nim.V2NIMSettingService.on("onP2PMessageMuteModeChanged", function (accountId: string, muteMode: V2NIMP2PMessageMuteMode)

TypeScriptnim.settingService.on('onTeamMessageMuteModeChanged', (teamId: string, teamType: V2NIMTeamType, muteMode: V2NIMTeamMessageMuteMode) => {})
nim.settingService.on('onP2PMessageMuteModeChanged', (accountId: string, muteMode: V2NIMP2PMessageMuteMode) => {})

TypeScriptexport interface NIMEBaseServiceInterface<I extends NIMEBaseListener> {
  /**
   * 继承自 EventEmitter3 的取消监听方法。
   */
  off<T extends keyof I>(eventName: T, fn: (...args: I[T]) => void): void;
  /**
   * 继承自 EventEmitter3 的移除事件方法。
   */
  removeAllListeners<T extends keyof I>(eventName?: T): void;
}

TypeScriptoff<T extends keyof I>(eventName: T, fn: (...args: I[T]) => void): void
export type V2NIMSettingListener = {

  onTeamMessageMuteModeChanged: [teamId: string, teamType: V2NIMTeamType, muteMode: V2NIMTeamMessageMuteMode]

  onP2PMessageMuteModeChanged: [accountId: string, muteMode: V2NIMP2PMessageMuteMode]
}

TypeScriptnim.V2NIMSettingService.off("onTeamMessageMuteModeChanged", function (teamId: string, teamType: V2NIMTeamType, muteMode: V2NIMTeamMessageMuteMode)
nim.V2NIMSettingService.off("onP2PMessageMuteModeChanged", function (accountId: string, muteMode: V2NIMP2PMessageMuteMode)

TypeScriptnim.settingService.off('onTeamMessageMuteModeChanged', fn)
nim.settingService.off('onP2PMessageMuteModeChanged', fn)

Javavoid setP2PMessageMuteMode(String accountId, V2NIMP2PMessageMuteMode muteMode, V2NIMSuccessCallback<Void> success, V2NIMFailureCallback failure);

Objective-C- (void)setP2PMessageMuteMode:(NSString *)accountId
                     muteMode:(V2NIMP2PMessageMuteMode)muteMode
                      success:(nullable V2NIMSuccessCallback)success
                      failure:(nullable V2NIMFailureCallback)failure;

C++virtual void setP2PMessageMuteMode(std::string accountId,
                                   V2NIMP2PMessageMuteMode muteMode,
                                   V2NIMSuccessCallback<void> success,
                                   V2NIMFailureCallback failure) = 0;

TypeScriptsetP2PMessageMuteMode(accountId: string, muteMode: V2NIMP2PMessageMuteMode): Promise<void>

TypeScriptsetP2PMessageMuteMode(accountId: string, muteMode: V2NIMP2PMessageMuteMode): Promise<void>

JavaNIMClient.getService(V2NIMSettingService.class).setP2PMessageMuteMode(accountId, muteMode,
new V2NIMSuccessCallback<Void>() {
    @Override
    public void onSuccess(Void unused) {

    }
},
new V2NIMFailureCallback() {
    @Override
    public void onFailure(V2NIMError error) {

    }
});

Objective-C[[[NIMSDK sharedSDK] v2SettingService] setP2PMessageMuteMode:@"accountId" muteMode:V2NIM_P2P_MESSAGE_MUTE_MODE_OFF success:^{
        // 成功回调
    } failure:^(V2NIMError * _Nonnull error) {
        // 失败回调
    }];

C++settingService.setP2PMessageMuteMode(
    "accountId",
    V2NIM_P2P_MESSAGE_MUTE_MODE_ON,
    []() {
        // set p2p mute mode succeeded
    },
    [](V2NIMError error) {
        // set p2p mute mode failed, handle error
    });

TypeScriptnim.V2NIMSettingService.setP2PMessageMuteMode('accountId', 1)

TypeScriptawait nim.settingService.setP2PMessageMuteMode('accountId', V2NIMP2PMessageMuteMode.V2NIM_P2P_MESSAGE_MUTE_MODE_ON)

无返回值。

Promise<void>

• 请求成功，返回 V2NIMSuccessCallback 回调。设置成功，返回 onP2PMessageMuteModeChanged 回调。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含免打扰相关错误码。

设置成功，返回 onP2PMessageMuteModeChanged 回调。

JavaV2NIMP2PMessageMuteMode getP2PMessageMuteMode(String accountId);

Objective-C- (V2NIMP2PMessageMuteMode)getP2PMessageMuteMode:(NSString *)accountId;

C++virtual V2NIMP2PMessageMuteMode getP2PMessageMuteMode(nstd::string accountId) = 0;

TypeScriptgetP2PMessageMuteMode(accountId: string): V2NIMP2PMessageMuteMode

TypeScriptgetP2PMessageMuteMode(accountId: string): Promise<V2NIMP2PMessageMuteMode>

JavaV2NIMP2PMessageMuteMode muteMode = NIMClient.getService(V2NIMSettingService.class).getP2PMessageMuteMode(accountId);

Objective-C[[[NIMSDK sharedSDK] v2SettingService] getP2PMessageMuteMode:@"accountId"];

C++auto muteMode = settingService.getP2PMessageMuteMode("accountId");

TypeScriptconst mode = nim.V2NIMSettingService.getP2PMessageMuteMode('accountId')

TypeScriptconst mode = await nim.settingService.getP2PMessageMuteMode('accountId')

V2NIMP2PMessageMuteMode 单聊（点对点）消息免打扰模式

Promise<V2NIMP2PMessageMuteMode>

Javavoid getP2PMessageMuteList(V2NIMSuccessCallback<List<String>> success, V2NIMFailureCallback failure);

Objective-C- (void)getP2PMessageMuteList:(nullable V2NIMGetMuteListSuccess)success
                      failure:(nullable V2NIMFailureCallback)failure;

C++virtual void getP2PMessageMuteList(V2NIMSuccessCallback<nstd::vector<nstd::string>> success, V2NIMFailureCallback failure) = 0;

TypeScriptgetP2PMessageMuteList(): Promise<Array<string>>

TypeScriptgetP2PMessageMuteList(): Promise<Array<string>>

JavaNIMClient.getService(V2NIMSettingService.class).getP2PMessageMuteList(
    new V2NIMSuccessCallback<List<String>>() {
        @Override
        public void onSuccess(List<String> strings) {

        }
    },
    new V2NIMFailureCallback() {
        @Override
        public void onFailure(V2NIMError error) {

        }
    }
);

Objective-C[[[NIMSDK sharedSDK] v2SettingService] getP2PMessageMuteList:^(NSArray<NSString *> * _Nonnull result) {
    // 成功回调
} failure:^(V2NIMError * _Nonnull error) {
    // 失败回调
}];

C++settingService.getP2PMessageMuteList(
    [](nstd::vector<nstd::string> muteList) {
        // get p2p mute list succeeded, handle mute list
    },
    [](V2NIMError error) {
        // get p2p mute list failed, handle error
    });

TypeScriptconst mutedList = await nim.V2NIMSettingService.getP2PMessageMuteList()

TypeScriptconst mutedList = await nim.settingService.getP2PMessageMuteList()

无返回值。

Promise<Array>

• 请求成功，返回 V2NIMSuccessCallback 回调，包含 accountId 列表。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含免打扰相关错误码。

无。

Javavoid setTeamMessageMuteMode(String teamId, V2NIMTeamType teamType, V2NIMTeamMessageMuteMode muteMode, V2NIMSuccessCallback<Void> success, V2NIMFailureCallback failure);

Objective-C- (void)setTeamMessageMuteMode:(NSString *)teamId
                     teamType:(V2NIMTeamType)teamType
                     muteMode:(V2NIMTeamMessageMuteMode)muteMode
                      success:(nullable V2NIMSuccessCallback)success
                      failure:(nullable V2NIMFailureCallback)failure;

C++virtual void setTeamMessageMuteMode(std::string teamId, V2NIMTeamType teamType, V2NIMTeamMessageMuteMode muteMode, V2NIMSuccessCallback<void> success, V2NIMFailureCallback failure) = 0;

TypeScriptsetTeamMessageMuteMode(teamId: string, teamType: V2NIMTeamType, muteMode: V2NIMTeamMessageMuteMode): Promise<void>

TypeScriptsetTeamMessageMuteMode(teamId: string, teamType: V2NIMTeamType, muteMode: V2NIMTeamMessageMuteMode): Promise<void>

JavaNIMClient.getService(V2NIMSettingService.class).setTeamMessageMuteMode(teamId, teamType, muteMode,
new V2NIMSuccessCallback<Void>() {
    @Override
    public void onSuccess(Void unused) {
    // success
    }
},
new V2NIMFailureCallback() {
    @Override
    public void onFailure(V2NIMError error) {
    // failed, handle error
    }
});

Objective-C[[[NIMSDK sharedSDK] v2SettingService] setTeamMessageMuteMode:@"teamId" teamType:V2NIM_TEAM_TYPE_INVALID muteMode:V2NIM_TEAM_MESSAGE_MUTE_MODE_OFF success:^{
    // 成功回调
} failure:^(V2NIMError * _Nonnull error) {
    // 失败回调
}];

C++settingService.setTeamMessageMuteMode(
    "teamId",
    V2NIM_TEAM_TYPE_NORMAL,
    V2NIM_TEAM_MESSAGE_MUTE_MODE_ON,
    []() {
        // set team mute mode succeeded
    },
    [](V2NIMError error) {
        // set team mute mode failed, handle error
    }
);

TypeScriptnim.V2NIMSettingService.setTeamMessageMuteMode('teamId', 1, 1)

TypeScriptawait nim.settingService.setTeamMessageMuteMode('teamId', V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL, V2NIMTeamMessageMuteMode.V2NIM_TEAM_MESSAGE_MUTE_MODE_ON)

无返回值。

Promise<void>

• 请求成功，返回 V2NIMSuccessCallback 回调。设置成功，返回 onTeamMessageMuteModeChanged 回调。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含免打扰相关错误码。

设置成功，返回 onTeamMessageMuteModeChanged 回调。

JavaV2NIMTeamMessageMuteMode getTeamMessageMuteMode(String teamId, V2NIMTeamType teamType);

Objective-C- (V2NIMTeamMessageMuteMode)getTeamMessageMuteMode:(NSString *)teamId
                                          teamType:(V2NIMTeamType)teamType;

C++virtual V2NIMTeamMessageMuteMode getTeamMessageMuteMode(nstd::string teamId, V2NIMTeamType teamType) = 0;

TypeScriptgetTeamMessageMuteMode(teamId: string, teamType: V2NIMTeamType): V2NIMTeamMessageMuteMode

TypeScriptgetTeamMessageMuteMode(teamId: string, teamType: V2NIMTeamType): Promise<V2NIMTeamMessageMuteMode>

JavaV2NIMTeamMessageMuteMode muteMode = NIMClient.getService(V2NIMSettingService.class).getTeamMessageMuteMode(teamId, teamType);

Objective-C[[[NIMSDK sharedSDK] v2SettingService] getTeamMessageMuteMode:@"teamId" teamType:V2NIM_TEAM_TYPE_NORMAL];

C++auto muteMode = settingService.getTeamMessageMuteMode("teamId", V2NIM_TEAM_TYPE_NORMAL);

TypeScriptconst muteMode = nim.V2NIMSettingService.getTeamMessageMuteMode('teamId', 1)

TypeScriptconst muteMode = await nim.settingService.getTeamMessageMuteMode('teamId', V2NIMTeamType.V2NIM_TEAM_TYPE_NORMAL)

V2NIMTeamMessageMuteMode 群聊消息免打扰模式

Promise<V2NIMTeamMessageMuteMode>

Javaboolean getConversationMuteStatus(String conversationId);

Objective-C- (BOOL)getConversationMuteStatus:(NSString *)conversationId;

C++virtual bool getConversationMuteStatus(nstd::string conversationId) = 0;

TypeScriptgetConversationMuteStatus(conversationId: string): boolean

TypeScriptgetConversationMuteStatus(conversationId: string): Promise<boolean>

Javaboolean isMute = NIMClient.getService(V2NIMSettingService.class).getConversationMuteStatus(conversationId);

Objective-C[[NIMSDK sharedSDK] v2SettingService] getConversationMuteStatus:@"conversationId"];

C++auto mute = settingService.getConversationMuteStatus(conversationId);

TypeScriptnim.V2NIMSettingService.getConversationMuteStatus('sender|1|receiver')

TypeScriptawait nim.settingService.getConversationMuteStatus('sender|1|receiver')

Javavoid setPushMobileOnDesktopOnline(boolean need, V2NIMSuccessCallback<Void> success, V2NIMFailureCallback failure);

Objective-C- (void)setPushMobileOnDesktopOnline:(BOOL)need
                             success:(nullable V2NIMSuccessCallback)success
                             failure:(nullable V2NIMFailureCallback)failure;

C++virtual void setPushMobileOnDesktopOnline(bool need, V2NIMSuccessCallback<void> success, V2NIMFailureCallback failure) = 0;

TypeScriptsetPushMobileOnDesktopOnline(need: boolean): Promise<void>

TypeScriptsetPushMobileOnDesktopOnline(need: boolean): Promise<void>

JavaNIMClient.getService(V2NIMSettingService.class).setPushMobileOnDesktopOnline(needPushMobileOnDesktopOnline,
new V2NIMSuccessCallback<Void>() {
    @Override
    public void onSuccess(Void unused) {

    }
},
new V2NIMFailureCallback() {
    @Override
    public void onFailure(V2NIMError error) {

    }
});

Objective-C[[[NIMSDK sharedSDK] v2SettingService] setPushMobileOnDesktopOnline:YES success:^{
    // 成功回调
} failure:^(V2NIMError * _Nonnull error) {
    // 失败回调
}];

C++settingService.setPushMobileOnDesktopOnline(
    true,
    []() {
        // set push mobile on desktop online succeeded
    },
    [](V2NIMError error) {
        // set push mobile on desktop online failed, handle error
    });

TypeScriptnim.V2NIMSettingService.setPushMobileOnDesktopOnline(true)

TypeScriptawait nim.settingService.setPushMobileOnDesktopOnline(true)

• 请求成功，返回 V2NIMSuccessCallback 回调。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含相关错误码。

无。

Javavoid setDndConfig(V2NIMDndConfig config, V2NIMSuccessCallback<Void> success, V2NIMFailureCallback failure);

Objective-C- (void)setDndConfig:(V2NIMDndConfig *)config;

C++virtual void v2::V2NIMSettingService::setDndConfig    ("   V2NIMDndConfig     config,
                                                        V2NIMSuccessCallback< void >     success,
                                                        V2NIMFailureCallback     failure
)

TypeScriptsetDndConfig(config: V2NIMDndConfig): Promise<void>

JavaV2NIMDndConfig dndConfig = V2NIMDndConfig.V2NIMDndConfigBuilder.builder(fromH, fromM, toH, toM).build();
NIMClient.getService(V2NIMSettingService.class).setDndConfig(dndConfig,
        new V2NIMSuccessCallback<Void>() {
            @Override
            public void onSuccess(Void unused) {

            }
        },
        new V2NIMFailureCallback() {
            @Override
            public void onFailure(V2NIMError error) {

            }
        });

Objective-C[[[NIMSDK sharedSDK] v2SettingService] setDndConfig:config];

C++V2NIMDndConfig config;
settingService.setDndConfig(
    config,
    []() {
        // set dnd config succeeded
    },
    [](V2NIMError error) {
        // set dnd config failed, handle error
    });
);

TypeScriptconst res = await nim.settingService.setDndConfig({
  showDetail: true,
  dndOn: true,
  fromH: 22,
  fromM: 30,
  toH: 6,
  toM: 30
} as V2NIMDndConfig)

• 请求成功，返回 V2NIMSuccessCallback 回调。
• 请求失败，返回 V2NIMFailuerCallback 回调，包含相关错误码。

无。

JavaV2NIMDndConfig getDndConfig();

Objective-C- (nullable V2NIMDndConfig *)getDndConfig;

C++virtual V2NIMDndConfig v2::V2NIMSettingService::getDndConfig()

TypeScriptgetDndConfig(): Promise<V2NIMDndConfig>;

JavaV2NIMDndConfig dndConfig = NIMClient.getService(V2NIMSettingService.class).getDndConfig();

Objective-C[NIMSDK.sharedSDK.v2SettingService getDndConfig];

C++V2NIMDndConfig dndConfig = settingService.getDndConfig();

TypeScriptawait nim.settingService.getDndConfig()