harmony 鸿蒙@ohos.notification (Notification模块)

2022-08-09
浏览 (1055)

@ohos.notification (Notification模块)

本模块提供通知管理的能力，包括发布、取消发布通知，创建、获取、移除通知通道，订阅、取消订阅通知，获取通知的使能状态、角标使能状态，获取通知的相关信息等。

说明：

从API version 9开始，该接口不再维护，推荐使用新接口@ohos.notificationManager。本模块首批接口从API version 7开始支持。后续版本的新增接口，采用上角标单独标记接口的起始版本。

通知订阅和取消订阅仅对系统应用开放。

导入模块

import Notification from '@ohos.notification';

Notification.publish

publish(request: NotificationRequest, callback: AsyncCallback<void>): void

发布通知（callback形式）。

系统能力：SystemCapability.Notification.Notification

参数：

参数名	类型	必填	说明
request	NotificationRequest	是	用于设置要发布通知的内容和相关配置信息。
callback	AsyncCallback<void>	是	发布通知的回调方法。

示例：

import NotificationManager from '@ohos.notificationManager';
import Base from '@ohos.base';

// publish回调
let publishCallback = (err: Base.BusinessError) => {
  if (err) {
    console.error(`publish failed, code is ${err}`);
  } else {
    console.info("publish success");
  }
}
// 通知Request对象
let notificationRequest: NotificationManager.NotificationRequest = {
  id: 1,
  content: {
    contentType: Notification.ContentType.NOTIFICATION_CONTENT_BASIC_TEXT,
    normal: {
      title: "test_title",
      text: "test_text",
      additionalText: "test_additionalText"
    }
  }
};
Notification.publish(notificationRequest, publishCallback);

Notification.publish

publish(request: NotificationRequest): Promise<void>

发布通知（Promise形式）。

系统能力：SystemCapability.Notification.Notification

参数：

参数名	类型	必填	说明
request	NotificationRequest	是	用于设置要发布通知的内容和相关配置信息。

返回值：

类型	说明
Promise<void>	无返回结果的Promise对象。

示例：

import NotificationManager from '@ohos.notificationManager';
import Base from '@ohos.base';

// 通知Request对象
let notificationRequest: NotificationManager.NotificationRequest = {
  id: 1,
  content: {
    contentType: Notification.ContentType.NOTIFICATION_CONTENT_BASIC_TEXT,
    normal: {
      title: "test_title",
      text: "test_text",
      additionalText: "test_additionalText"
    }
  }
};
Notification.publish(notificationRequest).then(() => {
  console.info("publish success");
}).catch((err: Base.BusinessError) => {
  console.error(`publish failed, code is ${err}`);
});

Notification.publish⁸⁺

publish(request: NotificationRequest, userId: number, callback: AsyncCallback<void>): void

发布通知给指定的用户（callback形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

参数：

参数名	类型	必填	说明
request	NotificationRequest	是	用于设置要发布通知的内容和相关配置信息。
userId	number	是	用户ID。
callback	AsyncCallback<void>	是	被指定的回调方法。

示例：

import NotificationManager from '@ohos.notificationManager';
import Base from '@ohos.base';

// publish回调
let publishCallback = (err: Base.BusinessError) => {
  if (err) {
    console.error(`publish failed, code is ${err.code}`);
  } else {
    console.info("publish success");
  }
}
// 用户ID
let userId: number = 1;
// 通知Request对象
let notificationRequest: NotificationManager.NotificationRequest = {
  id: 1,
  content: {
    contentType: Notification.ContentType.NOTIFICATION_CONTENT_BASIC_TEXT,
    normal: {
      title: "test_title",
      text: "test_text",
      additionalText: "test_additionalText"
    }
  }
};
Notification.publish(notificationRequest, userId, publishCallback);

Notification.publish⁸⁺

publish(request: NotificationRequest, userId: number): Promise<void>

发布通知给指定的用户（Promise形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

参数：

参数名	类型	必填	说明
request	NotificationRequest	是	用于设置要发布通知的内容和相关配置信息。
userId	number	是	用户ID。

返回值：

类型	说明
Promise<void>	无返回结果的Promise对象。

示例：

import NotificationManager from '@ohos.notificationManager';
import Base from '@ohos.base';

let notificationRequest: NotificationManager.NotificationRequest = {
  id: 1,
  content: {
    contentType: Notification.ContentType.NOTIFICATION_CONTENT_BASIC_TEXT,
    normal: {
      title: "test_title",
      text: "test_text",
      additionalText: "test_additionalText"
    }
  }
};

let userId: number = 1;

Notification.publish(notificationRequest, userId).then(() => {
  console.info("publish success");
}).catch((err: Base.BusinessError) => {
  console.error(`publish failed, code is ${err}`);
});

Notification.cancel

cancel(id: number, label: string, callback: AsyncCallback<void>): void

通过通知ID和通知标签取消已发布的通知（callback形式）。

系统能力：SystemCapability.Notification.Notification

参数：

参数名	类型	必填	说明
id	number	是	通知ID。
label	string	是	通知标签。
callback	AsyncCallback<void>	是	表示被指定的回调方法。

示例：

import Base from '@ohos.base';

// cancel回调
let cancelCallback = (err: Base.BusinessError) => {
  if (err) {
    console.info("cancel failed " + JSON.stringify(err));
  } else {
    console.info("cancel success");
  }
}
Notification.cancel(0, "label", cancelCallback);

Notification.cancel

cancel(id: number, label?: string): Promise<void>

取消与指定通知ID相匹配的已发布通知，label可以指定也可以不指定（Promise形式）。

系统能力：SystemCapability.Notification.Notification

参数：

参数名	类型	必填	说明
id	number	是	通知ID。
label	string	否	通知标签，默认为空。

返回值：

类型	说明
Promise<void>	无返回结果的Promise对象。

示例：

import Base from '@ohos.base';

Notification.cancel(0).then(() => {
	console.info("cancel success");
}).catch((err: Base.BusinessError) => {
  console.error(`cancel failed, code is ${err}`);
});

Notification.cancel

cancel(id: number, callback: AsyncCallback<void>): void

取消与指定通知ID相匹配的已发布通知（callback形式）。

系统能力：SystemCapability.Notification.Notification

参数：

参数名	类型	必填	说明
id	number	是	通知ID。
callback	AsyncCallback<void>	是	表示被指定的回调方法。

示例：

import Base from '@ohos.base';

// cancel回调
let cancelCallback = (err: Base.BusinessError) => {
  if (err) {
    console.info("cancel failed " + JSON.stringify(err));
  } else {
    console.info("cancel success");
  }
}
Notification.cancel(0, cancelCallback);

Notification.cancelAll

cancelAll(callback: AsyncCallback<void>): void

取消所有已发布的通知（callback形式）。

系统能力：SystemCapability.Notification.Notification

参数：

参数名	类型	必填	说明
callback	AsyncCallback<void>	是	表示被指定的回调方法。

示例：

import Base from '@ohos.base';

// cancel回调
let cancelAllCallback = (err: Base.BusinessError) => {
  if (err) {
    console.info("cancelAll failed " + JSON.stringify(err));
  } else {
    console.info("cancelAll success");
  }
}
Notification.cancelAll(cancelAllCallback);

Notification.cancelAll

cancelAll(): Promise<void>

取消所有已发布的通知（Promise形式）。

系统能力：SystemCapability.Notification.Notification

返回值：

类型	说明
Promise<void>	无返回结果的Promise对象。

示例：

import Base from '@ohos.base';

Notification.cancelAll().then(() => {
	console.info("cancelAll success");
}).catch((err: Base.BusinessError) => {
  console.error(`cancelAll failed, code is ${err}`);
});

Notification.addSlot

addSlot(slot: NotificationSlot, callback: AsyncCallback<void>): void

创建通知通道（callback形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

参数：

参数名	类型	必填	说明
slot	NotificationSlot	是	要创建的通知通道对象。
callback	AsyncCallback<void>	是	表示被指定的回调方法。

示例：

import NotificationManager from '@ohos.notificationManager';
import Base from '@ohos.base';

// addslot回调
let addSlotCallBack = (err: Base.BusinessError) => {
  if (err) {
    console.info("addSlot failed " + JSON.stringify(err));
  } else {
    console.info("addSlot success");
  }
}
// 通知slot对象
let notificationSlot: NotificationManager.NotificationSlot = {
  type: Notification.SlotType.SOCIAL_COMMUNICATION
};
Notification.addSlot(notificationSlot, addSlotCallBack);

Notification.addSlot

addSlot(slot: NotificationSlot): Promise<void>

创建通知通道（Promise形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

参数：

参数名	类型	必填	说明
slot	NotificationSlot	是	要创建的通知通道对象。

返回值：

类型	说明
Promise<void>	无返回结果的Promise对象。

示例：

import NotificationManager from '@ohos.notificationManager';
import Base from '@ohos.base';

// 通知slot对象
let notificationSlot: NotificationManager.NotificationSlot = {
    type: Notification.SlotType.SOCIAL_COMMUNICATION
};
Notification.addSlot(notificationSlot).then(() => {
	console.info("addSlot success");
}).catch((err: Base.BusinessError) => {
  console.error(`addSlot failed, code is ${err}`);
});

Notification.addSlot

addSlot(type: SlotType, callback: AsyncCallback<void>): void

创建指定类型的通知通道（callback形式）。

系统能力：SystemCapability.Notification.Notification

参数：

参数名	类型	必填	说明
type	SlotType	是	要创建的通知通道的类型。
callback	AsyncCallback<void>	是	表示被指定的回调方法。

示例：

import Base from '@ohos.base';

// addslot回调
let addSlotCallBack = (err: Base.BusinessError) => {
  if (err) {
    console.info("addSlot failed " + JSON.stringify(err));
  } else {
    console.info("addSlot success");
  }
}
Notification.addSlot(Notification.SlotType.SOCIAL_COMMUNICATION, addSlotCallBack);

Notification.addSlot

addSlot(type: SlotType): Promise<void>

创建指定类型的通知通道（Promise形式）。

系统能力：SystemCapability.Notification.Notification

参数：

参数名	类型	必填	说明
type	SlotType	是	要创建的通知通道的类型。

返回值：

类型	说明
Promise<void>	无返回结果的Promise对象。

示例：

import Base from '@ohos.base';

Notification.addSlot(Notification.SlotType.SOCIAL_COMMUNICATION).then(() => {
  console.info("addSlot success");
}).catch((err: Base.BusinessError) => {
  console.error(`addSlot failed, code is ${err}`);
});

Notification.addSlots

addSlots(slots: Array<NotificationSlot>, callback: AsyncCallback<void>): void

创建多个通知通道（callback形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

参数：

参数名	类型	必填	说明
slots	Array<NotificationSlot>	是	要创建的通知通道对象数组。
callback	AsyncCallback<void>	是	表示被指定的回调方法。

示例：

import NotificationManager from '@ohos.notificationManager';
import Base from '@ohos.base';

