koishi-plugin-bilibili-notify 2.0.0-alpha.9 → 3.0.0-alpha.0

package/lib/comRegister.js

@@ -18,14 +18,25 @@ var LiveType;
     LiveType[LiveType["StopBroadcast"] = 3] = "StopBroadcast";
 })(LiveType || (LiveType = {}));
 class ComRegister {
-    static inject = ['ba', 'gi', 'database', 'sm'];
+    // 必须服务
+    static inject = ['ba', 'gi', 'database', 'bl', 'sm'];
+    // 定义数组：QQ相关bot
     qqRelatedBotList = ['qq', 'onebot', 'red', 'satori', 'chronocat'];
+    // logger
     logger;
+    // config
     config;
+    // 登录定时器
     loginTimer;
+    // 订阅数量
     num = 0;
+    // 重启次数
     rebootCount = 0;
+    // 订阅通知
     subNotifier;
+    // Context
+    ctx;
+    // 订阅管理器
     subManager = [];
     // 检查登录数据库是否有数据
     loginDBData;
@@ -37,56 +48,11 @@ class ComRegister {
     sendMsgFunc;
     // 构造函数
     constructor(ctx, config) {
-        this.logger = ctx.logger('cr');
-        this.config = config;
-        // 拿到私人机器人实例
-        this.privateBot = ctx.bots.find(bot => bot.platform === config.master.platform);
-        if (!this.privateBot) {
-            ctx.notifier.create({
-                content: '您未配置私人机器人，将无法向您推送机器人状态！'
-            });
-            this.logger.error('您未配置私人机器人，将无法向您推送机器人状态！');
-        }
-        // 检查登录数据库是否有数据
-        ctx.database.get('loginBili', 1, ['dynamic_group_id']).then(data => this.loginDBData = data[0]);
-        // 从数据库获取订阅
-        this.getSubFromDatabase(ctx);
-        // 判断消息发送方式
-        if (config.automaticResend) {
-            this.sendMsgFunc = async (bot, guild, content) => {
-                // 多次尝试发送消息
-                const attempts = 3;
-                for (let i = 0; i < attempts; i++) {
-                    try {
-                        // 发送消息
-                        await bot.sendMessage(guild, content);
-                        // 防止消息发送速度过快被忽略
-                        await ctx.sleep(500);
-                        // 成功发送消息，跳出循环
-                        break;
-                    }
-                    catch (e) {
-                        if (i === attempts - 1) { // 已尝试三次
-                            this.logger.error(`发送群组ID:${guild}消息失败！原因: ` + e.message);
-                            console.log(e);
-                            this.sendPrivateMsg(`发送群组ID:${guild}消息失败，请查看日志`);
-                        }
-                    }
-                }
-            };
-        }
-        else {
-            this.sendMsgFunc = async (bot, guild, content) => {
-                try {
-                    // 发送消息
-                    await bot.sendMessage(guild, content);
-                }
-                catch (e) {
-                    this.logger.error(`发送群组ID:${guild}消息失败！原因: ` + e.message);
-                    await this.sendPrivateMsg(`发送群组ID:${guild}消息失败，请查看日志`);
-                }
-            };
-        }
+        // 将ctx赋值给类属性
+        this.ctx = ctx;
+        // 初始化
+        this.init(config);
+        // 注册指令
         const statusCom = ctx.command('status', '插件状态相关指令', { permissions: ['authority:5'] });
         statusCom.subcommand('.dyn', '查看动态监测运行状态')
             .usage('查看动态监测运行状态')
@@ -198,7 +164,7 @@ class ComRegister {
                         // 销毁定时器
                         this.loginTimer();
                         // 订阅之前的订阅
-                        await this.getSubFromDatabase(ctx);
+                        await this.loadSubFromDatabase();
                         // 清除控制台通知
                         ctx.ba.disposeNotifier();
                         // 发送成功登录推送
@@ -236,17 +202,14 @@ class ComRegister {
                     // 取消单个订阅
                     if (options.live || options.dynamic) {
                         if (options.live)
-                            await session.send(this.unsubSingle(ctx, sub.roomId, 0)); /* 0为取消订阅Live */
+                            await session.send(this.unsubSingle(sub.roomId, 0)); /* 0为取消订阅Live */
                         if (options.dynamic)
-                            await session.send(this.unsubSingle(ctx, sub.uid, 1)); /* 1为取消订阅Dynamic */
+                            await session.send(this.unsubSingle(sub.uid, 1)); /* 1为取消订阅Dynamic */
                         // 将存在flag设置为true
                         exist = true;
                         // 结束循环
                         return;
                     }
-                    // 取消全部订阅 执行dispose方法，销毁定时器
-                    if (sub.live)
-                        this.subManager[i].liveDispose();
                     // 从数据库中删除订阅
                     await ctx.database.remove('bilibili', { uid: this.subManager[i].uid });
                     // 将该订阅对象从订阅管理对象中移除
@@ -265,16 +228,11 @@ class ComRegister {
                     // id--
                     this.num--;
                     // 判断是否还有动态订阅
-                    if (this.dynamicDispose && !this.subManager.find((sub) => sub.dynamic === true)) { // 没有动态订阅
-                        // 将动态检测关闭
-                        this.dynamicDispose();
-                        // 将动态监测置为空
-                        this.dynamicDispose = null;
-                    }
+                    this.checkIfUserIsTheLastOneWhoSubDyn();
                     // 发送成功通知
                     await session.send('已取消订阅该用户');
                     // 更新控制台提示
-                    this.updateSubNotifier(ctx);
+                    this.updateSubNotifier();
                     // 将存在flag设置为true
                     exist = true;
                 }
@@ -292,20 +250,21 @@ class ComRegister {
             return subTable;
         });
         biliCom
-            .subcommand('.sub <mid:string>', '订阅用户动态和直播通知')
-            .option('multiplatform', '-m <value:string>', { type: /^[A-Za-z0-9]+(?:,[A-Za-z0-9]+)*\.[A-Za-z0-9]+(?:,[A-Za-z0-9]+)*(?:;[A-Za-z0-9]+(?:,[A-Za-z0-9]+)*\.[A-Za-z0-9]+(?:,[A-Za-z0-9]+)*)*$/ })
+            .subcommand('.sub <mid:string> [...groupId:string]', '订阅用户动态和直播通知')
+            .option('multiplatform', '-m <value:string>', { type: /^(?:-?[A-Za-z0-9]+@?(?:,-?[A-Za-z0-9]+@?)*\.[A-Za-z0-9]+)(?:;(?:-?[A-Za-z0-9]+@?(?:,-?[A-Za-z0-9]+@?)*\.[A-Za-z0-9]+))*$/ })
             .option('live', '-l')
             .option('dynamic', '-d')
-            .usage('订阅用户动态和直播通知，若需要订阅直播请加上-l，需要订阅动态则加上-d。若没有加任何参数，之后会向你单独询问，尖括号中为必选参数，中括号为可选参数，目标群号若不填，则默认为当前群聊')
-            .example('bili sub 1194210119 目标QQ群号(实验性) -l -d 订阅UID为1194210119的UP主的动态和直播')
-            .action(async ({ session, options }, mid) => {
+            .option('atAll', '-a')
+            .usage('订阅用户动态和直播通知，若需要订阅直播请加上-l，需要订阅动态则加上-d')
+            .example('bili sub 1194210119 目标群号或频道号 -l -d 订阅UID为1194210119的UP主的动态和直播')
+            .action(async ({ session, options }, mid, ...groupId) => {
             this.logger.info('调用bili.sub指令');
             // 先判断是否订阅直播，再判断是否解锁订阅限制，最后判断直播订阅是否已超三个
             if (options.live && !this.config.unlockSubLimits && (this.subManager.reduce((acc, cur) => acc + (cur.live ? 1 : 0), 0) >= 3)) {
                 return '直播订阅已达上限，请取消部分直播订阅后再进行订阅';
             }
             // 检查是否登录
-            if (!(await this.checkIfIsLogin(ctx))) {
+            if (!(await this.checkIfIsLogin())) {
                 // 未登录直接返回
                 return '请使用指令bili login登录后再进行订阅操作';
             }
@@ -313,77 +272,103 @@ class ComRegister {
             if (!mid)
                 return '请输入用户uid';
             // 订阅对象
-            const subUserData = await this.subUserInBili(ctx, mid);
+            const subUserData = await this.subUserInBili(mid);
             // 判断是否订阅对象存在
             if (!subUserData.flag)
                 return '订阅对象失败，请稍后重试！';
-            let target;
-            // 判断是否使用多平台功能
-            if (options.multiplatform) {
-                // 分割字符串，赋值给target
-                target = this.splitMultiPlatformStr(options.multiplatform);
+            // 定义目标变量
+            let target = [];
+            // 判断是否使用了多群组推送
+            if (groupId.length > 0) {
+                // 定义channelIdArr
+                const channelIdArr = [];
+                // 遍历输入的群组
+                groupId.forEach(group => {
+                    channelIdArr.push({
+                        channelId: group,
+                        dynamic: true,
+                        live: true,
+                        liveDanmaku: false,
+                        atAll: options.atAll
+                    });
+                });
+                target.push({
+                    channelIdArr,
+                    platform: session.event.platform
+                });
             }
-            if (target) {
-                target.forEach(async ({ idArr, platform }, index) => {
-                    if (idArr.length > 0) { // 输入了推送群号或频道号
-                        // 拿到对应的bot
-                        const bot = this.getBot(ctx, platform);
-                        // 判断是否配置了对应平台的机器人
-                        if (!ctx.bots.some(bot => bot.platform === platform)) {
-                            await session.send('您未配置对应平台的机器人，不能在该平台进行订阅操作');
-                        }
-                        // 判断是否需要加入的群全部推送
-                        if (idArr[0] !== 'all') {
-                            // 定义满足条件的群组数组
-                            const targetArr = [];
-                            // 获取机器人加入的群组
-                            const guildList = await bot.getGuildList();
-                            // 遍历target数组
-                            for (const id of idArr) {
-                                // 定义是否加入群组标志
-                                let flag = false;
-                                // 遍历群组
-                                for (const guild of guildList.data) {
-                                    // 获取频道列表
-                                    const channelList = await bot.getChannelList(guild.id);
-                                    // 判断机器人是否加入群聊或频道
-                                    if (channelList.data.some(channel => channel.id === id)) {
-                                        // 加入群聊或频道
-                                        targetArr.push(id);
-                                        // 设置标志位为true
-                                        flag = true;
-                                        // 结束循环
-                                        break;
+            else {
+                // 判断是否使用多平台功能
+                if (options.multiplatform) {
+                    // 分割字符串，赋值给target
+                    target = this.splitMultiPlatformStr(options.multiplatform);
+                }
+                // 判断是否使用了多平台
+                if (target.length > 0) {
+                    for (const [index, { channelIdArr, platform }] of target.entries()) {
+                        if (channelIdArr.length > 0) { // 输入了推送群号或频道号
+                            // 拿到对应的bot
+                            const bot = this.getBot(platform);
+                            // 判断是否配置了对应平台的机器人
+                            if (!ctx.bots.some(bot => bot.platform === platform)) {
+                                // 发送提示消息
+                                await session.send('您未配置对应平台的机器人，不能在该平台进行订阅操作');
+                                // 直接返回
+                                return;
+                            }
+                            // 判断是否需要加入的群全部推送
+                            if (channelIdArr[0].channelId !== 'all') {
+                                // 定义满足条件的群组数组
+                                const targetArr = [];
+                                // 获取机器人加入的群组
+                                const guildList = await bot.getGuildList();
+                                // 遍历target数组
+                                for (const channelId of channelIdArr) {
+                                    // 定义是否加入群组标志
+                                    let flag = false;
+                                    // 遍历群组
+                                    for (const guild of guildList.data) {
+                                        // 获取频道列表
+                                        const channelList = await bot.getChannelList(guild.id);
+                                        // 判断机器人是否加入群聊或频道
+                                        if (channelList.data.some(channel => channel.id === channelId.channelId)) {
+                                            // 加入群聊或频道
+                                            targetArr.push(channelId);
+                                            // 设置标志位为true
+                                            flag = true;
+                                            // 结束循环
+                                            break;
+                                        }
+                                    }
+                                    if (!flag) {
+                                        // 不满足条件发送错误提示
+                                        await session.send(`您的机器未加入${channelId.channelId}，无法对该群或频道进行推送`);
                                     }
                                 }
-                                if (!flag) {
-                                    // 不满足条件发送错误提示
-                                    await session.send(`您的机器未加入${id}，无法对该群或频道进行推送`);
+                                // 判断targetArr是否为空
+                                if (target.length === 0) {
+                                    // 为空则默认为当前环境
+                                    target = [{ channelIdArr: [{ channelId: session.event.channel.id, dynamic: true, live: true, liveDanmaku: false, atAll: options.atAll ? options.atAll : false }], platform: session.event.platform }];
+                                    // 没有满足条件的群组或频道
+                                    await session.send('没有满足条件的群组或频道，默认订阅到当前聊天环境');
                                 }
+                                // 将符合条件的群组添加到target中
+                                target[index].channelIdArr = targetArr;
                             }
-                            // 判断targetArr是否为空
-                            if (target.length === 0) {
-                                // 为空则默认为当前环境
-                                target = [{ idArr: [session.event.channel.id], platform: session.event.platform }];
-                                // 没有满足条件的群组或频道
-                                await session.send('没有满足条件的群组或频道，默认订阅到当前聊天环境');
-                            }
-                            // 将符合条件的群组添加到target中
-                            target[index].idArr = targetArr;
+                            // 如果为all则全部推送，不需要进行处理
+                        }
+                        else {
+                            // 未填写群号或频道号，默认为当前环境
+                            target = [{ channelIdArr: [{ channelId: session.event.channel.id, dynamic: true, live: true, liveDanmaku: false, atAll: options.atAll ? options.atAll : false }], platform: session.event.platform }];
+                            // 发送提示消息
+                            await session.send('没有填写群号或频道号，默认订阅到当前聊天环境');
                         }
-                        // 如果为all则全部推送，不需要进行修改
-                    }
-                    else {
-                        // 未填写群号或频道号，默认为当前环境
-                        target = [{ idArr: [session.event.channel.id], platform: session.event.platform }];
-                        // 发送提示消息
-                        await session.send('没有填写群号或频道号，默认订阅到当前聊天环境');
                     }
-                });
-            }
-            else {
-                // 用户直接订阅，将当前环境赋值给target
-                target = [{ idArr: [session.event.channel.id], platform: session.event.platform }];
+                }
+                else {
+                    // 用户直接订阅，将当前环境赋值给target
+                    target = [{ channelIdArr: [{ channelId: session.event.channel.id, dynamic: true, live: true, liveDanmaku: false, atAll: options.atAll ? options.atAll : false }], platform: session.event.platform }];
+                }
             }
             // 定义外围变量                
             let content;
@@ -452,12 +437,10 @@ class ComRegister {
                 this.logger.error('bili sub指令 getMasterInfo() 发生了错误，错误为：' + e.message);
                 return '订阅出错啦，请重试';
             }
-            // 定义live销毁函数
-            let liveDispose;
             // 订阅直播
             if (liveMsg) {
-                // 开始循环检测
-                liveDispose = ctx.setInterval(this.liveDetect(ctx, roomId, target), config.liveLoopTime * 1000);
+                // 连接到服务器
+                this.liveDetectWithListener(roomId, target);
                 // 发送订阅消息通知
                 await session.send(`订阅${userData.info.uname}直播通知`);
             }
@@ -465,13 +448,7 @@ class ComRegister {
             if (dynamicMsg) {
                 // 判断是否开启动态监测
                 if (!this.dynamicDispose) {
-                    // 开启动态监测
-                    if (this.config.dynamicDebugMode) {
-                        this.dynamicDispose = ctx.setInterval(this.debug_dynamicDetect(ctx), config.dynamicLoopTime * 1000);
-                    }
-                    else {
-                        this.dynamicDispose = ctx.setInterval(this.dynamicDetect(ctx), config.dynamicLoopTime * 1000);
-                    }
+                    this.enableDynamicDetect();
                 }
                 // 发送订阅消息通知
                 await session.send(`订阅${userData.info.uname}动态通知`);
@@ -481,7 +458,6 @@ class ComRegister {
                 uid: mid,
                 room_id: roomId,
                 dynamic: dynamicMsg ? 1 : 0,
-                video: 1,
                 live: liveMsg ? 1 : 0,
                 target: JSON.stringify(target),
                 platform: session.event.platform,
@@ -498,28 +474,10 @@ class ComRegister {
                 platform: session.event.platform,
                 live: liveMsg,
                 dynamic: dynamicMsg,
-                liveDispose
             });
             // 新增订阅展示到控制台
-            this.updateSubNotifier(ctx);
+            this.updateSubNotifier();
         });
-        /* biliCom
-            .subcommand('.live <roomId:string> <...guildId:string>', '订阅主播开播通知', { hidden: true })
-            .usage('订阅主播开播通知')
-            .example('bili live 26316137 订阅房间号为26316137的直播间')
-            .action(async (_, roomId, ...guildId) => {
-                this.logger.info('调用bili.live指令')
-                // 如果room_id为空则返回
-                if (!roomId) return `${roomId}非法调用 dynamic 指令` // 订阅主播房间号不能为空
-                if (!guildId) return `${roomId}非法调用 dynamic 指令` // 目标群组或频道不能为空
-                // 要订阅的对象不在订阅管理对象中，直接返回
-                const index = this.subManager.findIndex(sub => sub.roomId === roomId)
-                if (index === -1) return '请勿直接调用该指令'
-                // 开始循环检测
-                const dispose = ctx.setInterval(this.liveDetect(ctx, roomId, guildId, this.subManager[index].platform), config.liveLoopTime * 1000)
-                // 保存销毁函数
-                this.subManager[index].liveDispose = dispose
-            }) */
         biliCom
             .subcommand('.status <roomId:string>', '查询主播当前直播状态', { hidden: true })
             .usage('查询主播当前直播状态')
@@ -574,14 +532,78 @@ class ComRegister {
             await session.send('已发送消息，如未收到则说明您的机器人不支持发送私聊消息或您的信息填写有误');
         });
     }
+    async init(config) {
+        // 设置logger
+        this.logger = this.ctx.logger('cr');
+        // 将config设置给类属性
+        this.config = config;
+        // 拿到私人机器人实例
+        this.privateBot = this.ctx.bots.find(bot => bot.platform === config.master.platform);
+        if (!this.privateBot) {
+            this.ctx.notifier.create({
+                content: '您未配置私人机器人，将无法向您推送机器人状态！'
+            });
+            this.logger.error('您未配置私人机器人，将无法向您推送机器人状态！');
+        }
+        // 判断消息发送方式
+        if (config.automaticResend) {
+            this.sendMsgFunc = async (bot, channelId, content) => {
+                // 多次尝试发送消息
+                const attempts = 3;
+                for (let i = 0; i < attempts; i++) {
+                    try {
+                        // 发送消息
+                        await bot.sendMessage(channelId, content);
+                        // 防止消息发送速度过快被忽略
+                        await this.ctx.sleep(500);
+                        // 成功发送消息，跳出循环
+                        break;
+                    }
+                    catch (e) {
+                        if (i === attempts - 1) { // 已尝试三次
+                            this.logger.error(`发送群组ID:${channelId}消息失败！原因: ` + e.message);
+                            console.log(e);
+                            this.sendPrivateMsg(`发送群组ID:${channelId}消息失败，请查看日志`);
+                        }
+                    }
+                }
+            };
+        }
+        else {
+            this.sendMsgFunc = async (bot, guild, content) => {
+                try {
+                    // 发送消息
+                    await bot.sendMessage(guild, content);
+                }
+                catch (e) {
+                    this.logger.error(`发送群组ID:${guild}消息失败！原因: ` + e.message);
+                    await this.sendPrivateMsg(`发送群组ID:${guild}消息失败，请查看日志`);
+                }
+            };
+        }
+        // 检查登录数据库是否有数据
+        this.loginDBData = (await this.ctx.database.get('loginBili', 1, ['dynamic_group_id']))[0];
+        // 从配置获取订阅
+        config.sub && await this.loadSubFromConfig(config.sub);
+        // 从数据库获取订阅
+        await this.loadSubFromDatabase();
+        // 检查是否需要动态监测
+        this.checkIfDynamicDetectIsNeeded();
+        // 在控制台中显示订阅对象
+        this.updateSubNotifier();
+    }
     splitMultiPlatformStr(str) {
         return str.split(';').map(cv => cv.split('.')).map(([idStr, platform]) => {
-            const idArr = idStr.split(',');
-            return { idArr, platform };
+            const channelIdArr = idStr.split(',').map(id => {
+                const atAll = /@$/.test(id); // 使用正则表达式检查 id 是否以 @ 结尾
+                const channelId = atAll ? id.slice(0, -1) : id; // 去除末尾的 @
+                return { channelId, dynamic: true, live: true, liveDanmaku: false, atAll };
+            });
+            return { channelIdArr, platform };
         });
     }
-    getBot(ctx, pf) {
-        return ctx.bots.find(bot => bot.platform === pf);
+    getBot(pf) {
+        return this.ctx.bots.find(bot => bot.platform === pf);
     }
     async sendPrivateMsg(content) {
         if (this.config.master.enable) {
@@ -595,7 +617,7 @@ class ComRegister {
             }
         }
     }
-    async sendPrivateMsgAndRebootService(ctx) {
+    async sendPrivateMsgAndRebootService() {
         // 判断重启次数是否超过三次
         if (this.rebootCount >= 3) {
             // logger
@@ -603,7 +625,7 @@ class ComRegister {
             // 重启失败，发送消息
             await this.sendPrivateMsg('已重启插件三次，请检查机器人状态后使用指令 sys start 启动插件');
             // 关闭插件
-            await ctx.sm.disposePlugin();
+            await this.ctx.sm.disposePlugin();
             // 结束
             return;
         }
@@ -612,7 +634,7 @@ class ComRegister {
         // logger
         this.logger.info('插件出现未知错误，正在重启插件');
         // 重启插件
-        const flag = await ctx.sm.restartPlugin();
+        const flag = await this.ctx.sm.restartPlugin();
         // 判断是否重启成功
         if (flag) {
             this.logger.info('重启插件成功');
@@ -623,42 +645,66 @@ class ComRegister {
             // 重启失败，发送消息
             await this.sendPrivateMsg('重启插件失败，请检查机器人状态后使用指令 sys start 启动插件');
             // 关闭插件
-            await ctx.sm.disposePlugin();
+            await this.ctx.sm.disposePlugin();
         }
     }
-    async sendPrivateMsgAndStopService(ctx) {
+    async sendPrivateMsgAndStopService() {
         // 发送消息
         await this.sendPrivateMsg('插件发生未知错误，请检查机器人状态后使用指令 sys start 启动插件');
         // logger
         this.logger.error('插件发生未知错误，请检查机器人状态后使用指令 sys start 启动插件');
         // 关闭插件
-        await ctx.sm.disposePlugin();
+        await this.ctx.sm.disposePlugin();
         // 结束
         return;
     }
-    async sendMsg(ctx, targets, content) {
+    async sendMsg(targets, content, live) {
         for (const target of targets) {
             // 获取机器人实例
-            const bot = this.getBot(ctx, target.platform);
+            const bot = this.getBot(target.platform);
             // 定义需要发送的数组
             let sendArr = [];
             // 判断是否需要推送所有机器人加入的群
-            if (target.idArr[0] === 'all') {
+            if (target.channelIdArr[0].channelId === 'all') {
                 // 获取所有guild
                 for (const guild of (await bot.getGuildList()).data) {
-                    sendArr.push(guild.id);
+                    sendArr.push({
+                        channelId: guild.id,
+                        dynamic: target.channelIdArr[0].dynamic,
+                        live: target.channelIdArr[0].live,
+                        liveDanmaku: target.channelIdArr[0].liveDanmaku,
+                        atAll: target.channelIdArr[0].atAll
+                    });
                 }
             }
             else {
-                sendArr = target.idArr;
+                sendArr = target.channelIdArr;
+            }
+            // 判断是否是直播开播推送，如果是则需要进一步判断是否需要艾特群体成员
+            if (live) {
+                // 直播开播推送，判断是否需要艾特全体成员
+                for (const channel of sendArr) {
+                    // 判断是否需要推送直播消息
+                    if (channel.live) {
+                        await this.sendMsgFunc(bot, channel.channelId, content);
+                    }
+                    // 判断是否需要艾特全体成员
+                    if (channel.atAll) {
+                        await this.sendMsgFunc(bot, channel.channelId, (0, jsx_runtime_1.jsx)("at", { type: "all" }));
+                    }
+                }
             }
-            // 循环给每个群组发送
-            for (const guild of sendArr) {
-                await this.sendMsgFunc(bot, guild, content);
+            else {
+                for (const channel of sendArr) {
+                    // 判断是否需要推送动态消息和直播消息
+                    if (channel.dynamic || channel.live) {
+                        await this.sendMsgFunc(bot, channel.channelId, content);
+                    }
+                }
             }
         }
     }
-    dynamicDetect(ctx) {
+    dynamicDetect() {
         let detectSetup = true;
         let updateBaseline;
         // 相当于锁的作用，防止上一个循环没处理完
@@ -674,7 +720,7 @@ class ComRegister {
                 // 检测启动初始化
                 if (detectSetup) {
                     // 获取动态信息
-                    const data = await ctx.ba.getAllDynamic();
+                    const data = await this.ctx.ba.getAllDynamic();
                     // 判断获取动态信息是否成功
                     if (data.code !== 0)
                         return;
@@ -690,13 +736,13 @@ class ComRegister {
                 let content;
                 try {
                     // 查询是否有新动态
-                    const data = await ctx.ba.hasNewDynamic(updateBaseline);
+                    const data = await this.ctx.ba.hasNewDynamic(updateBaseline);
                     updateNum = data.data.update_num;
                     // 没有新动态或获取动态信息失败直接返回
                     if (updateNum <= 0 || data.code !== 0)
                         return;
                     // 获取动态内容
-                    content = await ctx.ba.getAllDynamic(updateBaseline);
+                    content = await this.ctx.ba.getAllDynamic(updateBaseline);
                 }
                 catch (e) {
                     return this.logger.error('dynamicDetect getUserSpaceDynamic() 发生了错误，错误为：' + e.message);
@@ -710,7 +756,7 @@ class ComRegister {
                             // 发送私聊消息
                             await this.sendPrivateMsg('账号未登录，插件已停止工作，请登录后，输入指令 sys start 启动插件');
                             // 停止服务
-                            await ctx.sm.disposePlugin();
+                            await this.ctx.sm.disposePlugin();
                             // 结束循环
                             break;
                         }
@@ -720,7 +766,7 @@ class ComRegister {
                             // 发送私聊消息
                             await this.sendPrivateMsg('账号被风控，插件已停止工作，请确认风控解除后，输入指令 sys start 启动插件');
                             // 停止服务
-                            await ctx.sm.disposePlugin();
+                            await this.ctx.sm.disposePlugin();
                             // 结束循环
                             break;
                         }
@@ -771,7 +817,7 @@ class ComRegister {
                                 // 获取动态推送图片
                                 try {
                                     // 渲染图片
-                                    const { pic: gimgPic, buffer: gimgBuffer } = await ctx.gi.generateDynamicImg(items[num]);
+                                    const { pic: gimgPic, buffer: gimgBuffer } = await this.ctx.gi.generateDynamicImg(items[num]);
                                     // 赋值
                                     pic = gimgPic;
                                     buffer = gimgBuffer;
@@ -785,13 +831,13 @@ class ComRegister {
                                     if (e.message === '出现关键词，屏蔽该动态') {
                                         // 如果需要发送才发送
                                         if (this.config.filter.notify) {
-                                            await this.sendMsg(ctx, sub.target, `${upName}发布了一条含有屏蔽关键字的动态`);
+                                            await this.sendMsg(sub.target, `${upName}发布了一条含有屏蔽关键字的动态`);
                                         }
                                         return;
                                     }
                                     if (e.message === '已屏蔽转发动态') {
                                         if (this.config.filter.notify) {
-                                            await this.sendMsg(ctx, sub.target, `${upName}发布了一条转发动态，已屏蔽`);
+                                            await this.sendMsg(sub.target, `${upName}发布了一条转发动态，已屏蔽`);
                                         }
                                         return;
                                     }
@@ -799,7 +845,7 @@ class ComRegister {
                                     if (i === attempts - 1) {
                                         this.logger.error('dynamicDetect generateDynamicImg() 推送卡片发送失败，原因：' + e.message);
                                         // 发送私聊消息并重启服务
-                                        return await this.sendPrivateMsgAndStopService(ctx);
+                                        return await this.sendPrivateMsgAndStopService();
                                     }
                                 }
                             }
@@ -809,12 +855,12 @@ class ComRegister {
                             if (pic) {
                                 this.logger.info('推送动态中，使用render模式');
                                 // pic存在，使用的是render模式
-                                await this.sendMsg(ctx, sub.target, pic + (0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: dUrl }));
+                                await this.sendMsg(sub.target, pic + (0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: dUrl }));
                             }
                             else if (buffer) {
                                 this.logger.info('推送动态中，使用page模式');
                                 // pic不存在，说明使用的是page模式
-                                await this.sendMsg(ctx, sub.target, (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [koishi_1.h.image(buffer, 'image/png'), dUrl] }));
+                                await this.sendMsg(sub.target, (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [koishi_1.h.image(buffer, 'image/png'), dUrl] }));
                             }
                             else {
                                 this.logger.info(items[num].modules.module_author.name + '发布了一条动态，但是推送失败');
@@ -828,7 +874,7 @@ class ComRegister {
             }
         };
     }
-    debug_dynamicDetect(ctx) {
+    debug_dynamicDetect() {
         let detectSetup = true;
         let updateBaseline;
         // 相当于锁的作用，防止上一个循环没处理完
@@ -845,7 +891,7 @@ class ComRegister {
                 // 检测启动初始化
                 if (detectSetup) {
                     // 获取动态信息
-                    const data = await ctx.ba.getAllDynamic();
+                    const data = await this.ctx.ba.getAllDynamic();
                     // 判断获取动态信息是否成功
                     if (data.code !== 0)
                         return;
@@ -862,7 +908,7 @@ class ComRegister {
                 let content;
                 try {
                     // 查询是否有新动态
-                    const data = await ctx.ba.hasNewDynamic(updateBaseline);
+                    const data = await this.ctx.ba.hasNewDynamic(updateBaseline);
                     updateNum = data.data.update_num;
                     console.log(`获取是否有新动态：`);
                     console.log(data);
@@ -870,7 +916,7 @@ class ComRegister {
                     if (updateNum <= 0 || data.code !== 0)
                         return;
                     // 获取动态内容
-                    content = await ctx.ba.getAllDynamic(updateBaseline);
+                    content = await this.ctx.ba.getAllDynamic(updateBaseline);
                     console.log('获取动态内容：');
                     console.log(content.data.items[0]);
                 }
@@ -886,7 +932,7 @@ class ComRegister {
                             // 发送私聊消息
                             await this.sendPrivateMsg('账号未登录，插件已停止工作，请登录后，输入指令 sys start 启动插件');
                             // 停止服务
-                            await ctx.sm.disposePlugin();
+                            await this.ctx.sm.disposePlugin();
                             // 结束循环
                             break;
                         }
@@ -896,7 +942,7 @@ class ComRegister {
                             // 发送私聊消息
                             await this.sendPrivateMsg('账号被风控，插件已停止工作，请确认风控解除后，输入指令 sys start 启动插件');
                             // 停止服务
-                            await ctx.sm.disposePlugin();
+                            await this.ctx.sm.disposePlugin();
                             // 结束循环
                             break;
                         }
@@ -955,7 +1001,7 @@ class ComRegister {
                                 // 获取动态推送图片
                                 try {
                                     // 渲染图片
-                                    const { pic: gimgPic, buffer: gimgBuffer } = await ctx.gi.generateDynamicImg(items[num]);
+                                    const { pic: gimgPic, buffer: gimgBuffer } = await this.ctx.gi.generateDynamicImg(items[num]);
                                     // 赋值
                                     pic = gimgPic;
                                     buffer = gimgBuffer;
@@ -969,13 +1015,13 @@ class ComRegister {
                                     if (e.message === '出现关键词，屏蔽该动态') {
                                         // 如果需要发送才发送
                                         if (this.config.filter.notify) {
-                                            await this.sendMsg(ctx, sub.target, `${upName}发布了一条含有屏蔽关键字的动态`);
+                                            await this.sendMsg(sub.target, `${upName}发布了一条含有屏蔽关键字的动态`);
                                         }
                                         return;
                                     }
                                     if (e.message === '已屏蔽转发动态') {
                                         if (this.config.filter.notify) {
-                                            await this.sendMsg(ctx, sub.target, `${upName}发布了一条转发动态，已屏蔽`);
+                                            await this.sendMsg(sub.target, `${upName}发布了一条转发动态，已屏蔽`);
                                         }
                                         return;
                                     }
@@ -983,7 +1029,7 @@ class ComRegister {
                                     if (i === attempts - 1) {
                                         this.logger.error('dynamicDetect generateDynamicImg() 推送卡片发送失败，原因：' + e.message);
                                         // 发送私聊消息并重启服务
-                                        return await this.sendPrivateMsgAndStopService(ctx);
+                                        return await this.sendPrivateMsgAndStopService();
                                     }
                                 }
                             }
@@ -993,12 +1039,12 @@ class ComRegister {
                             if (pic) {
                                 this.logger.info('推送动态中，使用render模式');
                                 // pic存在，使用的是render模式
-                                await this.sendMsg(ctx, sub.target, pic + (0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: dUrl }));
+                                await this.sendMsg(sub.target, pic + (0, jsx_runtime_1.jsx)(jsx_runtime_1.Fragment, { children: dUrl }));
                             }
                             else if (buffer) {
                                 this.logger.info('推送动态中，使用page模式');
                                 // pic不存在，说明使用的是page模式
-                                await this.sendMsg(ctx, sub.target, (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [koishi_1.h.image(buffer, 'image/png'), dUrl] }));
+                                await this.sendMsg(sub.target, (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [koishi_1.h.image(buffer, 'image/png'), dUrl] }));
                             }
                             else {
                                 this.logger.info(items[num].modules.module_author.name + '发布了一条动态，但是推送失败');
@@ -1012,203 +1058,272 @@ class ComRegister {
             }
         };
     }
-    liveDetect(ctx, roomId, target) {
+    // 定义发送直播通知卡片方法
+    async sendLiveNotifyCard(info, liveType, liveNotifyMsg) {
+        // 定义变量
+        let pic;
+        let buffer;
+        // 多次尝试生成图片
+        const attempts = 3;
+        for (let i = 0; i < attempts; i++) {
+            try {
+                // 获取直播通知卡片
+                const { pic: picv, buffer: bufferv } = await this.ctx.gi.generateLiveImg(info.data, info.username, info.userface, liveType);
+                // 赋值
+                pic = picv;
+                buffer = bufferv;
+                // 成功则跳出循环
+                break;
+            }
+            catch (e) {
+                if (i === attempts - 1) { // 已尝试三次
+                    this.logger.error('liveDetect generateLiveImg() 推送卡片生成失败，原因：' + e.message);
+                    // 发送私聊消息并重启服务
+                    return await this.sendPrivateMsgAndStopService();
+                }
+            }
+        }
+        // 推送直播信息
+        // pic 存在，使用的是render模式
+        if (pic) {
+            // 只有在开播时才艾特全体成员
+            if (liveType === LiveType.StartBroadcasting) {
+                return await this.sendMsg(info.target, pic + (liveNotifyMsg ?? ''), true);
+            }
+            // 正常不需要艾特全体成员
+            return await this.sendMsg(info.target, pic + (liveNotifyMsg ?? ''));
+        }
+        // pic不存在，说明使用的是page模式
+        const msg = (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [koishi_1.h.image(buffer, 'image/png'), liveNotifyMsg || ''] });
+        // 只有在开播时才艾特全体成员
+        if (liveType === LiveType.StartBroadcasting) {
+            return await this.sendMsg(info.target, msg, true);
+        }
+        // 正常不需要艾特全体成员
+        return await this.sendMsg(info.target, msg);
+    }
+    // 定义获取主播信息方法
+    async useMasterInfo(uid) {
+        const { data } = await this.ctx.ba.getMasterInfo(uid);
+        return { username: data.info.uname, userface: data.info.face, roomId: data.room_id };
+    }
+    async useLiveRoomInfo(roomId) {
+        // 发送请求获取直播间信息
+        let content;
+        const attempts = 3;
+        for (let i = 0; i < attempts; i++) {
+            try {
+                // 发送请求获取room信息
+                content = await this.ctx.ba.getLiveRoomInfo(roomId);
+                // 成功则跳出循环
+                break;
+            }
+            catch (e) {
+                this.logger.error('liveDetect getLiveRoomInfo 发生了错误，错误为：' + e.message);
+                if (i === attempts - 1) { // 已尝试三次
+                    // 发送私聊消息并重启服务
+                    return await this.sendPrivateMsgAndStopService();
+                }
+            }
+        }
+        return content.data;
+    }
+    async liveDetectWithAPI() {
+        // 定义变量：第一次订阅
         let firstSubscription = true;
+        // 定义变量：timer计时器
         let timer = 0;
-        let open = false;
-        let liveTime;
-        let username;
-        let userface;
         // 相当于锁的作用，防止上一个循环没处理完
         let flag = true;
-        // 定义发送直播通知卡片方法
-        const sendLiveNotifyCard = async (data, liveType, liveNotifyMsg, atAll) => {
-            // 定义变量
-            let pic;
-            let buffer;
-            // 多次尝试生成图片
+        // 定义订阅对象Record 0未开播 1正在直播 2轮播中
+        const liveRecord = {};
+        // 初始化subRecord
+        this.subManager.forEach(sub => {
+            // 判断是否订阅直播
+            if (sub.live) {
+                // 将该订阅添加到subRecord中
+                liveRecord[sub.uid] = { liveStatus: 0, liveTime: '', target: sub.target };
+            }
+        });
+        // 定义函数: 发送请求获取直播状态
+        const useLiveStatus = async (roomId) => {
+            let content;
             const attempts = 3;
             for (let i = 0; i < attempts; i++) {
                 try {
-                    // 获取直播通知卡片
-                    const { pic: picv, buffer: bufferv } = await ctx.gi.generateLiveImg(data, username, userface, liveType);
-                    // 赋值
-                    pic = picv;
-                    buffer = bufferv;
+                    // 发送请求获取room信息
+                    content = await this.ctx.ba.getLiveRoomInfo(roomId);
                     // 成功则跳出循环
                     break;
                 }
                 catch (e) {
+                    this.logger.error('liveDetect getLiveRoomInfo 发生了错误，错误为：' + e.message);
                     if (i === attempts - 1) { // 已尝试三次
-                        this.logger.error('liveDetect generateLiveImg() 推送卡片生成失败，原因：' + e.message);
                         // 发送私聊消息并重启服务
-                        return await this.sendPrivateMsgAndStopService(ctx);
+                        return await this.sendPrivateMsgAndStopService();
                     }
                 }
             }
-            // 推送直播信息
-            // pic 存在，使用的是render模式
-            if (pic) {
-                const msg = (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [atAll && (0, jsx_runtime_1.jsx)("at", { type: "all" }), liveNotifyMsg && liveNotifyMsg] });
-                return await this.sendMsg(ctx, target, pic + msg);
-            }
-            // pic不存在，说明使用的是page模式
-            const msg = (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [koishi_1.h.image(buffer, 'image/png'), atAll && (0, jsx_runtime_1.jsx)("at", { type: "all" }), liveNotifyMsg && liveNotifyMsg] });
-            await this.sendMsg(ctx, target, pic + msg);
+            // 返回data
+            return content.data;
         };
-        // 定义获取主播信息方法
-        let useMasterInfo;
-        if (this.config.changeMasterInfoApi) {
-            useMasterInfo = async (uid) => {
-                const { data } = await ctx.ba.getUserInfo(uid);
-                username = data.name;
-                userface = data.face;
-            };
-        }
-        else {
-            useMasterInfo = async (uid) => {
-                const { data: { info } } = await ctx.ba.getMasterInfo(uid);
-                username = info.uname;
-                userface = info.face;
-            };
-        }
         return async () => {
             // 如果flag为false则说明前面的代码还未执行完，则直接返回
             if (!flag)
                 return;
+            // 将标志位置为false
             flag = false;
-            // 无论是否执行成功都要释放锁
             try {
-                // 发送请求检测直播状态
-                let content;
-                const attempts = 3;
-                for (let i = 0; i < attempts; i++) {
-                    try {
-                        // 发送请求获取room信息
-                        content = await ctx.ba.getLiveRoomInfo(roomId);
-                        // 成功则跳出循环
-                        break;
-                    }
-                    catch (e) {
-                        this.logger.error('liveDetect getLiveRoomInfo 发生了错误，错误为：' + e.message);
-                        if (i === attempts - 1) { // 已尝试三次
-                            // 发送私聊消息并重启服务
-                            return await this.sendPrivateMsgAndStopService(ctx);
-                        }
-                    }
-                }
-                const { data } = content;
+                // 获取正在直播对象
+                const liveUsers = await this.ctx.ba.getTheUserWhoIsLiveStreaming();
                 // 判断是否是第一次订阅
                 if (firstSubscription) {
+                    // 将第一次订阅置为false
                     firstSubscription = false;
-                    // 获取主播信息
-                    const attempts = 3;
-                    for (let i = 0; i < attempts; i++) {
-                        try {
-                            // 发送请求获取主播信息
-                            await useMasterInfo(data.uid);
-                            // 成功则跳出循环
-                            break;
-                        }
-                        catch (e) {
-                            this.logger.error('liveDetect getMasterInfo() 发生了错误，错误为：' + e.message);
-                            if (i === attempts - 1) { // 已尝试三次
-                                // 发送私聊消息并重启服务
-                                return await this.sendPrivateMsgAndStopService(ctx);
+                    // 先判断是否有UP主正在直播
+                    if (liveUsers.count > 0) {
+                        // 遍历liveUsers
+                        liveUsers.items.forEach(async (item) => {
+                            // 判断是否有订阅对象正在直播
+                            if (liveRecord[item.mid]) {
+                                // 获取当前用户直播间信息
+                                const data = await useLiveStatus(item.room_id.toString());
+                                // 设置开播时间
+                                liveRecord[item.mid].liveTime = data.live_time;
+                                // 设置直播中消息
+                                const liveMsg = this.config.customLive ? this.config.customLive
+                                    .replace('-name', item.uname)
+                                    .replace('-time', await this.ctx.gi.getTimeDifference(liveRecord[item.mid].liveTime))
+                                    .replace('-link', `https://live.bilibili.com/${data.short_id === 0 ? data.room_id : data.short_id}`) : null;
+                                // 发送直播通知卡片
+                                if (this.config.restartPush)
+                                    this.sendLiveNotifyCard({
+                                        username: item.uname,
+                                        userface: item.face,
+                                        target: liveRecord[item.mid].target,
+                                        data
+                                    }, LiveType.LiveBroadcast, liveMsg);
+                                // 改变开播状态
+                                liveRecord[item.mid].liveStatus = 1;
                             }
-                        }
+                        });
                     }
-                    // 判断直播状态
-                    if (data.live_status === 1) { // 当前正在直播
-                        // 设置开播时间
-                        liveTime = data.live_time;
-                        // 发送直播通知卡片
-                        if (this.config.restartPush)
-                            sendLiveNotifyCard(data, LiveType.LiveBroadcast);
-                        // 改变开播状态
-                        open = true;
-                    } // 未开播，直接返回
+                    // 没有正在直播的订阅对象，直接返回
                     return;
                 }
-                // 检查直播状态
-                switch (data.live_status) {
-                    case 0:
-                    case 2: { // 状态 0 和 2 说明未开播
-                        if (open) { // 之前开播，现在下播了
-                            // 更改直播状态
-                            open = false;
-                            // 下播了将定时器清零
-                            timer = 0;
-                            // 定义下播通知消息
-                            const liveEndMsg = this.config.customLiveEnd
-                                .replace('-name', username)
-                                .replace('-time', await ctx.gi.getTimeDifference(liveTime));
-                            // 更改直播时长
-                            data.live_time = liveTime;
-                            // 发送@全体成员通知
-                            await sendLiveNotifyCard(data, LiveType.StopBroadcast, liveEndMsg);
-                        }
-                        // 未进循环，还未开播，继续循环
-                        break;
-                    }
-                    case 1: {
-                        if (!open) { // 之前未开播，现在开播了
-                            // 更改直播状态
-                            open = true;
-                            // 设置开播时间
-                            liveTime = data.live_time;
-                            // 获取主播信息
-                            const attempts = 3;
-                            for (let i = 0; i < attempts; i++) {
-                                try {
-                                    // 主播信息不会变，开播时刷新一次即可
-                                    // 发送请求获取主播信息
-                                    await useMasterInfo(data.uid);
-                                    // 成功则跳出循环
+                // 获取当前订阅直播的数量
+                const currentLiveSubs = this.subManager.filter(sub => sub.live);
+                // 获取当前liveRecord里的订阅数量
+                const currentLiveRecordKeys = Object.keys(liveRecord);
+                // 判断是否能匹配双方数量
+                if (currentLiveRecordKeys.length < currentLiveSubs.length) {
+                    // 遍历currentLiveSubs
+                    for (const sub of currentLiveSubs) {
+                        // 判断liveRecord中缺少了哪些订阅
+                        if (!liveRecord[sub.uid]) {
+                            // 获取当前用户直播间信息
+                            const data = await useLiveStatus(sub.roomId.toString());
+                            switch (data.live_status) {
+                                case 0:
+                                case 2: { // 未开播
+                                    // 添加到liveRecord中
+                                    liveRecord[sub.uid] = { liveStatus: 0, liveTime: '', target: sub.target };
+                                    // break
                                     break;
                                 }
-                                catch (e) {
-                                    this.logger.error('liveDetect open getMasterInfo() 发生了错误，错误为：' + e.message);
-                                    if (i === attempts - 1) { // 已尝试三次
-                                        // 发送私聊消息并重启服务
-                                        return await this.sendPrivateMsgAndStopService(ctx);
-                                    }
+                                case 1: { //正在直播
+                                    // 添加到liveRecord中
+                                    liveRecord[sub.uid] = { liveStatus: 1, liveTime: data.live_time, target: sub.target };
                                 }
                             }
-                            // 定义开播通知语
-                            const liveStartMsg = this.config.customLiveStart
-                                .replace('-name', username)
-                                .replace('-time', await ctx.gi.getTimeDifference(liveTime))
-                                .replace('-link', `https://live.bilibili.com/${data.short_id === 0 ? data.room_id : data.short_id}`);
-                            // 判断是否需要@全体成员
-                            if (this.config.liveStartAtAll) {
-                                // 发送@全体成员通知
-                                await sendLiveNotifyCard(data, LiveType.StartBroadcasting, liveStartMsg, true);
-                            }
-                            else {
+                        }
+                    }
+                }
+                if (currentLiveRecordKeys.length > currentLiveSubs.length) {
+                    // 创建Set
+                    const setCurrentLiveSubs = new Set(currentLiveSubs.map(sub => sub.uid));
+                    // 找出 currentLiveRecordKeys中比currentLiveSubs 多的元素
+                    const extraInCurrentLiveSubs = currentLiveRecordKeys.filter(key => !setCurrentLiveSubs.has(key));
+                    // 遍历 extraInCurrentLiveSubs 
+                    for (const subUID of extraInCurrentLiveSubs) {
+                        // 删除记录
+                        delete liveRecord[subUID];
+                    }
+                }
+                // 数量没有差异，则不进行其他操作
+                // 遍历liveUsers
+                liveUsers.items.forEach(async (item) => {
+                    // 判断是否有正在直播的订阅对象
+                    if (liveRecord[item.mid]) { // 有正在直播的订阅对象
+                        // 获取当前用户直播间信息
+                        const data = await useLiveStatus(item.room_id.toString());
+                        // 判断开播状态
+                        switch (liveRecord[item.mid].liveStatus) {
+                            case 0: { // 之前未开播，现在开播了
+                                // 设置开播时间
+                                liveRecord[item.mid].liveTime = data.live_time;
+                                // 定义开播通知语                            
+                                const liveStartMsg = this.config.customLiveStart ? this.config.customLiveStart
+                                    .replace('-name', item.uname)
+                                    .replace('-time', await this.ctx.gi.getTimeDifference(liveRecord[item.mid].liveTime))
+                                    .replace('-link', `https://live.bilibili.com/${data.short_id === 0 ? data.room_id : data.short_id}`) : null;
                                 // 发送直播通知卡片
-                                await sendLiveNotifyCard(data, LiveType.StartBroadcasting, liveStartMsg);
+                                await this.sendLiveNotifyCard({
+                                    username: item.uname,
+                                    userface: item.face,
+                                    target: liveRecord[item.mid].target,
+                                    data
+                                }, LiveType.LiveBroadcast, liveStartMsg);
+                                // 改变开播状态
+                                liveRecord[item.mid].liveStatus = 1;
+                                // 结束
+                                break;
                             }
-                        }
-                        else { // 还在直播
-                            if (this.config.pushTime > 0) {
-                                timer++;
-                                // 开始记录时间
-                                if (timer >= (6 * 60 * this.config.pushTime)) { // 到时间推送直播消息
-                                    // 到时间重新计时
-                                    timer = 0;
-                                    // 定义直播中通知消息
-                                    const liveMsg = this.config.customLive ? this.config.customLive
-                                        .replace('-name', username)
-                                        .replace('-time', await ctx.gi.getTimeDifference(liveTime))
-                                        .replace('-link', `https://live.bilibili.com/${data.short_id === 0 ? data.room_id : data.short_id}`) : '';
-                                    // 发送直播通知卡片
-                                    sendLiveNotifyCard(data, LiveType.LiveBroadcast, liveMsg);
+                            case 1: { // 仍在直播
+                                if (this.config.pushTime > 0) {
+                                    timer++;
+                                    // 开始记录时间
+                                    if (timer >= (6 * 60 * this.config.pushTime)) { // 到时间推送直播消息
+                                        // 到时间重新计时
+                                        timer = 0;
+                                        // 定义直播中通知消息
+                                        const liveMsg = this.config.customLive ? this.config.customLive
+                                            .replace('-name', item.uname)
+                                            .replace('-time', await this.ctx.gi.getTimeDifference(liveRecord[item.mid].liveTime))
+                                            .replace('-link', `https://live.bilibili.com/${data.short_id === 0 ? data.room_id : data.short_id}`) : null;
+                                        // 发送直播通知卡片
+                                        this.sendLiveNotifyCard({
+                                            username: item.uname,
+                                            userface: item.face,
+                                            target: liveRecord[item.mid].target,
+                                            data
+                                        }, LiveType.LiveBroadcast, liveMsg);
+                                    }
                                 }
                             }
-                            // 否则继续循环
                         }
                     }
+                });
+                // 找出liveRecord中liveStatus为1但liveUsers中没有的元素
+                const extraInLiveRecord = currentLiveRecordKeys.filter(key => !liveUsers.items.some(item => item.mid === Number(key)));
+                // 遍历 extraInLiveRecord
+                for (const subUID of extraInLiveRecord) { // 下播的主播
+                    // 获取主播信息
+                    const masterInfo = await this.useMasterInfo(subUID);
+                    // 获取直播间消息
+                    const liveRoomInfo = await this.useLiveRoomInfo(masterInfo.roomId.toString());
+                    // 定义下播播通知语                            
+                    const liveEndMsg = this.config.customLiveEnd ? this.config.customLiveEnd
+                        .replace('-name', masterInfo.username)
+                        .replace('-time', await this.ctx.gi.getTimeDifference(liveRecord[subUID].liveTime))
+                        .replace('-link', `https://live.bilibili.com/${liveRoomInfo.short_id === 0 ? liveRoomInfo.room_id : liveRoomInfo.short_id}`) : null;
+                    // 发送下播通知
+                    this.sendLiveNotifyCard({
+                        username: masterInfo.username,
+                        userface: masterInfo.userface,
+                        target: liveRecord[subUID].target,
+                        data: liveRoomInfo
+                    }, LiveType.StopBroadcast, liveEndMsg);
                 }
             }
             finally {
@@ -1217,6 +1332,150 @@ class ComRegister {
             }
         };
     }
+    async liveDetectWithListener(roomId, target) {
+        // 定义开播时间
+        let liveTime;
+        // 定义定时推送定时器
+        let pushAtTimeTimer;
+        // 定义弹幕存放数组
+        const currentLiveDanmakuArr = [];
+        const temporaryLiveDanmakuArr = [];
+        // 处理target
+        // 找到频道/群组对应的
+        const newTarget = target.map(channel => {
+            const liveDanmakuArr = channel.channelIdArr.filter(channelId => channelId.liveDanmaku);
+            return {
+                channelIdArr: liveDanmakuArr,
+                platform: channel.platform
+            };
+        });
+        // 定义定时推送函数
+        const pushAtTimeFunc = async () => {
+            // 获取直播间信息
+            const liveRoomInfo = await this.useLiveRoomInfo(roomId);
+            // 获取主播信息
+            const masterInfo = await this.useMasterInfo(liveRoomInfo.uid);
+            // 定义直播中通知消息
+            const liveMsg = this.config.customLive ? this.config.customLive
+                .replace('-name', masterInfo.username)
+                .replace('-time', await this.ctx.gi.getTimeDifference(liveTime))
+                .replace('-link', `https://live.bilibili.com/${liveRoomInfo.short_id === 0 ? liveRoomInfo.room_id : liveRoomInfo.short_id}`) : null;
+            // 发送直播通知卡片
+            await this.sendLiveNotifyCard({
+                username: masterInfo.username,
+                userface: masterInfo.userface,
+                target: newTarget,
+                data: liveRoomInfo
+            }, LiveType.LiveBroadcast, liveMsg);
+        };
+        // 定义弹幕推送函数
+        const danmakuPushFunc = () => {
+            // 判断数组是否有内容
+            if (temporaryLiveDanmakuArr.length > 0) {
+                // 发送消息
+                this.sendMsg(newTarget, temporaryLiveDanmakuArr.join('\n'));
+                // 将临时消息数组清空
+                temporaryLiveDanmakuArr.length = 0;
+            }
+        };
+        // 获取直播间信息
+        const liveRoomInfo = await this.useLiveRoomInfo(roomId);
+        // 获取主播信息
+        const masterInfo = await this.useMasterInfo(liveRoomInfo.uid);
+        // 构建消息处理函数
+        const handler = {
+            onOpen: () => {
+                this.logger.info('直播间连接成功');
+            },
+            onClose: () => {
+                this.logger.info('直播间连接已断开');
+            },
+            onIncomeDanmu: ({ body }) => {
+                // 处理消息，只需要UP主名字和消息内容
+                const content = `【${masterInfo.username}的直播间】${body.user.uname}：${body.content}`;
+                // 保存消息到数组
+                currentLiveDanmakuArr.push(body.content);
+                temporaryLiveDanmakuArr.push(content);
+            },
+            onIncomeSuperChat: ({ body }) => {
+                // 处理SC消息
+                const content = `【${masterInfo.username}的直播间】${body.user.uname}发送了一条SC：${body.content}`;
+                // 保存消息到数组
+                currentLiveDanmakuArr.push(body.content);
+                temporaryLiveDanmakuArr.push(content);
+            },
+            onGuardBuy: ({ body }) => {
+                const content = `【${masterInfo.username}的直播间】${body.user.uname}加入了大航海（${body.gift_name}）`;
+                // 保存消息到数组
+                currentLiveDanmakuArr.push(content);
+                temporaryLiveDanmakuArr.push(content);
+            },
+            onLiveStart: async () => {
+                // 获取直播间信息
+                const liveRoomInfo = await this.useLiveRoomInfo(roomId);
+                // 获取主播信息
+                const masterInfo = await this.useMasterInfo(liveRoomInfo.uid);
+                // 定义下播通知消息
+                const liveEndMsg = this.config.customLiveEnd ? this.config.customLiveEnd
+                    .replace('-name', masterInfo.username)
+                    .replace('-time', await this.ctx.gi.getTimeDifference(liveTime)) : null;
+                // 更改直播时长
+                liveRoomInfo.live_time = liveTime;
+                // 推送下播通知
+                await this.sendLiveNotifyCard({
+                    username: masterInfo.username,
+                    userface: masterInfo.userface,
+                    target: newTarget,
+                    data: liveRoomInfo
+                }, LiveType.StopBroadcast, liveEndMsg);
+            },
+            onLiveEnd: async () => {
+                // 获取直播间消息
+                const liveRoomInfo = await this.useLiveRoomInfo(roomId);
+                // 获取主播信息
+                const masterInfo = await this.useMasterInfo(liveRoomInfo.uid);
+                // 关闭定时推送定时器
+                pushAtTimeTimer();
+                // 将推送定时器变量置空
+                pushAtTimeTimer = null;
+                // 定义下播播通知语                            
+                const liveEndMsg = this.config.customLiveEnd ? this.config.customLiveEnd
+                    .replace('-name', masterInfo.username)
+                    .replace('-time', await this.ctx.gi.getTimeDifference(liveTime))
+                    .replace('-link', `https://live.bilibili.com/${liveRoomInfo.short_id === 0 ? liveRoomInfo.room_id : liveRoomInfo.short_id}`) : null;
+                // 推送通知卡片
+                await this.sendLiveNotifyCard({
+                    username: masterInfo.username,
+                    userface: masterInfo.userface,
+                    target: newTarget,
+                    data: liveRoomInfo
+                }, LiveType.StartBroadcasting, liveEndMsg);
+            }
+        };
+        // 启动直播间弹幕监测
+        this.ctx.bl.startLiveRoomListener(roomId, handler, danmakuPushFunc);
+        // 判断直播状态
+        if (liveRoomInfo.live_status === 1) {
+            // 设置开播时间
+            liveTime = liveRoomInfo.live_time;
+            // 定义直播中通知消息
+            const liveMsg = this.config.customLive ? this.config.customLive
+                .replace('-name', masterInfo.username)
+                .replace('-time', await this.ctx.gi.getTimeDifference(liveTime))
+                .replace('-link', `https://live.bilibili.com/${liveRoomInfo.short_id === 0 ? liveRoomInfo.room_id : liveRoomInfo.short_id}`) : null;
+            // 发送直播通知卡片
+            if (this.config.restartPush) {
+                await this.sendLiveNotifyCard({
+                    username: masterInfo.username,
+                    userface: masterInfo.userface,
+                    target: newTarget,
+                    data: liveRoomInfo
+                }, LiveType.LiveBroadcast, liveMsg);
+            }
+            // 正在直播，开启定时器
+            pushAtTimeTimer = this.ctx.setInterval(pushAtTimeFunc, this.config.pushTime * 1000 * 60 * 60);
+        }
+    }
     subShow() {
         // 在控制台中显示订阅对象
         let table = ``;
@@ -1255,7 +1514,7 @@ class ComRegister {
         // 只订阅动态
         return [false, true];
     }
-    updateSubNotifier(ctx) {
+    updateSubNotifier() {
         // 更新控制台提示
         if (this.subNotifier)
             this.subNotifier.dispose();
@@ -1274,13 +1533,13 @@ class ComRegister {
             table = (0, jsx_runtime_1.jsxs)(jsx_runtime_1.Fragment, { children: [(0, jsx_runtime_1.jsx)("p", { children: "\u5F53\u524D\u8BA2\u9605\u5BF9\u8C61\uFF1A" }), (0, jsx_runtime_1.jsx)("ul", { children: subTableArray.map(str => ((0, jsx_runtime_1.jsx)("li", { children: str }))) })] });
         }
         // 设置更新后的提示
-        this.subNotifier = ctx.notifier.create(table);
+        this.subNotifier = this.ctx.notifier.create(table);
     }
-    async checkIfLoginInfoIsLoaded(ctx) {
+    async checkIfLoginInfoIsLoaded() {
         return new Promise(resolve => {
             const check = () => {
-                if (!ctx.ba.getLoginInfoIsLoaded()) {
-                    ctx.setTimeout(check, 500);
+                if (!this.ctx.ba.getLoginInfoIsLoaded()) {
+                    this.ctx.setTimeout(check, 500);
                 }
                 else {
                     resolve('success');
@@ -1289,17 +1548,17 @@ class ComRegister {
             check();
         });
     }
-    async subUserInBili(ctx, mid) {
+    async subUserInBili(mid) {
         // 获取关注分组信息
         const checkGroupIsReady = async () => {
             // 判断是否有数据
             if (this.loginDBData.dynamic_group_id === '' || this.loginDBData.dynamic_group_id === null) {
                 // 没有数据，没有创建分组，尝试创建分组
-                const createGroupData = await ctx.ba.createGroup("订阅");
+                const createGroupData = await this.ctx.ba.createGroup("订阅");
                 // 如果分组已创建，则获取分组id
                 if (createGroupData.code === 22106) {
                     // 分组已存在，拿到之前的分组id
-                    const allGroupData = await ctx.ba.getAllGroup();
+                    const allGroupData = await this.ctx.ba.getAllGroup();
                     // 遍历所有分组
                     for (const group of allGroupData.data) {
                         // 找到订阅分组
@@ -1317,7 +1576,7 @@ class ComRegister {
                     return false;
                 }
                 // 创建成功，保存到数据库
-                ctx.database.set('loginBili', 1, { dynamic_group_id: this.loginDBData.dynamic_group_id });
+                this.ctx.database.set('loginBili', 1, { dynamic_group_id: this.loginDBData.dynamic_group_id });
                 // 创建成功
                 return true;
             }
@@ -1331,7 +1590,7 @@ class ComRegister {
             return { flag: false, msg: '创建分组失败，请尝试重启插件' };
         }
         // 获取分组明细
-        const relationGroupDetailData = await ctx.ba.getRelationGroupDetail(this.loginDBData.dynamic_group_id);
+        const relationGroupDetailData = await this.ctx.ba.getRelationGroupDetail(this.loginDBData.dynamic_group_id);
         // 判断分组信息是否获取成功
         if (relationGroupDetailData.code !== 0) {
             if (relationGroupDetailData.code === 22104) {
@@ -1356,7 +1615,7 @@ class ComRegister {
             }
         });
         // 订阅对象
-        const subUserData = await ctx.ba.follow(mid);
+        const subUserData = await this.ctx.ba.follow(mid);
         // 判断是否订阅成功
         switch (subUserData.code) {
             case -101: return { flag: false, msg: '账号未登录，请使用指令bili login登录后再进行订阅操作' };
@@ -1369,7 +1628,7 @@ class ComRegister {
             case 22014: // 已关注订阅对象 无需再次关注
             case 0: { // 执行订阅成功
                 // 把订阅对象添加到分组中
-                const copyUserToGroupData = await ctx.ba.copyUserToGroup(mid, this.loginDBData.dynamic_group_id);
+                const copyUserToGroupData = await this.ctx.ba.copyUserToGroup(mid, this.loginDBData.dynamic_group_id);
                 // 判断是否添加成功
                 if (copyUserToGroupData.code !== 0) {
                     // 添加失败
@@ -1380,11 +1639,68 @@ class ComRegister {
         // 订阅成功
         return { flag: true, msg: '用户订阅成功' };
     }
-    async getSubFromDatabase(ctx) {
+    async loadSubFromConfig(subs) {
+        for (const sub of subs) {
+            // 定义Data
+            let data;
+            // 判断是否需要订阅直播
+            if (sub.live) {
+                // 获取用户信息
+                let content;
+                // 设置重试次数
+                const attempts = 3;
+                for (let i = 0; i < attempts; i++) {
+                    try {
+                        // 获取用户信息
+                        content = await this.ctx.ba.getUserInfo(sub.uid);
+                        // 成功则跳出循环
+                        break;
+                    }
+                    catch (e) {
+                        this.logger.error('getSubFromDatabase() getUserInfo() 发生了错误，错误为：' + e.message);
+                        if (i === attempts - 1) { // 已尝试三次
+                            // 发送私聊消息并重启服务
+                            return await this.sendPrivateMsgAndStopService();
+                        }
+                    }
+                }
+                // 获取data
+                data = content.data;
+                // 检查roomid是否存在
+                if (!data.live_room) {
+                    // 用户没有开通直播间，无法订阅直播
+                    sub.live = false;
+                    // 发送提示
+                    this.logger.warn(`UID:${sub.uid} 用户没有开通直播间，无法订阅直播！`);
+                }
+                // 判断是否订阅直播
+                if (sub.live) {
+                    // 订阅直播
+                    this.liveDetectWithListener(data.live_room.roomid, sub.target);
+                }
+            }
+            // 在B站中订阅该对象
+            const subInfo = await this.subUserInBili(sub.uid);
+            // 判断订阅是否成功
+            if (!subInfo.flag)
+                this.logger.warn(subInfo.msg);
+            // 将该订阅添加到sm中
+            this.subManager.push({
+                id: +sub.uid,
+                uid: sub.uid,
+                roomId: sub.live ? data.live_room.roomid : '',
+                target: sub.target,
+                platform: '',
+                live: sub.live,
+                dynamic: sub.dynamic
+            });
+        }
+    }
+    async loadSubFromDatabase() {
         // 判断登录信息是否已加载完毕
-        await this.checkIfLoginInfoIsLoaded(ctx);
+        await this.checkIfLoginInfoIsLoaded();
         // 如果未登录，则直接返回
-        if (!(await this.checkIfIsLogin(ctx))) {
+        if (!(await this.checkIfIsLogin())) {
             // log
             this.logger.info(`账号未登录，请登录`);
             return;
@@ -1393,7 +1709,7 @@ class ComRegister {
         if (this.subManager.length !== 0)
             return;
         // 从数据库中获取数据
-        const subData = await ctx.database.get('bilibili', { id: { $gt: 0 } });
+        const subData = await this.ctx.database.get('bilibili', { id: { $gt: 0 } });
         // 定义变量：订阅直播数
         let liveSubNum = 0;
         // 循环遍历
@@ -1401,14 +1717,14 @@ class ComRegister {
             // 判断是否存在没有任何订阅的数据
             if (!sub.dynamic && !sub.live) { // 存在未订阅任何项目的数据
                 // 删除该条数据
-                ctx.database.remove('bilibili', { id: sub.id });
+                this.ctx.database.remove('bilibili', { id: sub.id });
                 // log
                 this.logger.warn(`UID:${sub.uid} 该条数据没有任何订阅数据，自动取消订阅`);
                 // 跳过下面的步骤
                 continue;
             }
             // 判断用户是否在B站中订阅了
-            const subUserData = await this.subUserInBili(ctx, sub.uid);
+            const subUserData = await this.subUserInBili(sub.uid);
             // 判断是否订阅
             if (!subUserData.flag) {
                 // log
@@ -1416,7 +1732,7 @@ class ComRegister {
                 // 发送私聊消息
                 await this.sendPrivateMsg(`UID:${sub.uid} ${subUserData.msg}，自动取消订阅`);
                 // 删除该条数据
-                await ctx.database.remove('bilibili', { id: sub.id });
+                await this.ctx.database.remove('bilibili', { id: sub.id });
                 // 跳过下面的步骤
                 continue;
             }
@@ -1429,7 +1745,7 @@ class ComRegister {
             for (let i = 0; i < attempts; i++) {
                 try {
                     // 获取用户信息
-                    content = await ctx.ba.getUserInfo(sub.uid);
+                    content = await this.ctx.ba.getUserInfo(sub.uid);
                     // 成功则跳出循环
                     break;
                 }
@@ -1437,7 +1753,7 @@ class ComRegister {
                     this.logger.error('getSubFromDatabase() getUserInfo() 发生了错误，错误为：' + e.message);
                     if (i === attempts - 1) { // 已尝试三次
                         // 发送私聊消息并重启服务
-                        return await this.sendPrivateMsgAndStopService(ctx);
+                        return await this.sendPrivateMsgAndStopService();
                     }
                 }
             }
@@ -1446,7 +1762,7 @@ class ComRegister {
             // 定义函数删除数据和发送提示
             const deleteSub = async () => {
                 // 从数据库删除该条数据
-                await ctx.database.remove('bilibili', { id: sub.id });
+                await this.ctx.database.remove('bilibili', { id: sub.id });
                 // 给用户发送提示
                 await this.sendPrivateMsg(`UID:${sub.uid} 数据库内容被篡改，已取消对该UP主的订阅`);
             };
@@ -1478,6 +1794,7 @@ class ComRegister {
                 this.logger.info(`UID:${sub.uid} 房间号被篡改，自动取消订阅`);
                 // Send msg
                 await this.sendPrivateMsg(`UID:${sub.uid} 房间号被篡改，自动取消订阅`);
+                // 直接返回
                 return;
             }
             // 构建订阅对象
@@ -1487,46 +1804,47 @@ class ComRegister {
                 roomId: sub.room_id,
                 target,
                 platform: sub.platform,
-                live: +sub.live === 1 ? true : false,
-                dynamic: +sub.dynamic === 1 ? true : false,
+                live: sub.live === 1 ? true : false,
+                dynamic: sub.dynamic === 1 ? true : false,
                 liveDispose: null
             };
             // 判断是否订阅直播
             if (sub.live) {
                 // 判断订阅直播数是否超过限制
                 if (!this.config.unlockSubLimits && liveSubNum >= 3) {
+                    // 将live改为false
                     subManagerItem.live = false;
                     // log
                     this.logger.warn(`UID:${sub.uid} 订阅直播数超过限制，自动取消订阅`);
                     // 发送错误消息
-                    this.sendPrivateMsg(`UID:${sub.uid} 订阅直播数超过限制，自动取消订阅`);
+                    await this.sendPrivateMsg(`UID:${sub.uid} 订阅直播数超过限制，自动取消订阅`);
                 }
                 else {
                     // 直播订阅数+1
                     liveSubNum++;
                     // 订阅直播，开始循环检测
-                    const dispose = ctx.setInterval(this.liveDetect(ctx, sub.room_id, target), this.config.liveLoopTime * 1000);
-                    // 保存销毁函数
-                    subManagerItem.liveDispose = dispose;
+                    this.liveDetectWithListener(sub.room_id, target);
                 }
             }
             // 保存新订阅对象
             this.subManager.push(subManagerItem);
         }
+    }
+    checkIfDynamicDetectIsNeeded() {
         // 检查是否有订阅对象需要动态监测
-        if (this.subManager.some(sub => sub.dynamic)) {
-            // 开始动态监测
-            if (this.config.dynamicDebugMode) {
-                this.dynamicDispose = ctx.setInterval(this.debug_dynamicDetect(ctx), 10000);
-            }
-            else {
-                this.dynamicDispose = ctx.setInterval(this.dynamicDetect(ctx), 10000 /* this.config.dynamicLoopTime * 1000 */);
-            }
+        if (this.subManager.some(sub => sub.dynamic))
+            this.enableDynamicDetect();
+    }
+    enableDynamicDetect() {
+        // 开始动态监测
+        if (this.config.dynamicDebugMode) {
+            this.dynamicDispose = this.ctx.setInterval(this.debug_dynamicDetect(), this.config.dynamicLoopTime * 1000);
+        }
+        else {
+            this.dynamicDispose = this.ctx.setInterval(this.dynamicDetect(), this.config.dynamicLoopTime * 1000);
         }
-        // 在控制台中显示订阅对象
-        this.updateSubNotifier(ctx);
     }
-    unsubSingle(ctx, id /* UID或RoomId */, type /* 0取消Live订阅，1取消Dynamic订阅 */) {
+    unsubSingle(id /* UID或RoomId */, type /* 0取消Live订阅，1取消Dynamic订阅 */) {
         // 定义返回消息
         let msg;
         // 定义方法：检查是否没有任何订阅
@@ -1536,7 +1854,7 @@ class ComRegister {
             // 从管理对象中移除
             this.subManager.splice(index, 1);
             // 从数据库中删除
-            ctx.database.remove('bilibili', [this.subManager[index].id]);
+            this.ctx.database.remove('bilibili', [this.subManager[index].id]);
             // num--
             this.num--;
             // 判断是否还存在订阅了动态的对象，不存在则停止动态监测
@@ -1555,9 +1873,6 @@ class ComRegister {
                         return msg;
                     }
                     // 取消订阅
-                    if (sub.live)
-                        sub.liveDispose();
-                    sub.liveDispose = null;
                     sub.live = false;
                     // 如果没有对这个UP的任何订阅，则移除
                     if (checkIfNoSubExist(sub)) {
@@ -1566,7 +1881,7 @@ class ComRegister {
                         return '已取消订阅该用户';
                     }
                     // 更新数据库
-                    ctx.database.upsert('bilibili', [{
+                    this.ctx.database.upsert('bilibili', [{
                             id: +`${sub.id}`,
                             live: 0
                         }]);
@@ -1593,7 +1908,7 @@ class ComRegister {
                         return '已取消订阅该用户';
                     }
                     // 更新数据库
-                    ctx.database.upsert('bilibili', [{
+                    this.ctx.database.upsert('bilibili', [{
                             id: sub.id,
                             dynamic: 0
                         }]);
@@ -1603,25 +1918,22 @@ class ComRegister {
         }
         finally {
             // 执行完该方法后，保证执行一次updateSubNotifier()
-            this.updateSubNotifier(ctx);
+            this.updateSubNotifier();
         }
     }
     checkIfUserIsTheLastOneWhoSubDyn() {
-        if (this.subManager.some(sub => sub.dynamic)) {
+        if (this.dynamicDispose && !this.subManager.some(sub => sub.dynamic)) {
             // 停止动态监测
             this.dynamicDispose();
             this.dynamicDispose = null;
         }
     }
-    unsubAll(ctx, uid) {
+    unsubAll(uid) {
         this.subManager.filter(sub => sub.uid === uid).map(async (sub, i) => {
-            // 取消全部订阅 执行dispose方法，销毁定时器
-            if (sub.live)
-                await this.subManager[i].liveDispose();
             // 判断是否还存在订阅了动态的对象，不存在则停止动态监测
             this.checkIfUserIsTheLastOneWhoSubDyn();
             // 从数据库中删除订阅
-            await ctx.database.remove('bilibili', { uid: this.subManager[i].uid });
+            await this.ctx.database.remove('bilibili', { uid: this.subManager[i].uid });
             // 将该订阅对象从订阅管理对象中移除
             this.subManager.splice(i, 1);
             // id--
@@ -1629,13 +1941,13 @@ class ComRegister {
             // 发送成功通知
             this.sendPrivateMsg(`UID:${uid}，已取消订阅该用户`);
             // 更新控制台提示
-            this.updateSubNotifier(ctx);
+            this.updateSubNotifier();
         });
     }
-    async checkIfIsLogin(ctx) {
-        if ((await ctx.database.get('loginBili', 1)).length !== 0) { // 数据库中有数据
+    async checkIfIsLogin() {
+        if ((await this.ctx.database.get('loginBili', 1)).length !== 0) { // 数据库中有数据
             // 检查cookie中是否有值
-            if (ctx.ba.getCookies() !== '[]') { // 有值说明已登录
+            if (this.ctx.ba.getCookies() !== '[]') { // 有值说明已登录
                 return true;
             }
         }
@@ -1644,6 +1956,21 @@ class ComRegister {
 }
 (function (ComRegister) {
     ComRegister.Config = koishi_1.Schema.object({
+        sub: koishi_1.Schema.array(koishi_1.Schema.object({
+            uid: koishi_1.Schema.string().description('订阅用户UID'),
+            dynamic: koishi_1.Schema.boolean().description('是否订阅用户动态'),
+            live: koishi_1.Schema.boolean().description('是否订阅用户直播'),
+            target: koishi_1.Schema.array(koishi_1.Schema.object({
+                channelIdArr: koishi_1.Schema.array(koishi_1.Schema.object({
+                    channelId: koishi_1.Schema.string().description('频道/群组号'),
+                    dynamic: koishi_1.Schema.boolean().description('该频道/群组是否推送动态信息'),
+                    live: koishi_1.Schema.boolean().description('该频道/群组是否推送直播通知'),
+                    liveDanmaku: koishi_1.Schema.boolean().description('该频道/群组是否推送弹幕消息'),
+                    atAll: koishi_1.Schema.boolean().description('推送开播通知时是否艾特全体成员')
+                })).description('频道/群组信息'),
+                platform: koishi_1.Schema.string().description('推送平台')
+            })).description('订阅用户需要发送的频道/群组信息')
+        })).role('table').description('手动输入订阅信息，方便自定义订阅内容，这里的订阅内容不会存入数据库。uid: 订阅用户UID，dynamic: 是否需要订阅动态，live: 是否需要订阅直播'),
         master: koishi_1.Schema.object({
             enable: koishi_1.Schema.boolean(),
             platform: koishi_1.Schema.string(),
@@ -1652,8 +1979,6 @@ class ComRegister {
         }),
         unlockSubLimits: koishi_1.Schema.boolean().required(),
         automaticResend: koishi_1.Schema.boolean().required(),
-        changeMasterInfoApi: koishi_1.Schema.boolean().required(),
-        liveStartAtAll: koishi_1.Schema.boolean().required(),
         restartPush: koishi_1.Schema.boolean().required(),
         pushTime: koishi_1.Schema.number().required(),
         liveLoopTime: koishi_1.Schema.number().default(10),