// addSlots回调
let addSlotsCallBack = (err: Base.BusinessError) => {
  if (err) {
    console.info("addSlots failed " + JSON.stringify(err));
  } else {
    console.info("addSlots success");
  }
}
// 通知slot对象
let notificationSlot: NotificationManager.NotificationSlot = {
  type: Notification.SlotType.SOCIAL_COMMUNICATION
};
// 通知slot array 对象
let notificationSlotArray: NotificationManager.NotificationSlot[] = new Array();
notificationSlotArray[0] = notificationSlot;

Notification.addSlots(notificationSlotArray, addSlotsCallBack);

Notification.addSlots

addSlots(slots: Array<NotificationSlot>): Promise<void>

创建多个通知通道（Promise形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

参数：

参数名	类型	必填	说明
slots	Array<NotificationSlot>	是	要创建的通知通道对象数组。

返回值：

类型	说明
Promise<void>	无返回结果的Promise对象。

示例：

import NotificationManager from '@ohos.notificationManager';
import Base from '@ohos.base';

// 通知slot对象
let notificationSlot: NotificationManager.NotificationSlot = {
  type: Notification.SlotType.SOCIAL_COMMUNICATION
};
// 通知slot array 对象
let notificationSlotArray: NotificationManager.NotificationSlot[] = new Array();
notificationSlotArray[0] = notificationSlot;

Notification.addSlots(notificationSlotArray).then(() => {
  console.info("addSlots success");
}).catch((err: Base.BusinessError) => {
  console.error(`addSlot failed, code is ${err}`);
});

Notification.getSlot

getSlot(slotType: SlotType, callback: AsyncCallback<NotificationSlot>): void

获取一个指定类型的通知通道（callback形式）。

系统能力：SystemCapability.Notification.Notification

参数：

参数名	类型	必填	说明
slotType	SlotType	是	通知渠道类型，目前分为社交通信、服务提醒、内容咨询和其他类型。
callback	AsyncCallback<NotificationSlot>	是	表示被指定的回调方法。

示例：

import Base from '@ohos.base';

// getSlot回调
let getSlotCallback = (err: Base.BusinessError) => {
  if (err) {
    console.info("getSlot failed " + JSON.stringify(err));
  } else {
    console.info("getSlot success");
  }
}
let slotType: Notification.SlotType = Notification.SlotType.SOCIAL_COMMUNICATION;
Notification.getSlot(slotType, getSlotCallback);

Notification.getSlot

getSlot(slotType: SlotType): Promise<NotificationSlot>

获取一个指定类型的通知通道（Promise形式）。

系统能力：SystemCapability.Notification.Notification

参数：

参数名	类型	必填	说明
slotType	SlotType	是	通知渠道类型，目前分为社交通信、服务提醒、内容咨询和其他类型。

返回值：

类型	说明
Promise<NotificationSlot>	以Promise形式返回获取一个通知通道。

示例：

import Base from '@ohos.base';

let slotType: Notification.SlotType = Notification.SlotType.SOCIAL_COMMUNICATION;
Notification.getSlot(slotType).then((data) => {
  console.info("getSlot success, data: " + JSON.stringify(data));
}).catch((err: Base.BusinessError) => {
  console.error(`getSlot failed, code is ${err}`);
});

Notification.getSlots

getSlots(callback: AsyncCallback<Array<NotificationSlot>>): void

获取此应用程序的所有通知通道（callback形式）。

系统能力：SystemCapability.Notification.Notification

参数：

参数名	类型	必填	说明
callback	AsyncCallback<Array<NotificationSlot>>	是	以callback形式返回获取此应用程序的所有通知通道的结果。

示例：

import Base from '@ohos.base';

// getSlots回调
function getSlotsCallback(err: Base.BusinessError) {
  if (err) {
    console.info("getSlots failed " + JSON.stringify(err));
  } else {
    console.info("getSlots success");
  }
}
Notification.getSlots(getSlotsCallback);

Notification.getSlots

getSlots(): Promise<Array<NotificationSlot>>

获取此应用程序的所有通知通道（Promise形式）。

系统能力：SystemCapability.Notification.Notification

返回值：

类型	说明
Promise<Array<NotificationSlot>>	以Promise形式返回获取此应用程序的所有通知通道的结果。

示例：

import Base from '@ohos.base';

Notification.getSlots().then((data) => {
  console.info("getSlots success, data: " + JSON.stringify(data));
}).catch((err: Base.BusinessError) => {
  console.error(`getSlots failed, code is ${err}`);
});

Notification.removeSlot

removeSlot(slotType: SlotType, callback: AsyncCallback<void>): void

删除指定类型的通知通道（callback形式）。

系统能力：SystemCapability.Notification.Notification

参数：

参数名	类型	必填	说明
slotType	SlotType	是	通知渠道类型,目前分为社交通信、服务提醒、内容咨询和其他类型。
callback	AsyncCallback<void>	是	表示被指定的回调方法。

示例：

import Base from '@ohos.base';

// removeSlot回调
let removeSlotCallback = (err: Base.BusinessError) => {
  if (err) {
    console.info("removeSlot failed " + JSON.stringify(err));
  } else {
    console.info("removeSlot success");
  }
}
let slotType: Notification.SlotType = Notification.SlotType.SOCIAL_COMMUNICATION;
Notification.removeSlot(slotType, removeSlotCallback);

Notification.removeSlot

removeSlot(slotType: SlotType): Promise<void>

删除指定类型的通知通道（Promise形式）。

系统能力：SystemCapability.Notification.Notification

参数：

参数名	类型	必填	说明
slotType	SlotType	是	通知渠道类型,目前分为社交通信、服务提醒、内容咨询和其他类型。

返回值：

类型	说明
Promise<void>	无返回结果的Promise对象。

示例：

import Base from '@ohos.base';

let slotType: Notification.SlotType = Notification.SlotType.SOCIAL_COMMUNICATION;
Notification.removeSlot(slotType).then(() => {
  console.info("removeSlot success");
}).catch((err: Base.BusinessError) => {
  console.error(`removeSlot failed, code is ${err}`);
});

Notification.removeAllSlots

removeAllSlots(callback: AsyncCallback<void>): void

删除所有通知通道（callback形式）。

系统能力：SystemCapability.Notification.Notification

参数：

参数名	类型	必填	说明
callback	AsyncCallback<void>	是	表示被指定的回调方法。

示例：

import Base from '@ohos.base';

let removeAllCallBack = (err: Base.BusinessError) => {
  if (err) {
    console.info("removeAllSlots failed " + JSON.stringify(err));
  } else {
    console.info("removeAllSlots success");
  }
}
Notification.removeAllSlots(removeAllCallBack);

Notification.removeAllSlots

removeAllSlots(): Promise<void>

删除所有通知通道（Promise形式）。

系统能力：SystemCapability.Notification.Notification

返回值：

类型	说明
Promise<void>	无返回结果的Promise对象。

示例：

import Base from '@ohos.base';

Notification.removeAllSlots().then(() => {
  console.info("removeAllSlots success");
}).catch((err: Base.BusinessError) => {
  console.error(`removeAllSlots failed, code is ${err}`);
});

Notification.subscribe

subscribe(subscriber: NotificationSubscriber, info: NotificationSubscribeInfo, callback: AsyncCallback<void>): void

订阅通知并指定订阅信息（callback形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

参数：

参数名	类型	必填	说明
subscriber	NotificationSubscriber	是	通知订阅对象。
info	NotificationSubscribeInfo	是	通知订阅信息。
callback	AsyncCallback<void>	是	订阅动作回调函数。

示例：

import Base from '@ohos.base';
import NotificationSubscribe from '@ohos.notificationSubscribe';

// subscribe回调
let subscribeCallback = (err: Base.BusinessError) => {
  if (err) {
    console.info("subscribe failed " + JSON.stringify(err));
  } else {
    console.info("subscribe success");
  }
}
let onConsumeCallback = (data: NotificationSubscribe.SubscribeCallbackData) => {
  console.info("Consume callback: " + JSON.stringify(data));
}
let subscriber: NotificationSubscribe.NotificationSubscriber = {
  onConsume: onConsumeCallback
};
let info: NotificationSubscribe.NotificationSubscribeInfo = {
  bundleNames: ["bundleName1", "bundleName2"]
};
Notification.subscribe(subscriber, info, subscribeCallback);

Notification.subscribe

subscribe(subscriber: NotificationSubscriber, callback: AsyncCallback<void>): void

订阅当前用户下所有应用的通知（callback形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

参数：

参数名	类型	必填	说明
subscriber	NotificationSubscriber	是	通知订阅对象。
callback	AsyncCallback<void>	是	订阅动作回调函数。

示例：

import Base from '@ohos.base';
import NotificationSubscribe from '@ohos.notificationSubscribe';

let subscribeCallback = (err: Base.BusinessError) => {
  if (err) {
    console.info("subscribe failed " + JSON.stringify(err));
  } else {
    console.info("subscribe success");
  }
}
function onConsumeCallback(data: NotificationSubscribe.SubscribeCallbackData) {
  console.info("Consume callback: " + JSON.stringify(data));
}
let subscriber: NotificationSubscribe.NotificationSubscriber = {
  onConsume: onConsumeCallback
};
Notification.subscribe(subscriber, subscribeCallback);

Notification.subscribe

subscribe(subscriber: NotificationSubscriber, info?: NotificationSubscribeInfo): Promise<void>

订阅通知并指定订阅信息（Promise形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

参数：

参数名	类型	必填	说明
subscriber	NotificationSubscriber	是	通知订阅对象。
info	NotificationSubscribeInfo	否	通知订阅信息，默认为空。

返回值：

类型	说明
Promise<void>	无返回结果的Promise对象。

示例：

import Base from '@ohos.base';
import NotificationSubscribe from '@ohos.notificationSubscribe';

function onConsumeCallback(data: NotificationSubscribe.SubscribeCallbackData) {
  console.info("Consume callback: " + JSON.stringify(data));
}
let subscriber: NotificationSubscribe.NotificationSubscriber = {
  onConsume: onConsumeCallback
};
Notification.subscribe(subscriber).then(() => {
  console.info("subscribe success");
}).catch((err: Base.BusinessError) => {
  console.error(`subscribe failed, code is ${err}`);
});

Notification.unsubscribe

unsubscribe(subscriber: NotificationSubscriber, callback: AsyncCallback<void>): void

取消订阅（callbcak形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

参数：

参数名	类型	必填	说明
subscriber	NotificationSubscriber	是	通知订阅对象。
callback	AsyncCallback<void>	是	取消订阅动作回调函数。

示例：

import Base from '@ohos.base';
import NotificationSubscribe from '@ohos.notificationSubscribe';

let unsubscribeCallback = (err: Base.BusinessError) => {
  if (err) {
    console.info("unsubscribe failed " + JSON.stringify(err));
  } else {
    console.info("unsubscribe success");
  }
}
let onDisconnectCallback = () => {
  console.info("subscribe disconnect");
}
let subscriber: NotificationSubscribe.NotificationSubscriber = {
  onDisconnect: onDisconnectCallback
};
Notification.unsubscribe(subscriber, unsubscribeCallback);

Notification.unsubscribe

unsubscribe(subscriber: NotificationSubscriber): Promise<void>

取消订阅（Promise形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

参数：

参数名	类型	必填	说明
subscriber	NotificationSubscriber	是	通知订阅对象。

返回值：

类型	说明
Promise<void>	无返回结果的Promise对象。

示例：

import Base from '@ohos.base';
import NotificationSubscribe from '@ohos.notificationSubscribe';

function onDisconnectCallback() {
  console.info("subscribe disconnect");
}
let subscriber: NotificationSubscribe.NotificationSubscriber = {
  onDisconnect: onDisconnectCallback
};
Notification.unsubscribe(subscriber).then(() => {
  console.info("unsubscribe success");
}).catch((err: Base.BusinessError) => {
  console.error(`unsubscribe failed, code is ${err}`);
});

Notification.enableNotification

enableNotification(bundle: BundleOption, enable: boolean, callback: AsyncCallback<void>): void

设定指定应用的通知使能状态（Callback形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

参数：

参数名	类型	必填	说明
bundle	BundleOption	是	指定应用的包信息。
enable	boolean	是	使能状态。
callback	AsyncCallback<void>	是	设定通知使能回调函数。

示例：

import Base from '@ohos.base';

let enableNotificationCallback = (err: Base.BusinessError) => {
  if (err) {
    console.info("enableNotification failed " + JSON.stringify(err));
  } else {
    console.info("enableNotification success");
  }
}
let bundle: Notification.BundleOption = {
  bundle: "bundleName1",
};
Notification.enableNotification(bundle, false, enableNotificationCallback);

Notification.enableNotification

enableNotification(bundle: BundleOption, enable: boolean): Promise<void>

设定指定应用的通知使能状态（Promise形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

参数：

参数名	类型	必填	说明
bundle	BundleOption	是	指定应用的包信息。
enable	boolean	是	使能状态。

返回值：

类型	说明
Promise<void>	无返回结果的Promise对象。

示例：

import Base from '@ohos.base';

let bundle: Notification.BundleOption = {
  bundle: "bundleName1",
};
Notification.enableNotification(bundle, false).then(() => {
  console.info("enableNotification success");
}).catch((err: Base.BusinessError) => {
  console.error(`enableNotification failed, code is ${err}`);
});

Notification.isNotificationEnabled

isNotificationEnabled(bundle: BundleOption, callback: AsyncCallback<boolean>): void

获取指定应用的通知使能状态（Callback形式）。

系统能力：SystemCapability.Notification.Notification

系统API：此接口为系统接口，三方应用不支持调用。

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

参数：

参数名	类型	必填	说明
bundle	BundleOption	是	指定应用的包信息。
callback	AsyncCallback<void>	是	获取通知使能状态回调函数。

示例：

import Base from '@ohos.base';

let isNotificationEnabledCallback = (err: Base.BusinessError, data: boolean) => {
  if (err) {
    console.info("isNotificationEnabled failed " + JSON.stringify(err));
  } else {
    console.info("isNotificationEnabled success");
  }
}
let bundle: Notification.BundleOption = {
  bundle: "bundleName1",
};
Notification.isNotificationEnabled(bundle, isNotificationEnabledCallback);

Notification.isNotificationEnabled

isNotificationEnabled(bundle: BundleOption): Promise<boolean>

获取指定应用的通知使能状态（Promise形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

参数：

参数名	类型	必填	说明
bundle	BundleOption	是	指定应用的包信息。

返回值：

类型	说明
Promise<boolean>	以Promise形式返回获取指定应用的通知使能状态的结果。

示例：

import Base from '@ohos.base';

let bundle: Notification.BundleOption = {
  bundle: "bundleName1",
};
Notification.isNotificationEnabled(bundle).then((data) => {
  console.info("isNotificationEnabled success, data: " + JSON.stringify(data));
}).catch((err: Base.BusinessError) => {
  console.error(`isNotificationEnabled failed, code is ${err}`);
});

Notification.isNotificationEnabled

isNotificationEnabled(callback: AsyncCallback<boolean>): void

获取通知使能状态（Callback形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

参数：

参数名	类型	必填	说明
callback	AsyncCallback<void>	是	获取通知使能状态回调函数。

示例：

import Base from '@ohos.base';

let isNotificationEnabledCallback = (err: Base.BusinessError, data: boolean) => {
  if (err) {
    console.info("isNotificationEnabled failed " + JSON.stringify(err));
  } else {
    console.info("isNotificationEnabled success");
  }
}

Notification.isNotificationEnabled(isNotificationEnabledCallback);

Notification.isNotificationEnabled

isNotificationEnabled(): Promise<boolean>

获取通知使能状态（Promise形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

参数：

参数名	类型	必填	说明
bundle	BundleOption	是	指定应用的包信息。

返回值：

类型	说明
Promise<boolean>	以Promise形式返回获取通知使能状态的结果。

示例：

import Base from '@ohos.base';

Notification.isNotificationEnabled().then((data: boolean) => {
  console.info("isNotificationEnabled success, data: " + JSON.stringify(data));
}).catch((err: Base.BusinessError) => {
  console.error(`isNotificationEnabled failed, code is ${err}`);
});

Notification.displayBadge

displayBadge(bundle: BundleOption, enable: boolean, callback: AsyncCallback<void>): void

设定指定应用的角标使能状态（Callback形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

参数：

参数名	类型	必填	说明
bundle	BundleOption	是	指定应用的包信息。
enable	boolean	是	使能状态。
callback	AsyncCallback<void>	是	设定角标使能回调函数。

示例：

import Base from '@ohos.base';

let displayBadgeCallback = (err: Base.BusinessError) => {
  if (err) {
    console.info("displayBadge failed " + JSON.stringify(err));
  } else {
    console.info("displayBadge success");
  }
}
let bundle: Notification.BundleOption = {
  bundle: "bundleName1",
};
Notification.displayBadge(bundle, false, displayBadgeCallback);

Notification.displayBadge

displayBadge(bundle: BundleOption, enable: boolean): Promise<void>

设定指定应用的角标使能状态（Promise形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

参数：

参数名	类型	必填	说明
bundle	BundleOption	是	指定应用的包信息。
enable	boolean	是	使能状态。

返回值：

类型	说明
Promise<void>	无返回结果的Promise对象。

示例：

import Base from '@ohos.base';

let bundle: Notification.BundleOption = {
  bundle: "bundleName1",
};
Notification.displayBadge(bundle, false).then(() => {
  console.info("displayBadge success");
}).catch((err: Base.BusinessError) => {
  console.error(`displayBadge failed, code is ${err}`);
});

Notification.isBadgeDisplayed

isBadgeDisplayed(bundle: BundleOption, callback: AsyncCallback<boolean>): void

获取指定应用的角标使能状态（Callback形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

参数：

参数名	类型	必填	说明
bundle	BundleOption	是	指定应用的包信息。
callback	AsyncCallback<void>	是	获取角标使能状态回调函数。

示例：

import Base from '@ohos.base';

let isBadgeDisplayedCallback = (err: Base.BusinessError, data: boolean) => {
  if (err) {
    console.info("isBadgeDisplayed failed " + JSON.stringify(err));
  } else {
    console.info("isBadgeDisplayed success");
  }
}
let bundle: Notification.BundleOption = {
  bundle: "bundleName1",
};
Notification.isBadgeDisplayed(bundle, isBadgeDisplayedCallback);

Notification.isBadgeDisplayed

isBadgeDisplayed(bundle: BundleOption): Promise<boolean>

获取指定应用的角标使能状态（Promise形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

参数：

参数名	类型	必填	说明
bundle	BundleOption	是	指定应用的包信息。

返回值：

类型	说明
Promise<boolean>	以Promise形式返回获取指定应用的角标使能状态。

示例：

import Base from '@ohos.base';

let bundle: Notification.BundleOption = {
  bundle: "bundleName1",
};
Notification.isBadgeDisplayed(bundle).then((data) => {
  console.info("isBadgeDisplayed success, data: " + JSON.stringify(data));
}).catch((err: Base.BusinessError) => {
  console.error(`isBadgeDisplayed failed, code is ${err}`);
});

Notification.setSlotByBundle

setSlotByBundle(bundle: BundleOption, slot: NotificationSlot, callback: AsyncCallback<void>): void

设定指定应用的通知通道（Callback形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

参数：

参数名	类型	必填	说明
bundle	BundleOption	是	指定应用的包信息。
slot	NotificationSlot	是	通知通道。
callback	AsyncCallback<void>	是	设定通知通道回调函数。

示例：

import Base from '@ohos.base';
import NotificationManager from '@ohos.notificationManager';

let setSlotByBundleCallback = (err: Base.BusinessError) => {
  if (err) {
    console.info("setSlotByBundle failed " + JSON.stringify(err));
  } else {
    console.info("setSlotByBundle success");
  }
}
let bundle: Notification.BundleOption = {
  bundle: "bundleName1",
};
let notificationSlot: NotificationManager.NotificationSlot = {
  type: Notification.SlotType.SOCIAL_COMMUNICATION
};
Notification.setSlotByBundle(bundle, notificationSlot, setSlotByBundleCallback);

Notification.setSlotByBundle

setSlotByBundle(bundle: BundleOption, slot: NotificationSlot): Promise<void>

设定指定应用的通知通道（Promise形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

参数：

参数名	类型	必填	说明
bundle	BundleOption	是	指定应用的包信息。
slot	NotificationSlot	是	通知通道。

返回值：

类型	说明
Promise<void>	无返回结果的Promise对象。

示例：

import Base from '@ohos.base';
import NotificationManager from '@ohos.notificationManager';

let bundle: Notification.BundleOption = {
  bundle: "bundleName1",
};
let notificationSlot: NotificationManager.NotificationSlot = {
  type: Notification.SlotType.SOCIAL_COMMUNICATION
};
Notification.setSlotByBundle(bundle, notificationSlot).then(() => {
  console.info("setSlotByBundle success");
}).catch((err: Base.BusinessError) => {
  console.error(`setSlotByBundle failed, code is ${err}`);
});

Notification.getSlotsByBundle

getSlotsByBundle(bundle: BundleOption, callback: AsyncCallback<Array<NotificationSlot>>): void

获取指定应用的所有通知通道（Callback形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

参数：

参数名	类型	必填	说明
bundle	BundleOption	是	指定应用的包信息。
callback	AsyncCallback<Array<NotificationSlot>>	是	获取通知通道回调函数。

示例：

import Base from '@ohos.base';
import NotificationManager from '@ohos.notificationManager';

let getSlotsByBundleCallback = (err: Base.BusinessError, data: NotificationManager.NotificationSlot[]) => {
  if (err) {
    console.info("getSlotsByBundle failed " + JSON.stringify(err));
  } else {
    console.info("getSlotsByBundle success");
  }
}
let bundle: Notification.BundleOption = {
  bundle: "bundleName1",
};
Notification.getSlotsByBundle(bundle, getSlotsByBundleCallback);

Notification.getSlotsByBundle

getSlotsByBundle(bundle: BundleOption): Promise<Array<NotificationSlot>>

获取指定应用的所有通知通道（Promise形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

参数：

参数名	类型	必填	说明
bundle	BundleOption	是	指定应用的包信息。

返回值：

类型	说明
Promise<Array<NotificationSlot>>	以Promise形式返回获取指定应用的通知通道。

示例：

import Base from '@ohos.base';
import NotificationManager from '@ohos.notificationManager';

let bundle: Notification.BundleOption = {
  bundle: "bundleName1",
};
Notification.getSlotsByBundle(bundle).then((data: NotificationManager.NotificationSlot[]) => {
  console.info("getSlotsByBundle success, data: " + JSON.stringify(data));
}).catch((err: Base.BusinessError) => {
  console.error(`getSlotsByBundle failed, code is ${err}`);
});

Notification.getSlotNumByBundle

getSlotNumByBundle(bundle: BundleOption, callback: AsyncCallback<number>): void

获取指定应用的通知通道数量（Callback形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

参数：

参数名	类型	必填	说明
bundle	BundleOption	是	指定应用的包信息。
callback	AsyncCallback<number>	是	获取通知通道数量回调函数。

示例：

import Base from '@ohos.base';
import NotificationManager from '@ohos.notificationManager';

let getSlotNumByBundleCallback = (err: Base.BusinessError, data: number) => {
  if (err) {
    console.info("getSlotNumByBundle failed " + JSON.stringify(err));
  } else {
    console.info("getSlotNumByBundle success");
  }
}
let bundle: Notification.BundleOption = {
  bundle: "bundleName1",
};
Notification.getSlotNumByBundle(bundle, getSlotNumByBundleCallback);

Notification.getSlotNumByBundle

getSlotNumByBundle(bundle: BundleOption): Promise<number>

获取指定应用的通知通道数量（Promise形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

参数：

参数名	类型	必填	说明
bundle	BundleOption	是	指定应用的包信息。

返回值：

类型	说明
Promise<number>	以Promise形式返回获取指定应用的通知通道数量。

示例：

import Base from '@ohos.base';
import NotificationManager from '@ohos.notificationManager';

let bundle: Notification.BundleOption = {
  bundle: "bundleName1",
};
Notification.getSlotNumByBundle(bundle).then((data: number) => {
  console.info("getSlotNumByBundle success, data: " + JSON.stringify(data));
}).catch((err: Base.BusinessError) => {
  console.error(`getSlotNumByBundle failed, code is ${err}`);
});

Notification.remove

remove(bundle: BundleOption, notificationKey: NotificationKey, reason: RemoveReason, callback: AsyncCallback<void>): void

删除指定通知（Callback形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

参数：

参数名	类型	必填	说明
bundle	BundleOption	是	指定应用的包信息。
notificationKey	NotificationKey	是	通知键值。
reason	RemoveReason	是	通知删除原因。
callback	AsyncCallback<void>	是	删除指定通知回调函数。

示例：

import Base from '@ohos.base';

let removeCallback = (err: Base.BusinessError) => {
  if (err) {
    console.info("remove failed " + JSON.stringify(err));
  } else {
    console.info("remove success");
  }
}
let bundle: Notification.BundleOption = {
  bundle: "bundleName1",
};
let notificationKey: Notification.NotificationKey = {
  id: 0,
  label: "label",
};
let reason: Notification.RemoveReason = Notification.RemoveReason.CLICK_REASON_REMOVE;
Notification.remove(bundle, notificationKey, reason, removeCallback);

Notification.remove

remove(bundle: BundleOption, notificationKey: NotificationKey, reason: RemoveReason): Promise<void>

删除指定通知（Promise形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

参数：

参数名	类型	必填	说明
bundle	BundleOption	是	指定应用的包信息。
notificationKey	NotificationKey	是	通知键值。
reason	RemoveReason	是	通知删除原因。

返回值：

类型	说明
Promise<void>	无返回结果的Promise对象。

示例：

import Base from '@ohos.base';

let bundle: Notification.BundleOption = {
  bundle: "bundleName1",
};
let notificationKey: Notification.NotificationKey = {
  id: 0,
  label: "label",
};
let reason: Notification.RemoveReason = Notification.RemoveReason.CLICK_REASON_REMOVE;
Notification.remove(bundle, notificationKey, reason).then(() => {
  console.info("remove success");
}).catch((err: Base.BusinessError) => {
  console.error(`remove failed, code is ${err}`);
});

Notification.remove

remove(hashCode: string, reason: RemoveReason, callback: AsyncCallback<void>): void

删除指定通知（Callback形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

参数：

参数名	类型	必填	说明
hashCode	string	是	通知唯一ID。可以通过onConsume回调的入参SubscribeCallbackData获取其内部NotificationRequest对象中的hashCode。
reason	RemoveReason	是	通知删除原因。
callback	AsyncCallback<void>	是	删除指定通知回调函数。

示例：

import Base from '@ohos.base';

let hashCode: string = 'hashCode';

let removeCallback = (err: Base.BusinessError) => {
  if (err) {
    console.info("remove failed " + JSON.stringify(err));
  } else {
    console.info("remove success");
  }
}
let reason: Notification.RemoveReason = Notification.RemoveReason.CANCEL_REASON_REMOVE;
Notification.remove(hashCode, reason, removeCallback);

Notification.remove

remove(hashCode: string, reason: RemoveReason): Promise<void>

删除指定通知（Promise形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

参数：

参数名	类型	必填	说明
hashCode	string	是	通知唯一ID。
reason	RemoveReason	是	通知删除原因。

返回值：

类型	说明
Promise<void>	无返回结果的Promise对象。

示例：

import Base from '@ohos.base';

let hashCode: string = 'hashCode';
let reason: Notification.RemoveReason = Notification.RemoveReason.CLICK_REASON_REMOVE;
Notification.remove(hashCode, reason).then(() => {
  console.info("remove success");
}).catch((err: Base.BusinessError) => {
  console.error(`remove failed, code is ${err}`);
});

Notification.removeAll

removeAll(bundle: BundleOption, callback: AsyncCallback<void>): void

删除指定应用的所有通知（Callback形式）。

系统能力：SystemCapability.Notification.Notification

系统API：此接口为系统接口，三方应用不支持调用。

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

参数：

参数名	类型	必填	说明
bundle	BundleOption	是	指定应用的包信息。
callback	AsyncCallback<void>	是	删除指定应用的所有通知回调函数。

示例：

import Base from '@ohos.base';

let removeAllCallback = (err: Base.BusinessError) => {
  if (err) {
    console.info("removeAll failed " + JSON.stringify(err));
  } else {
    console.info("removeAll success");
  }
}
let bundle: Notification.BundleOption = {
  bundle: "bundleName1",
};
Notification.removeAll(bundle, removeAllCallback);

Notification.removeAll

removeAll(callback: AsyncCallback<void>): void

删除所有通知（Callback形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

参数：

参数名	类型	必填	说明
callback	AsyncCallback<void>	是	删除所有通知回调函数。

示例：

import Base from '@ohos.base';

let removeAllCallback = (err: Base.BusinessError) => {
  if (err) {
    console.info("removeAll failed " + JSON.stringify(err));
  } else {
    console.info("removeAll success");
  }
}

Notification.removeAll(removeAllCallback);

Notification.removeAll

removeAll(bundle?: BundleOption): Promise<void>

删除指定应用的所有通知（Promise形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

参数：

参数名	类型	必填	说明
bundle	BundleOption	否	指定应用的包信息。默认为空，表示删除所有通知。

返回值：

类型	说明
Promise<void>	无返回结果的Promise对象。

示例：

import Base from '@ohos.base';

// 不指定应用时，删除所有通知
Notification.removeAll().then(() => {
  console.info("removeAll success");
}).catch((err: Base.BusinessError) => {
  console.error(`removeAll failed, code is ${err}`);
});

Notification.removeAll⁸⁺

removeAll(userId: number, callback: AsyncCallback<void>): void

删除指定用户下的所有通知（callback形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

参数：

参数名	类型	必填	说明
userId	number	是	用户ID。
callback	AsyncCallback<void>	是	删除指定用户所有通知回调函数。

示例：

import Base from '@ohos.base';

function removeAllCallback(err: Base.BusinessError) {
  if (err) {
    console.info("removeAll failed " + JSON.stringify(err));
  } else {
    console.info("removeAll success");
  }
}

let userId: number = 1;
Notification.removeAll(userId, removeAllCallback);

Notification.removeAll⁸⁺

removeAll(userId: number): Promise<void>

删除指定用户下的所有通知（Promise形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

参数：

参数名	类型	必填	说明
userId	number	是	用户ID。

示例：

import Base from '@ohos.base';

let userId: number = 1;
Notification.removeAll(userId).then(() => {
  console.info("removeAll success");
}).catch((err: Base.BusinessError) => {
  console.error(`removeAll failed, code is ${err}`);
});

Notification.getAllActiveNotifications

getAllActiveNotifications(callback: AsyncCallback<Array<NotificationRequest>>): void

获取当前未删除的所有通知（Callback形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

参数：

参数名	类型	必填	说明
callback	AsyncCallback<Array<NotificationRequest>>	是	获取活动通知回调函数。

示例：

import Base from '@ohos.base';
import NotificationManager from '@ohos.notificationManager';

function getAllActiveNotificationsCallback(err: Base.BusinessError, data: NotificationManager.NotificationRequest[]) {
  if (err) {
    console.info("getAllActiveNotifications failed " + JSON.stringify(err));
  } else {
    console.info("getAllActiveNotifications success");
  }
}

Notification.getAllActiveNotifications(getAllActiveNotificationsCallback);

Notification.getAllActiveNotifications

getAllActiveNotifications(): Promise<Array<NotificationRequest>>

获取当前未删除的所有通知（Promise形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

返回值：

类型	说明
Promise<Array<NotificationRequest>>	以Promise形式返回获取活动通知。

示例：

import Base from '@ohos.base';
import NotificationManager from '@ohos.notificationManager';

Notification.getAllActiveNotifications().then((data: NotificationManager.NotificationRequest[]) => {
  console.info("getAllActiveNotifications success, data: " + JSON.stringify(data));
}).catch((err: Base.BusinessError) => {
  console.error(`getAllActiveNotifications failed, code is ${err}`);
});

Notification.getActiveNotificationCount

getActiveNotificationCount(callback: AsyncCallback<number>): void

获取当前应用未删除的通知数（Callback形式）。

系统能力：SystemCapability.Notification.Notification

参数：

参数名	类型	必填	说明
callback	AsyncCallback<number>	是	获取未删除通知数回调函数。

示例：

import Base from '@ohos.base';

let getActiveNotificationCountCallback = (err: Base.BusinessError, data: number) => {
  if (err) {
    console.info("getActiveNotificationCount failed " + JSON.stringify(err));
  } else {
    console.info("getActiveNotificationCount success");
  }
}

Notification.getActiveNotificationCount(getActiveNotificationCountCallback);

Notification.getActiveNotificationCount

getActiveNotificationCount(): Promise<number>

获取当前应用未删除的通知数（Promise形式）。

系统能力：SystemCapability.Notification.Notification

返回值：

类型	说明
Promise<number>	以Promise形式返回获取当前应用未删除通知数。

示例：

import Base from '@ohos.base';

Notification.getActiveNotificationCount().then((data: number) => {
  console.info("getActiveNotificationCount success, data: " + JSON.stringify(data));
}).catch((err: Base.BusinessError) => {
  console.error(`getAllActiveNotifications failed, code is ${err}`);
});

Notification.getActiveNotifications

getActiveNotifications(callback: AsyncCallback>): void

获取当前应用未删除的通知列表（Callback形式）。

系统能力：SystemCapability.Notification.Notification

参数：

参数名	类型	必填	说明
callback	AsyncCallback>	是	获取当前应用通知列表回调函数。

示例：

import Base from '@ohos.base';
import NotificationManager from '@ohos.notificationManager';

let getActiveNotificationsCallback = (err: Base.BusinessError, data: NotificationManager.NotificationRequest[]) => {
  if (err) {
    console.info("getActiveNotifications failed " + JSON.stringify(err));
  } else {
    console.info("getActiveNotifications success");
  }
}

Notification.getActiveNotifications(getActiveNotificationsCallback);

Notification.getActiveNotifications

getActiveNotifications(): Promise<Array<NotificationRequest>>

获取当前应用未删除的通知列表（Promise形式）。

系统能力：SystemCapability.Notification.Notification

返回值：

类型	说明
Promise<Array<NotificationRequest>>	以Promise形式返回获取当前应用通知列表。

示例：

import Base from '@ohos.base';
import NotificationManager from '@ohos.notificationManager';

Notification.getActiveNotifications().then((data: NotificationManager.NotificationRequest[]) => {
  console.info("removeGroupByBundle success, data: " + JSON.stringify(data));
}).catch((err: Base.BusinessError) => {
  console.error(`removeGroupByBundle failed, code is ${err}`);
});

Notification.cancelGroup⁸⁺

cancelGroup(groupName: string, callback: AsyncCallback<void>): void

取消本应用指定组下的通知（Callback形式）。

系统能力：SystemCapability.Notification.Notification

参数：

参数名	类型	必填	说明
groupName	string	是	通知组名称，此名称需要在发布通知时通过NotificationRequest对象指定。
callback	AsyncCallback<void>	是	取消本应用指定组下通知的回调函数。

示例：

import Base from '@ohos.base';

let cancelGroupCallback = (err: Base.BusinessError) => {
  if (err) {
    console.info("cancelGroup failed " + JSON.stringify(err));
  } else {
    console.info("cancelGroup success");
  }
}

let groupName: string = "GroupName";

Notification.cancelGroup(groupName, cancelGroupCallback);

Notification.cancelGroup⁸⁺

cancelGroup(groupName: string): Promise<void>

取消本应用指定组下的通知（Promise形式）。

系统能力：SystemCapability.Notification.Notification

参数：

参数名	类型	必填	说明
groupName	string	是	通知组名称。

返回值：

类型	说明
Promise<void>	无返回结果的Promise对象。

示例：

import Base from '@ohos.base';

let groupName: string = "GroupName";
Notification.cancelGroup(groupName).then(() => {
	console.info("cancelGroup success");
}).catch((err: Base.BusinessError) => {
  console.error(`cancelGroup failed, code is ${err}`);
});

Notification.removeGroupByBundle⁸⁺

removeGroupByBundle(bundle: BundleOption, groupName: string, callback: AsyncCallback<void>): void

删除指定应用的指定组下的通知（Callback形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

参数：

参数名	类型	必填	说明
bundle	BundleOption	是	应用的包信息。
groupName	string	是	通知组名称。
callback	AsyncCallback<void>	是	删除指定应用指定组下通知的回调函数。

示例：

import Base from '@ohos.base';

let removeGroupByBundleCallback = (err: Base.BusinessError) => {
  if (err) {
    console.info("removeGroupByBundle failed " + JSON.stringify(err));
  } else {
    console.info("removeGroupByBundle success");
  }
}

let bundleOption: Notification.BundleOption = {bundle: "Bundle"};
let groupName: string = "GroupName";

Notification.removeGroupByBundle(bundleOption, groupName, removeGroupByBundleCallback);

Notification.removeGroupByBundle⁸⁺

removeGroupByBundle(bundle: BundleOption, groupName: string): Promise<void>

删除指定应用的指定组下的通知（Promise形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

参数：

参数名	类型	必填	说明
bundle	BundleOption	是	应用的包信息。
groupName	string	是	通知组名称。

返回值：

类型	说明
Promise<void>	无返回结果的Promise对象。

示例：

import Base from '@ohos.base';

let bundleOption: Notification.BundleOption = {bundle: "Bundle"};
let groupName: string = "GroupName";
Notification.removeGroupByBundle(bundleOption, groupName).then(() => {
  console.info("removeGroupByBundle success");
}).catch((err: Base.BusinessError) => {
  console.error(`removeGroupByBundle failed, code is ${err}`);
});

Notification.setDoNotDisturbDate⁸⁺

setDoNotDisturbDate(date: DoNotDisturbDate, callback: AsyncCallback<void>): void

设置免打扰时间（Callback形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

参数：

参数名	类型	必填	说明
date	DoNotDisturbDate	是	免打扰时间选项。
callback	AsyncCallback<void>	是	设置免打扰时间回调函数。

示例：

import Base from '@ohos.base';

let setDoNotDisturbDateCallback = (err: Base.BusinessError) => {
  if (err) {
    console.info("setDoNotDisturbDate failed " + JSON.stringify(err));
  } else {
    console.info("setDoNotDisturbDate success");
  }
}

let doNotDisturbDate: Notification.DoNotDisturbDate = {
  type: Notification.DoNotDisturbType.TYPE_ONCE,
  begin: new Date(),
  end: new Date(2021, 11, 15, 18, 0)
};

Notification.setDoNotDisturbDate(doNotDisturbDate, setDoNotDisturbDateCallback);

Notification.setDoNotDisturbDate⁸⁺

setDoNotDisturbDate(date: DoNotDisturbDate): Promise<void>

设置免打扰时间（Promise形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

参数：

参数名	类型	必填	说明
date	DoNotDisturbDate	是	免打扰时间选项。

返回值：

类型	说明
Promise<void>	无返回结果的Promise对象。

示例：

import Base from '@ohos.base';

let doNotDisturbDate: Notification.DoNotDisturbDate = {
    type: Notification.DoNotDisturbType.TYPE_ONCE,
    begin: new Date(),
    end: new Date(2021, 11, 15, 18, 0)
};
Notification.setDoNotDisturbDate(doNotDisturbDate).then(() => {
	console.info("setDoNotDisturbDate success");
}).catch((err: Base.BusinessError) => {
  console.error(`setDoNotDisturbDate failed, code is ${err}`);
});

Notification.setDoNotDisturbDate⁸⁺

setDoNotDisturbDate(date: DoNotDisturbDate, userId: number, callback: AsyncCallback<void>): void

指定用户设置免打扰时间（Callback形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

参数：

参数名	类型	必填	说明
date	DoNotDisturbDate	是	免打扰时间选项。
userId	number	是	设置免打扰时间的用户ID。
callback	AsyncCallback<void>	是	设置免打扰时间回调函数。

示例：

import Base from '@ohos.base';

let setDoNotDisturbDateCallback = (err: Base.BusinessError) => {
  if (err) {
    console.info("setDoNotDisturbDate failed " + JSON.stringify(err));
  } else {
    console.info("setDoNotDisturbDate success");
  }
}

let doNotDisturbDate: Notification.DoNotDisturbDate = {
  type: Notification.DoNotDisturbType.TYPE_ONCE,
  begin: new Date(),
  end: new Date(2021, 11, 15, 18, 0)
};

let userId: number = 1;
Notification.setDoNotDisturbDate(doNotDisturbDate, userId, setDoNotDisturbDateCallback);

Notification.setDoNotDisturbDate⁸⁺

setDoNotDisturbDate(date: DoNotDisturbDate, userId: number): Promise<void>

指定用户设置免打扰时间（Promise形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

参数：

参数名	类型	必填	说明
date	DoNotDisturbDate	是	免打扰时间选项。
userId	number	是	设置免打扰时间的用户ID。

返回值：

类型	说明
Promise<void>	无返回结果的Promise对象。

示例：

import Base from '@ohos.base';

let doNotDisturbDate: Notification.DoNotDisturbDate = {
  type: Notification.DoNotDisturbType.TYPE_ONCE,
  begin: new Date(),
  end: new Date(2021, 11, 15, 18, 0)
};

let userId: number = 1;

Notification.setDoNotDisturbDate(doNotDisturbDate, userId).then(() => {
  console.info("setDoNotDisturbDate success");
}).catch((err: Base.BusinessError) => {
  console.error(`setDoNotDisturbDate failed, code is ${err}`);
});

Notification.getDoNotDisturbDate⁸⁺

getDoNotDisturbDate(callback: AsyncCallback<DoNotDisturbDate>): void

查询免打扰时间（Callback形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

参数：

参数名	类型	必填	说明
callback	AsyncCallback<DoNotDisturbDate>	是	查询免打扰时间回调函数。

示例：

import Base from '@ohos.base';

let getDoNotDisturbDateCallback = (err: Base.BusinessError, data: Notification.DoNotDisturbDate) => {
  if (err) {
    console.info("getDoNotDisturbDate failed " + JSON.stringify(err));
  } else {
    console.info("getDoNotDisturbDate success");
  }
}

Notification.getDoNotDisturbDate(getDoNotDisturbDateCallback);

Notification.getDoNotDisturbDate⁸⁺

getDoNotDisturbDate(): Promise<DoNotDisturbDate>

查询免打扰时间（Promise形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

返回值：

类型	说明
Promise<DoNotDisturbDate>	以Promise形式返回获取查询到的免打扰时间。

示例：

import Base from '@ohos.base';

Notification.getDoNotDisturbDate().then((data: Notification.DoNotDisturbDate) => {
  console.info("getDoNotDisturbDate success, data: " + JSON.stringify(data));
}).catch((err: Base.BusinessError) => {
  console.error(`getDoNotDisturbDate failed, code is ${err}`);
});

Notification.getDoNotDisturbDate⁸⁺

getDoNotDisturbDate(userId: number, callback: AsyncCallback<DoNotDisturbDate>): void

查询指定用户的免打扰时间（Callback形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

参数：

参数名	类型	必填	说明
callback	AsyncCallback<DoNotDisturbDate>	是	查询免打扰时间回调函数。
userId	number	是	用户ID。

示例：

import Base from '@ohos.base';

let getDoNotDisturbDateCallback = (err: Base.BusinessError, data: Notification.DoNotDisturbDate) => {
  if (err) {
    console.info("getDoNotDisturbDate failed " + JSON.stringify(err));
  } else {
    console.info("getDoNotDisturbDate success");
  }
}

let userId: number = 1;

Notification.getDoNotDisturbDate(userId, getDoNotDisturbDateCallback);

Notification.getDoNotDisturbDate⁸⁺

getDoNotDisturbDate(userId: number): Promise<DoNotDisturbDate>

查询指定用户的免打扰时间（Promise形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

参数：

参数名	类型	必填	说明
userId	number	是	用户ID。

返回值：

类型	说明
Promise<DoNotDisturbDate>	以Promise形式返回获取查询到的免打扰时间。

示例：

import Base from '@ohos.base';

let userId: number = 1;

Notification.getDoNotDisturbDate(userId).then((data: Notification.DoNotDisturbDate) => {
  console.info("getDoNotDisturbDate success, data: " + JSON.stringify(data));
}).catch((err: Base.BusinessError) => {
  console.error(`getDoNotDisturbDate failed, code is ${err}`);
});

Notification.supportDoNotDisturbMode⁸⁺

supportDoNotDisturbMode(callback: AsyncCallback<boolean>): void

查询是否支持免打扰功能（Callback形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

参数：

参数名	类型	必填	说明
callback	AsyncCallback<boolean>	是	查询是否支持免打扰功能回调函数。

示例：

import Base from '@ohos.base';

let supportDoNotDisturbModeCallback = (err: Base.BusinessError, data: boolean) => {
  if (err) {
    console.info("supportDoNotDisturbMode failed " + JSON.stringify(err));
  } else {
    console.info("supportDoNotDisturbMode success");
  }
}

Notification.supportDoNotDisturbMode(supportDoNotDisturbModeCallback);

Notification.supportDoNotDisturbMode⁸⁺

supportDoNotDisturbMode(): Promise<boolean>

查询是否支持免打扰功能（Promise形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

返回值：

类型	说明
Promise<boolean>	以Promise形式返回获取是否支持免打扰功能的结果。

示例：

import Base from '@ohos.base';

Notification.supportDoNotDisturbMode().then((data: boolean) => {
  console.info("supportDoNotDisturbMode success, data: " + JSON.stringify(data));
}).catch((err: Base.BusinessError) => {
  console.error(`supportDoNotDisturbMode failed, code is ${err}`);
});

Notification.isSupportTemplate⁸⁺

isSupportTemplate(templateName: string, callback: AsyncCallback<boolean>): void

查询模板是否存在（Callback形式）。

系统能力：SystemCapability.Notification.Notification

参数：

参数名	类型	必填	说明
templateName	string	是	模板名称。
callback	AsyncCallback<boolean>	是	查询模板是否存在的回调函数。

示例：

import Base from '@ohos.base';

let templateName: string = 'process';
function isSupportTemplateCallback(err: Base.BusinessError, data: boolean) {
  if (err) {
    console.info("isSupportTemplate failed " + JSON.stringify(err));
  } else {
    console.info("isSupportTemplate success");
  }
}

Notification.isSupportTemplate(templateName, isSupportTemplateCallback);

Notification.isSupportTemplate⁸⁺

isSupportTemplate(templateName: string): Promise<boolean>

查询模板是否存在（Promise形式）。

系统能力：SystemCapability.Notification.Notification

参数：

参数名	类型	必填	说明
templateName	string	是	模板名称。

返回值：

类型	说明
Promise<boolean>	Promise方式返回模板是否存在的结果。

示例：

import Base from '@ohos.base';

let templateName: string = 'process';
Notification.isSupportTemplate(templateName).then((data: boolean) => {
  console.info("isSupportTemplate success, data: " + JSON.stringify(data));
}).catch((err: Base.BusinessError) => {
  console.error(`isSupportTemplate failed, code is ${err}`);
});

Notification.requestEnableNotification⁸⁺

requestEnableNotification(callback: AsyncCallback<void>): void

应用请求通知使能（Callback形式）。

系统能力：SystemCapability.Notification.Notification

参数：

参数名	类型	必填	说明
callback	AsyncCallback<void>	是	应用请求通知使能的回调函数。

示例：

import Base from '@ohos.base';

let requestEnableNotificationCallback = (err: Base.BusinessError) => {
  if (err) {
    console.info("requestEnableNotification failed " + JSON.stringify(err));
  } else {
    console.info("requestEnableNotification success");
  }
};

Notification.requestEnableNotification(requestEnableNotificationCallback);

Notification.requestEnableNotification⁸⁺

requestEnableNotification(): Promise<void>

应用请求通知使能（Promise形式）。

系统能力：SystemCapability.Notification.Notification

返回值：

类型	说明
Promise<void>	无返回结果的Promise对象。

示例：

import Base from '@ohos.base';

Notification.requestEnableNotification().then(() => {
  console.info("requestEnableNotification success");
}).catch((err: Base.BusinessError) => {
  console.error(`requestEnableNotification failed, code is ${err}`);
});

Notification.enableDistributed⁸⁺

enableDistributed(enable: boolean, callback: AsyncCallback<void>): void

设置设备是否支持分布式通知（Callback形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

参数：

参数名	类型	必填	说明
enable	boolean	是	是否支持。
callback	AsyncCallback<void>	是	设置设备是否支持分布式通知的回调函数。

示例：

import Base from '@ohos.base';

let enabledNotificationCallback = (err: Base.BusinessError) => {
  if (err) {
    console.info("enableDistributed failed " + JSON.stringify(err));
  } else {
    console.info("enableDistributed success");
  }
};

let enable: boolean = true;

Notification.enableDistributed(enable, enabledNotificationCallback);

Notification.enableDistributed⁸⁺

enableDistributed(enable: boolean): Promise<void>

设置设备是否支持分布式通知（Promise形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

参数：

参数名	类型	必填	说明
enable	boolean	是	是否支持。

示例：

import Base from '@ohos.base';

let enable: boolean = true;
Notification.enableDistributed(enable).then(() => {
  console.info("enableDistributed success");
}).catch((err: Base.BusinessError) => {
  console.error(`enableDistributed failed, code is ${err}`);
});

Notification.isDistributedEnabled⁸⁺

isDistributedEnabled(callback: AsyncCallback<boolean>): void

查询设备是否支持分布式通知（Callback形式）。

系统能力：SystemCapability.Notification.Notification

参数：

参数名	类型	必填	说明
callback	AsyncCallback<boolean>	是	设备是否支持分布式通知的回调函数。

示例：

import Base from '@ohos.base';

let isDistributedEnabledCallback = (err: Base.BusinessError, data: boolean) => {
  if (err) {
    console.info("isDistributedEnabled failed " + JSON.stringify(err));
  } else {
    console.info("isDistributedEnabled success " + JSON.stringify(data));
  }
};

Notification.isDistributedEnabled(isDistributedEnabledCallback);

Notification.isDistributedEnabled⁸⁺

isDistributedEnabled(): Promise<boolean>

查询设备是否支持分布式通知（Promise形式）。

系统能力：SystemCapability.Notification.Notification

返回值：

类型	说明
Promise<boolean>	Promise方式返回设备是否支持分布式通知的结果。

示例：

import Base from '@ohos.base';

Notification.isDistributedEnabled().then((data: boolean) => {
    console.info("isDistributedEnabled success, data: " + JSON.stringify(data));
}).catch((err: Base.BusinessError) => {
  console.error(`isDistributedEnabled failed, code is ${err}`);
});

Notification.enableDistributedByBundle⁸⁺

enableDistributedByBundle(bundle: BundleOption, enable: boolean, callback: AsyncCallback<void>): void

设置指定应用是否支持分布式通知（Callback形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

参数：

参数名	类型	必填	说明
bundle	BundleOption	是	应用的包信息。
enable	boolean	是	是否支持。
callback	AsyncCallback<void>	是	应用程序是否支持分布式通知的回调函数。

示例：

import Base from '@ohos.base';

let enableDistributedByBundleCallback = (err: Base.BusinessError) => {
  if (err) {
    console.info("enableDistributedByBundle failed " + JSON.stringify(err));
  } else {
    console.info("enableDistributedByBundle success");
  }
};

let bundle: Notification.BundleOption = {
  bundle: "bundleName1",
};

let enable: boolean = true;

Notification.enableDistributedByBundle(bundle, enable, enableDistributedByBundleCallback);

Notification.enableDistributedByBundle⁸⁺

enableDistributedByBundle(bundle: BundleOption, enable: boolean): Promise<void>

设置指定应用是否支持分布式通知（Promise形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

参数：

参数名	类型	必填	说明
bundle	BundleOption	是	应用的包。
enable	boolean	是	是否支持。

示例：

import Base from '@ohos.base';

let enable: boolean = true;

let bundle: Notification.BundleOption = {
  bundle: "bundleName1",
};

Notification.enableDistributedByBundle(bundle, enable).then(() => {
  console.info("enableDistributedByBundle success");
}).catch((err: Base.BusinessError) => {
  console.error(`enableDistributedByBundle failed, code is ${err}`);
});

Notification.isDistributedEnabledByBundle⁸⁺

isDistributedEnabledByBundle(bundle: BundleOption, callback: AsyncCallback<boolean>): void

根据应用的包获取应用程序是否支持分布式通知（Callback形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

参数：

参数名	类型	必填	说明
bundle	BundleOption	是	应用的包。
callback	AsyncCallback<boolean>	是	查询指定应用是否支持分布式通知的回调函数。

示例：

import Base from '@ohos.base';

let isDistributedEnabledByBundleCallback = (err: Base.BusinessError, data: boolean) => {
  if (err) {
    console.info("isDistributedEnabledByBundle failed " + JSON.stringify(err));
  } else {
    console.info("isDistributedEnabledByBundle success" + JSON.stringify(data));
  }
};

let bundle: Notification.BundleOption = {
  bundle: "bundleName1",
};

Notification.isDistributedEnabledByBundle(bundle, isDistributedEnabledByBundleCallback);

Notification.isDistributedEnabledByBundle⁸⁺

isDistributedEnabledByBundle(bundle: BundleOption): Promise<boolean>

查询指定应用是否支持分布式通知（Promise形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

参数：

参数名	类型	必填	说明
bundle	BundleOption	是	应用的包。

返回值：

类型	说明
Promise<boolean>	Promise方式返回指定应用是否支持分布式通知的结果。

示例：

import Base from '@ohos.base';

let bundle: Notification.BundleOption = {
  bundle: "bundleName1",
};

Notification.isDistributedEnabledByBundle(bundle).then((data: boolean) => {
  console.info("isDistributedEnabledByBundle success, data: " + JSON.stringify(data));
}).catch((err: Base.BusinessError) => {
  console.error(`isDistributedEnabledByBundle failed, code is ${err}`);
});

Notification.getDeviceRemindType⁸⁺

getDeviceRemindType(callback: AsyncCallback<DeviceRemindType>): void

获取通知的提醒方式（Callback形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

参数：

参数名	类型	必填	说明
callback	AsyncCallback<DeviceRemindType>	是	获取通知提醒方式的回调函数。

示例：

import Base from '@ohos.base';

let getDeviceRemindTypeCallback = (err: Base.BusinessError, data: Notification.DeviceRemindType) => {
  if (err) {
    console.info("getDeviceRemindType failed " + JSON.stringify(err));
  } else {
    console.info("getDeviceRemindType success");
  }
};

Notification.getDeviceRemindType(getDeviceRemindTypeCallback);

Notification.getDeviceRemindType⁸⁺

getDeviceRemindType(): Promise<DeviceRemindType>

获取通知的提醒方式（Promise形式）。

系统能力：SystemCapability.Notification.Notification

需要权限: ohos.permission.NOTIFICATION_CONTROLLER

系统API: 此接口为系统接口，三方应用不支持调用。

返回值：

类型	说明
Promise<DeviceRemindType>	Promise方式返回获取通知提醒方式的结果。

示例：

import Base from '@ohos.base';

Notification.getDeviceRemindType().then((data: Notification.DeviceRemindType) => {
  console.info("getDeviceRemindType success, data: " + JSON.stringify(data));
}).catch((err: Base.BusinessError) => {
  console.error(`getDeviceRemindType failed, code is ${err}`);
});

SubscribeCallbackData

系统能力：以下各项对应的系统能力均为SystemCapability.Notification.Notification

系统API：此接口为系统接口，三方应用不支持调用。

名称	类型	可读	可写	说明
request	NotificationRequest	是	否	通知内容。
sortingMap	NotificationSortingMap	是	否	通知排序信息。
reason	number	是	否	删除原因。
sound	string	是	否	通知声音。
vibrationValues	Array<number>	是	否	通知震动。

EnabledNotificationCallbackData⁸⁺

系统能力：以下各项对应的系统能力均为SystemCapability.Notification.Notification

系统API：此接口为系统接口，三方应用不支持调用。

名称	类型	可读	可写	说明
bundle	string	是	否	应用的包名。
uid	number	是	否	应用的uid。
enable	boolean	是	否	应用通知使能状态。

DoNotDisturbDate⁸⁺ ^deprecated

系统能力：以下各项对应的系统能力均为SystemCapability.Notification.Notification

说明： 从 API version 8开始支持，从API version 9开始废弃。建议使用notificationManager.DoNotDisturbDate替代

系统API：此接口为系统接口，三方应用不支持调用。

名称	类型	可读	可写	说明
type	DoNotDisturbType	是	是	免打扰设置的时间类型。
begin	Date	是	是	免打扰设置的起点时间。
end	Date	是	是	免打扰设置的终点时间。

DoNotDisturbType⁸⁺ ^deprecated

系统能力：以下各项对应的系统能力均为SystemCapability.Notification.Notification

说明： 从 API version 8开始支持，从API version 9开始废弃。建议使用notificationManager.DoNotDisturbType替代

系统API: 此接口为系统接口，三方应用不支持调用。

名称	值	说明
TYPE_NONE	0	非通知勿扰类型。
TYPE_ONCE	1	以设置时间段(只看小时和分钟)一次执行勿扰。
TYPE_DAILY	2	以设置时间段(只看小时和分钟)每天执行勿扰。
TYPE_CLEARLY	3	以设置时间段(明确年月日时分)执行勿扰。

ContentType

系统能力：以下各项对应的系统能力均为SystemCapability.Notification.Notification

名称	值	说明
NOTIFICATION_CONTENT_BASIC_TEXT	NOTIFICATION_CONTENT_BASIC_TEXT	普通类型通知。
NOTIFICATION_CONTENT_LONG_TEXT	NOTIFICATION_CONTENT_LONG_TEXT	长文本类型通知。
NOTIFICATION_CONTENT_PICTURE	NOTIFICATION_CONTENT_PICTURE	图片类型通知。
NOTIFICATION_CONTENT_CONVERSATION	NOTIFICATION_CONTENT_CONVERSATION	社交类型通知。
NOTIFICATION_CONTENT_MULTILINE	NOTIFICATION_CONTENT_MULTILINE	多行文本类型通知。

SlotLevel

系统能力：以下各项对应的系统能力均为SystemCapability.Notification.Notification

名称	值	说明
LEVEL_NONE	0	表示关闭通知功能。
LEVEL_MIN	1	表示通知功能已启用，但状态栏中不显示通知图标，且没有横幅或提示音。
LEVEL_LOW	2	表示通知功能已启用，且状态栏中显示通知图标，但没有横幅或提示音。
LEVEL_DEFAULT	3	表示通知功能已启用，状态栏中显示通知图标，没有横幅但有提示音。
LEVEL_HIGH	4	表示通知功能已启用，状态栏中显示通知图标，有横幅和提示音。

BundleOption^deprecated

系统能力：以下各项对应的系统能力均为SystemCapability.Notification.Notification

说明： 从 API version 7开始支持，从API version 9开始废弃。建议使用notificationManager.BundleOption替代

名称	类型	必填	说明
bundle	string	是	应用的包信息。
uid	number	否	用户ID，默认为0。

NotificationKey^deprecated

系统能力：以下各项对应的系统能力均为SystemCapability.Notification.Notification

说明： 从 API version 7开始支持，从API version 9开始废弃。建议使用notificationManager.NotificationKey替代

名称	类型	可读	可写	说明
id	number	是	是	通知ID。
label	string	是	是	通知标签。

SlotType

系统能力：以下各项对应的系统能力均为SystemCapability.Notification.Notification

名称	值	说明
UNKNOWN_TYPE	0	未知类型。
SOCIAL_COMMUNICATION	1	社交类型。
SERVICE_INFORMATION	2	服务类型。
CONTENT_INFORMATION	3	内容类型。
OTHER_TYPES	0xFFFF	其他类型。

NotificationActionButton

描述通知中显示的操作按钮。

系统能力：以下各项对应的系统能力均为SystemCapability.Notification.Notification

名称	类型	可读	可写	说明
title	string	是	是	按钮标题。
wantAgent	WantAgent	是	是	点击按钮时触发的WantAgent。
extras	{ [key: string]: any }	是	是	按钮扩展信息。
userInput⁸⁺	NotificationUserInput	是	是	用户输入对象实例。

NotificationBasicContent

描述普通文本通知。

系统能力：以下各项对应的系统能力均为SystemCapability.Notification.Notification

名称	类型	可读	可写	说明
title	string	是	是	通知标题。
text	string	是	是	通知内容。
additionalText	string	是	是	通知附加内容，是对通知内容的补充。

NotificationLongTextContent

描述长文本通知。

系统能力：以下各项对应的系统能力均为SystemCapability.Notification.Notification

名称	类型	可读	可写	说明
title	string	是	是	通知标题。
text	string	是	是	通知内容。
additionalText	string	是	是	通知附加内容，是对通知内容的补充。
longText	string	是	是	通知的长文本。
briefText	string	是	是	通知概要内容，是对通知内容的总结。
expandedTitle	string	是	是	通知展开时的标题。

NotificationMultiLineContent

描述多行文本通知。

系统能力：以下各项对应的系统能力均为SystemCapability.Notification.Notification

名称	类型	可读	可写	说明
title	string	是	是	通知标题。
text	string	是	是	通知内容。
additionalText	string	是	是	通知附加内容，是对通知内容的补充。
briefText	string	是	是	通知概要内容，是对通知内容的总结。
longTitle	string	是	是	通知展开时的标题。
lines	Array<string>	是	是	通知的多行文本。

NotificationPictureContent

描述附有图片的通知。

系统能力：以下各项对应的系统能力均为SystemCapability.Notification.Notification

名称	类型	可读	可写	说明
title	string	是	是	通知标题。
text	string	是	是	通知内容。
additionalText	string	是	是	通知附加内容，是对通知内容的补充。
briefText	string	是	是	通知概要内容，是对通知内容的总结。
expandedTitle	string	是	是	通知展开时的标题。
picture	image.PixelMap	是	是	通知的图片内容。

NotificationContent

描述通知类型。

系统能力：以下各项对应的系统能力均为SystemCapability.Notification.Notification

名称	类型	可读	可写	说明
contentType	ContentType	是	是	通知内容类型。
normal	NotificationBasicContent	是	是	基本类型通知内容。
longText	NotificationLongTextContent	是	是	长文本类型通知内容。
multiLine	NotificationMultiLineContent	是	是	多行类型通知内容。
picture	NotificationPictureContent	是	是	图片类型通知内容。

NotificationFlagStatus⁸⁺

描述通知标志状态。

系统能力：以下各项对应的系统能力均为SystemCapability.Notification.Notification

系统接口：此接口为系统接口，三方应用不支持调用。

名称	值	说明
TYPE_NONE	0	默认标志。
TYPE_OPEN	1	通知标志打开。
TYPE_CLOSE	2	通知标志关闭。

NotificationFlags⁸⁺

描述通知标志的实例。

系统能力：以下各项对应的系统能力均为SystemCapability.Notification.Notification

名称	类型	可读	可写	说明
soundEnabled	NotificationFlagStatus	是	否	是否启用声音提示。
vibrationEnabled	NotificationFlagStatus	是	否	是否启用振动提醒功能。

NotificationRequest

描述通知的请求。

系统能力：以下各项对应的系统能力均为SystemCapability.Notification.Notification

名称	类型	可读	可写	说明
content	NotificationContent	是	是	通知内容。
id	number	是	是	通知ID。
slotType	SlotType	是	是	通道类型。
isOngoing	boolean	是	是	是否进行时通知。
isUnremovable	boolean	是	是	是否可移除。
deliveryTime	number	是	是	通知发送时间。
tapDismissed	boolean	是	是	通知是否自动清除。
autoDeletedTime	number	是	是	自动清除的时间。
wantAgent	WantAgent	是	是	WantAgent封装了应用的行为意图，点击通知时触发该行为。
extraInfo	{[key: string]: any}	是	是	扩展参数。
color	number	是	是	通知背景颜色。预留能力，暂未支持。
colorEnabled	boolean	是	是	通知背景颜色是否使能。预留能力，暂未支持。
isAlertOnce	boolean	是	是	设置是否仅有一次此通知提醒。
isStopwatch	boolean	是	是	是否显示已用时间。
isCountDown	boolean	是	是	是否显示倒计时时间。
isFloatingIcon	boolean	是	是	是否显示状态栏图标。
label	string	是	是	通知标签。
badgeIconStyle	number	是	是	通知角标类型。
showDeliveryTime	boolean	是	是	是否显示分发时间。
actionButtons	Array<NotificationActionButton>	是	是	通知按钮，最多两个按钮。
smallIcon	image.PixelMap	是	是	通知小图标。可选字段，大小不超过30KB。
largeIcon	image.PixelMap	是	是	通知大图标。可选字段，大小不超过30KB。
creatorBundleName	string	是	否	创建通知的包名。
creatorUid	number	是	否	创建通知的UID。
creatorPid	number	是	否	创建通知的PID。
creatorUserId⁸⁺	number	是	否	创建通知的UserId。
hashCode	string	是	否	通知唯一标识。
classification	string	是	是	通知分类。系统API: 此接口为系统接口，三方应用不支持调用。
groupName⁸⁺	string	是	是	组通知名称。
template⁸⁺	NotificationTemplate	是	是	通知模板。
isRemoveAllowed⁸⁺	boolean	是	否	通知是否能被移除。系统API: 此接口为系统接口，三方应用不支持调用。
source⁸⁺	number	是	否	通知源。系统API: 此接口为系统接口，三方应用不支持调用。
distributedOption⁸⁺	DistributedOptions	是	是	分布式通知的选项。
deviceId⁸⁺	string	是	否	通知源的deviceId。系统API: 此接口为系统接口，三方应用不支持调用。
notificationFlags⁸⁺	NotificationFlags	是	否	获取NotificationFlags。
removalWantAgent⁹⁺	WantAgent	是	是	当移除通知时，通知将被重定向到的WantAgent实例。
badgeNumber⁹⁺	number	是	是	应用程序图标上显示的通知数。

DistributedOptions⁸⁺

描述分布式选项。

系统能力：以下各项对应的系统能力均为SystemCapability.Notification.Notification

名称	类型	可读	可写	说明
isDistributed	boolean	是	是	是否为分布式通知。
supportDisplayDevices	Array<string>	是	是	可以同步通知到的设备列表。
supportOperateDevices	Array<string>	是	是	可以打开通知的设备列表。
remindType	number	是	否	通知的提醒方式。系统API: 此接口为系统接口，三方应用不支持调用。

NotificationSlot

描述通知槽

系统能力：以下各项对应的系统能力均为SystemCapability.Notification.Notification

名称	类型	可读	可写	说明
type	SlotType	是	是	通道类型。
level	number	是	是	通知级别，不设置则根据通知渠道类型有默认值。
desc	string	是	是	通知渠道描述信息。
badgeFlag	boolean	是	是	是否显示角标。
bypassDnd	boolean	是	是	设置是否在系统中绕过免打扰模式。
lockscreenVisibility	number	是	是	在锁定屏幕上显示通知的模式。
vibrationEnabled	boolean	是	是	是否可振动。
sound	string	是	是	通知提示音。
lightEnabled	boolean	是	是	是否闪灯。
lightColor	number	是	是	通知灯颜色。
vibrationValues	Array<number>	是	是	通知振动样式。
enabled⁹⁺	boolean	是	否	此通知插槽中的启停状态。

NotificationSorting

提供有关活动通知的排序信息。

系统能力：以下各项对应的系统能力均为SystemCapability.Notification.Notification

系统API: 此接口为系统接口，三方应用不支持调用。

名称	类型	可读	可写	说明
slot	NotificationSlot	是	否	通知通道内容。
hashCode	string	是	否	通知唯一标识。
ranking	number	是	否	通知排序序号。

NotificationSortingMap

提供关于已订阅的所有通知中活动通知的排序信息

系统能力：以下各项对应的系统能力均为SystemCapability.Notification.Notification

系统API：此接口为系统接口，三方应用不支持调用。

名称	类型	可读	可写	说明
sortings	{[key: string]: NotificationSorting}	是	否	通知排序信息数组。
sortedHashCode	Array<string>	是	否	通知唯一标识数组。

NotificationSubscribeInfo

设置订阅所需通知的发布者的信息。

系统能力：以下各项对应的系统能力均为SystemCapability.Notification.Notification

系统API: 此接口为系统接口，三方应用不支持调用。

名称	类型	可读	可写	说明
bundleNames	Array<string>	是	是	指定订阅哪些包名的APP发来的通知。
userId	number	是	是	指定订阅哪个用户下发来的通知，可以通过getCurrentOsAccount获取userId。

NotificationTemplate⁸⁺

通知模板。

系统能力：以下各项对应的系统能力均为SystemCapability.Notification.Notification

名称	类型	可读	可写	说明
name	string	是	是	模板名称。
data	{[key:string]: Object}	是	是	模板数据。

NotificationUserInput⁸⁺

保存用户输入的通知消息。

系统能力：SystemCapability.Notification.Notification

名称	类型	可读	可写	说明
inputKey	string	是	是	用户输入时用于标识此输入的key。

DeviceRemindType⁸⁺ ^deprecated

系统能力：SystemCapability.Notification.Notification

系统API: 此接口为系统接口，三方应用不支持调用。

说明： 从 API version 8开始支持，从API version 9开始废弃。建议使用notificationManager.DeviceRemindType替代

名称	值	说明
IDLE_DONOT_REMIND	0	设备未被使用，无需提醒。
IDLE_REMIND	1	提醒设备未被使用。
ACTIVE_DONOT_REMIND	2	设备正在使用，无需提醒。
ACTIVE_REMIND	3	提醒设备正在使用。

SourceType⁸⁺ ^deprecated

系统能力：SystemCapability.Notification.Notification

系统API: 此接口为系统接口，三方应用不支持调用。

说明： 从 API version 8开始支持，从API version 9开始废弃。建议使用notificationManager.SourceType替代

名称	值	说明
TYPE_NORMAL	0	一般通知。
TYPE_CONTINUOUS	1	连续通知。
TYPE_TIMER	2	计划通知。

RemoveReason ^deprecated

系统能力：SystemCapability.Notification.Notification

系统API: 此接口为系统接口，三方应用不支持调用。

说明： 从 API version 7开始支持，从API version 9开始废弃。建议使用notificationManager.RemoveReason替代

名称	值	说明
CLICK_REASON_REMOVE	1	点击通知后删除通知。
CANCEL_REASON_REMOVE	2	用户删除通知。

你可能感兴趣的鸿蒙文章

harmony 鸿蒙接口

harmony 鸿蒙系统公共事件定义(待停用)

harmony 鸿蒙系统公共事件定义

harmony 鸿蒙开发说明

harmony 鸿蒙企业设备管理概述（仅对系统应用开放）

harmony 鸿蒙BundleStatusCallback

harmony 鸿蒙@ohos.bundle.innerBundleManager (innerBundleManager模块)

harmony 鸿蒙@ohos.distributedBundle (分布式包管理)

harmony 鸿蒙@ohos.bundle (Bundle模块)

harmony 鸿蒙@ohos.enterprise.EnterpriseAdminExtensionAbility (企业设备管理扩展能力)

0 赞

所属分类： 后端技术
本文标签： 软件鸿蒙
版权声明： 原创文章如转载，请注明本文链接: https://www.seaxiang.com/blog/5360967660ef4d0eaff42fb8680d1012

harmony 鸿蒙@ohos.notification (Notification模块)

@ohos.notification (Notification模块)

导入模块

Notification.publish

Notification.publish

Notification.publish8+

Notification.publish8+

Notification.cancel

Notification.cancel

Notification.cancel

Notification.cancelAll

Notification.cancelAll

Notification.addSlot

Notification.addSlot

Notification.addSlot

Notification.addSlot

Notification.addSlots

Notification.addSlots

Notification.getSlot

Notification.getSlot

Notification.getSlots

Notification.getSlots

Notification.removeSlot

Notification.removeSlot

Notification.removeAllSlots

Notification.removeAllSlots

Notification.subscribe

Notification.subscribe

Notification.subscribe

Notification.unsubscribe

Notification.unsubscribe

Notification.enableNotification

Notification.enableNotification

Notification.isNotificationEnabled

Notification.isNotificationEnabled

Notification.isNotificationEnabled

Notification.isNotificationEnabled

Notification.displayBadge

Notification.displayBadge

Notification.isBadgeDisplayed

Notification.isBadgeDisplayed

Notification.setSlotByBundle

Notification.setSlotByBundle

Notification.getSlotsByBundle

Notification.getSlotsByBundle

Notification.getSlotNumByBundle

Notification.getSlotNumByBundle

Notification.remove

Notification.remove

Notification.remove

Notification.remove

Notification.removeAll

Notification.removeAll

Notification.removeAll

Notification.removeAll8+

Notification.removeAll8+

Notification.getAllActiveNotifications

Notification.getAllActiveNotifications

Notification.getActiveNotificationCount

Notification.getActiveNotificationCount

Notification.getActiveNotifications

Notification.getActiveNotifications

Notification.cancelGroup8+

Notification.cancelGroup8+

Notification.removeGroupByBundle8+

Notification.removeGroupByBundle8+

Notification.setDoNotDisturbDate8+

Notification.setDoNotDisturbDate8+

Notification.setDoNotDisturbDate8+

Notification.setDoNotDisturbDate8+

Notification.getDoNotDisturbDate8+

Notification.getDoNotDisturbDate8+

Notification.getDoNotDisturbDate8+

Notification.getDoNotDisturbDate8+

Notification.supportDoNotDisturbMode8+

Notification.supportDoNotDisturbMode8+

Notification.isSupportTemplate8+

Notification.isSupportTemplate8+

Notification.requestEnableNotification8+

Notification.requestEnableNotification8+

Notification.publish⁸⁺

Notification.publish⁸⁺

Notification.removeAll⁸⁺

Notification.removeAll⁸⁺

Notification.cancelGroup⁸⁺

Notification.cancelGroup⁸⁺

Notification.removeGroupByBundle⁸⁺

Notification.removeGroupByBundle⁸⁺

Notification.setDoNotDisturbDate⁸⁺

Notification.setDoNotDisturbDate⁸⁺

Notification.setDoNotDisturbDate⁸⁺

Notification.setDoNotDisturbDate⁸⁺

Notification.getDoNotDisturbDate⁸⁺

Notification.getDoNotDisturbDate⁸⁺

Notification.getDoNotDisturbDate⁸⁺

Notification.getDoNotDisturbDate⁸⁺

Notification.supportDoNotDisturbMode⁸⁺

Notification.supportDoNotDisturbMode⁸⁺

Notification.isSupportTemplate⁸⁺

Notification.isSupportTemplate⁸⁺

Notification.requestEnableNotification⁸⁺

Notification.requestEnableNotification⁸⁺

Notification.enableDistributed⁸⁺

Notification.enableDistributed⁸⁺

Notification.isDistributedEnabled⁸⁺

Notification.isDistributedEnabled⁸⁺

Notification.enableDistributedByBundle⁸⁺

Notification.enableDistributedByBundle⁸⁺

Notification.isDistributedEnabledByBundle⁸⁺

Notification.isDistributedEnabledByBundle⁸⁺

Notification.getDeviceRemindType⁸⁺

Notification.getDeviceRemindType⁸⁺

EnabledNotificationCallbackData⁸⁺

DoNotDisturbDate⁸⁺ ^deprecated

DoNotDisturbType⁸⁺ ^deprecated

BundleOption^deprecated

NotificationKey^deprecated

NotificationFlagStatus⁸⁺

NotificationFlags⁸⁺

DistributedOptions⁸⁺

NotificationTemplate⁸⁺

NotificationUserInput⁸⁺

DeviceRemindType⁸⁺ ^deprecated

SourceType⁸⁺ ^deprecated

RemoveReason ^deprecated