Example #1
0
        private static void 刷新B站房间列表()
        {
            if (!MMPU.是否能连接阿B)
            {
                return;
            }
            之前的bilibili房间主表状态.Clear();
            List <RL> 临时主表 = new List <RL>();

            foreach (var item in bilibili房间主表)
            {
                if (item.平台 == "bilibili")
                {
                    之前的bilibili房间主表状态.Add(item);
                    临时主表.Add(item);
                }
            }
            int A = 临时主表.Count();

            for (int i = 0; i < A; i++)
            {
                if (临时主表[i].平台 == "bilibili")
                {
                    临时主表.Remove(临时主表[i]);
                    i--;
                }
                A--;
            }
            foreach (var 最新的状态 in bilibili.RoomList)
            {
                foreach (var 之前的状态 in 之前的bilibili房间主表状态)
                {
                    if (之前的状态.唯一码 == 最新的状态.房间号)
                    {
                        if (B站更新刷新次数 > 5)
                        {
                            if (之前的状态.直播状态 == false && 最新的状态.直播状态 == true && 之前的状态.是否提醒)
                            {
                                MMPU.弹窗.Add(3000, "直播提醒", 最新的状态.称 + "/" + 最新的状态.原名 + "的直播状态发生了变化");
                            }
                        }
                        if (之前的状态.直播状态 == false && 最新的状态.直播状态 == true && 之前的状态.是否录制 == true)
                        {
                            if (B站更新刷新次数 > 5)
                            {
                                MMPU.弹窗.Add(3000, "自动录制", 最新的状态.称 + "/" + 最新的状态.原名 + "开始直播了,开始自动录制");
                            }
                            if (MMPU.初始化后启动下载提示)
                            {
                                MMPU.初始化后启动下载提示 = !MMPU.初始化后启动下载提示;
                                MMPU.弹窗.Add(3000, "自动录制", "有关注的正在直播,根据配置列表开始自动录制");
                            }

                            InfoLog.InfoPrintf(最新的状态.称 + "/" + 最新的状态.原名 + "开始直播了,开始自动录制", InfoLog.InfoClass.载必要提示);
                            //Console.WriteLine(最新的状态.名称);
                            new Task(() =>
                            {
                                Downloader.新建下载对象(之前的状态.平台, 之前的状态.唯一码, bilibili.根据房间号获取房间信息.获取标题(之前的状态.唯一码), Guid.NewGuid().ToString(), bilibili.根据房间号获取房间信息.载地址(之前的状态.唯一码), "自动录制", true, 最新的状态.称 + "-" + 最新的状态.原名, false, null).DownIofo.备注 = "自动录制下载中";
                            }).Start();
                        }
                        break;
                    }
                }
                int B = 之前的bilibili房间主表状态.Count();
                临时主表.Add(new RL {
                    称 = 最新的状态.称, 唯一码 = 最新的状态.房间号, 平台 = "bilibili", 是否录制 = 最新的状态.是否录制视频, 是否提醒 = 最新的状态.是否提醒, 直播状态 = 最新的状态.直播状态, 原名 = 最新的状态.原名
                });
            }
            bilibili房间主表.Clear();
            foreach (var item in 临时主表)
            {
                bilibili房间主表.Add(item);
            }
            bilibili房间主表长度 = bilibili房间主表.Count();
            B站更新刷新次数++;
        }
Example #2
0
        // public event EventHandler<EventArgs> DownUpdate;
        // public event EventHandler<EventArgs> DownOk;
        private void  载完成事件(object sender, AsyncCompletedEventArgs e)
        {
            WebClient WWC = (WebClient)sender;

            new Task((() =>
            {
                DownIofo.载状态 = false;
                DownIofo.结束时间 = Convert.ToInt32((DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, 0)).TotalSeconds);
                DownIofo.备注 = "下载任务结束";
                // if (e.Error != null && e.Error.)
                //Clipboard.SetDataObject(e.Error.Message);

                if (e.Cancelled)
                {
                    DownIofo.备注 = "用户取消,停止下载";
                    if (!DownIofo.播放状态 && DownIofo.是否是播放任务)
                    {
                        DownIofo.备注 = "播放窗口关闭";
                        InfoLog.InfoPrintf("下载任务结束\n==============下载任务结束================\n主播名:" + DownIofo.主播名称 + "\n房间号:" + DownIofo.房间_频道号 + "\n标题:" + DownIofo.标题 + "\n开播时间:" + DownIofo.开始时间 + "\n结束时间:" + DownIofo.结束时间 + "\n保存路径:" + DownIofo.文件保存路径 + "\n下载任务类型:" + (DownIofo.继承.是否为继承对象 ? "续下任务" : "新建下载任务") + "\n结束原因:" + DownIofo.备注 + "\n===============下载任务结束===============\n", InfoLog.InfoClass.载必要提示);

                        return;
                    }
                }
                else if (e.Cancelled == false && !bilibili.根据房间号获取房间信息.是否正在直播(DownIofo.房间_频道号))
                {
                    DownIofo.备注 = "直播停止,下载完成下载完成";
                    InfoLog.InfoPrintf("下载任务结束\n==============下载任务结束================\n主播名:" + DownIofo.主播名称 + "\n房间号:" + DownIofo.房间_频道号 + "\n标题:" + DownIofo.标题 + "\n开播时间:" + DownIofo.开始时间 + "\n结束时间:" + DownIofo.结束时间 + "\n保存路径:" + DownIofo.文件保存路径 + "\n下载任务类型:" + (DownIofo.继承.是否为继承对象 ? "续下任务" : "新建下载任务") + "\n结束原因:" + DownIofo.备注 + "\n===============下载任务结束===============\n", InfoLog.InfoClass.载必要提示);
                    if (DownIofo.继承 == null)
                    {
                        DownIofo.继承.是否为继承对象 = false;
                    }
                    if (DownIofo.继承.是否为继承对象 && !DownIofo.是否是播放任务)
                    {
                        DownIofo.继承.合并后的文件路径 = 载完成合并FLV(DownIofo.继承.继承的下载文件路径, DownIofo.文件保存路径, true);
                        if (!string.IsNullOrEmpty(DownIofo.继承.合并后的文件路径))
                        {
                            DownIofo.文件保存路径 = DownIofo.继承.合并后的文件路径;
                        }
                    }
                    else if (!DownIofo.是否是播放任务)
                    {
                        FlvMethod.转码(DownIofo.文件保存路径);
                    }
                    InfoLog.InfoPrintf(DownIofo.房间_频道号 + "房间:" + DownIofo.主播名称 + " 下播,录制完成", InfoLog.InfoClass.载必要提示);
                    return;
                }
                else
                {
                    if (bilibili.根据房间号获取房间信息.是否正在直播(DownIofo.房间_频道号) && DownIofo.是否保存)
                    {
                        DownIofo.备注 = "下载流断开,但检测到房间仍为开播状态,已新建续下任务";
                        DownIofo.载状态 = false;
                        DownIofo.结束时间 = Convert.ToInt32((DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, 0)).TotalSeconds);
                        switch (DownIofo.平台)
                        {
                        case "bilibili":
                            {
                                if (DownIofo.继承.是否为继承对象 && !DownIofo.是否是播放任务)
                                {
                                    DownIofo.继承.合并后的文件路径 = 载完成合并FLV(DownIofo.继承.继承的下载文件路径, DownIofo.文件保存路径, false);
                                    if (!string.IsNullOrEmpty(DownIofo.继承.合并后的文件路径))
                                    {
                                        DownIofo.文件保存路径 = DownIofo.继承.合并后的文件路径;
                                    }
                                }

                                Downloader 载对象 = Downloader.新建下载对象(DownIofo.平台, DownIofo.房间_频道号, bilibili.根据房间号获取房间信息.获取标题(DownIofo.房间_频道号), Guid.NewGuid().ToString(), bilibili.根据房间号获取房间信息.载地址(DownIofo.房间_频道号), "重连", DownIofo.是否保存, DownIofo.主播名称, true, DownIofo.文件保存路径);
                                if (!载对象.DownIofo.载状态)
                                {
                                    载对象.DownIofo.载状态 = false;
                                    载对象.DownIofo.结束时间 = Convert.ToInt32((DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, 0)).TotalSeconds);
                                    载对象.DownIofo.备注 = "服务器主动断开连接,直播结束";
                                    if (DownIofo.继承.是否为继承对象 && !DownIofo.是否是播放任务)
                                    {
                                        DownIofo.继承.合并后的文件路径 = 载完成合并FLV(DownIofo.继承.继承的下载文件路径, DownIofo.文件保存路径, true);
                                        if (!string.IsNullOrEmpty(DownIofo.继承.合并后的文件路径))
                                        {
                                            DownIofo.文件保存路径 = DownIofo.继承.合并后的文件路径;
                                        }
                                    }
                                    else if (!DownIofo.是否是播放任务)
                                    {
                                        FlvMethod.转码(DownIofo.文件保存路径);
                                    }

                                    InfoLog.InfoPrintf("下载任务结束\n==============下载任务结束================\n主播名:" + DownIofo.主播名称 + "\n房间号:" + DownIofo.房间_频道号 + "\n标题:" + DownIofo.标题 + "\n开播时间:" + DownIofo.开始时间 + "\n结束时间:" + DownIofo.结束时间 + "\n保存路径:" + DownIofo.文件保存路径 + "\n下载任务类型:" + (DownIofo.继承.是否为继承对象 ? "续下任务" : "新建下载任务") + "\n结束原因:" + DownIofo.备注 + "\n===============下载任务结束===============\n", InfoLog.InfoClass.载必要提示);
                                    载对象.DownIofo.载状态 = false;
                                    载对象.DownIofo.结束时间 = Convert.ToInt32((DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, 0)).TotalSeconds);
                                    DownIofo.载状态 = false;
                                    DownIofo.结束时间 = Convert.ToInt32((DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, 0)).TotalSeconds);
                                    return;
                                }
                                new Task((() =>
                                {
                                    while (true)
                                    {
                                        Thread.Sleep(1000);
                                        if (载对象.DownIofo.已下载大小bit > 1000)
                                        {
                                            DownIofo.载状态 = true;
                                            return;
                                        }
                                        if (!bilibili.根据房间号获取房间信息.是否正在直播(DownIofo.房间_频道号))
                                        {
                                            InfoLog.InfoPrintf("下载任务结束\n==============下载任务结束================\n主播名:" + DownIofo.主播名称 + "\n房间号:" + DownIofo.房间_频道号 + "\n标题:" + DownIofo.标题 + "\n开播时间:" + DownIofo.开始时间 + "\n结束时间:" + DownIofo.结束时间 + "\n保存路径:" + DownIofo.文件保存路径 + "\n下载任务类型:" + (DownIofo.继承.是否为继承对象 ? "续下任务" : "新建下载任务") + "\n结束原因:" + DownIofo.备注 + "\n===============下载任务结束===============\n", InfoLog.InfoClass.载必要提示);
                                            载对象.DownIofo.备注 = "停止直播";
                                            载对象.DownIofo.载状态 = false;
                                            载对象.DownIofo.结束时间 = Convert.ToInt32((DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, 0)).TotalSeconds);
                                            DownIofo.载状态 = false;
                                            DownIofo.结束时间 = Convert.ToInt32((DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, 0)).TotalSeconds);
                                            载对象.DownIofo.WC.CancelAsync();
                                            MMPU.DownList.Remove(载对象);
                                            return;
                                        }
                                    }
                                })).Start();
                                break;
                            }

                        //case "youtube":
                        //    {
                        //        break;
                        //    }
                        //case "T台":
                        //    {
                        //        break;
                        //    }
                        //case "FC2":
                        //    {
                        //        break;
                        //    }
                        //case "DDTV直播服务器":
                        //    {
                        //        break;
                        //    }
                        default:
                            DownIofo.载状态 = false;
                            DownIofo.结束时间 = Convert.ToInt32((DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, 0)).TotalSeconds);
                            InfoLog.InfoPrintf("该房间的配置文件发现了与当前版本不支持的平台,请检查文件配置或者检查更新", InfoLog.InfoClass.系统错误信息);
                            return;
                        }
                    }
                }
            })).Start();
        }
Example #3
0
        // public event EventHandler<EventArgs> DownUpdate;
        // public event EventHandler<EventArgs> DownOk;

        private void  载完成事件(object sender, AsyncCompletedEventArgs e)
        {
            new Task((() =>
            {
                try
                {
                    DownIofo.载状态 = false;
                    DownIofo.结束时间 = Convert.ToInt32((DateTime.Now - new DateTime(1970, 1, 1, 0, 0, 0, 0)).TotalSeconds);
                    DownIofo.备注 = "下载任务结束";
                    if (e.Cancelled && !DownIofo.网络超时)
                    {
                        if (!DownIofo.播放状态 && DownIofo.是否是播放任务)
                        {
                            DownIofo.备注 = "播放窗口关闭";
                            DownIofo.载状态 = false;
                            载结束提醒(true, "下载任务结束", DownIofo);
                            return;
                        }
                        DownIofo.继承.待合并文件列表.Add(DownIofo.文件保存路径);
                        DownIofo.备注 = "用户取消,停止下载";
                        DownIofo.载状态 = false;
                        载结束提醒(true, "下载任务结束", DownIofo);
                    }
                    else if (!e.Cancelled && !bilibili.根据房间号获取房间信息.是否正在直播(DownIofo.房间_频道号, true))
                    {
                        DownIofo.继承.待合并文件列表.Add(DownIofo.文件保存路径);
                        DownIofo.载状态 = false;
                        DownIofo.备注 = "下载完成,直播间已关闭";
                        if (DownIofo.继承 == null)
                        {
                            DownIofo.继承.是否为继承对象 = false;
                        }
                        if (DownIofo.继承.是否为继承对象 && !DownIofo.是否是播放任务)
                        {
                            DownIofo.继承.合并后的文件路径 = 载完成合并FLV(DownIofo, true);
                            if (!string.IsNullOrEmpty(DownIofo.继承.合并后的文件路径))
                            {
                                DownIofo.文件保存路径 = DownIofo.继承.合并后的文件路径;
                            }
                        }
                        if (!DownIofo.是否是播放任务)
                        {
                            FlvMethod.转码(DownIofo.文件保存路径);
                        }
                        InfoLog.InfoPrintf(DownIofo.房间_频道号 + "房间:" + DownIofo.主播名称 + " 下播,录制完成", InfoLog.InfoClass.载必要提示);
                        foreach (var item in RoomInit.bilibili房间主表)
                        {
                            if (item.唯一码 == DownIofo.房间_频道号)
                            {
                                item.直播状态 = false;
                                break;
                            }
                        }
                        DownIofo.载状态 = false;
                        载结束提醒(true, "下载任务结束", DownIofo);
                        return;
                    }
                    else
                    {
                        if (bilibili.根据房间号获取房间信息.是否正在直播(DownIofo.房间_频道号, true) && DownIofo.是否保存)
                        {
                            DownIofo.网络超时 = true;
                            DownIofo.载状态 = false;
                            DownIofo.备注 = "下载流中断,检测到房间仍为开播状态,新建续下任务。";
                            DownIofo.结束时间 = Convert.ToInt32((DateTime.Now - new DateTime(1970, 1, 1, 0, 0, 0, 0)).TotalSeconds);
                            switch (DownIofo.平台)
                            {
                            case "bilibili":
                                {
                                    if (DownIofo.继承.是否为继承对象 && !DownIofo.是否是播放任务)
                                    {
                                        //DownIofo.继承.合并后的文件路径 = 下载完成合并FLV(DownIofo.继承.继承的下载文件路径, DownIofo.文件保存路径, false);
                                        if (DownIofo.继承.待合并文件列表.Count == 0)
                                        {
                                            DownIofo.继承.待合并文件列表.Add(DownIofo.继承.继承的下载文件路径);
                                            InfoLog.InfoPrintf($"{DownIofo.房间_频道号}:{DownIofo.主播名称}下载任务续下,历史文件加入待合并文件列表:{DownIofo.继承.继承的下载文件路径}", InfoLog.InfoClass.载必要提示);
                                        }
                                        DownIofo.继承.待合并文件列表.Add(DownIofo.文件保存路径);
                                        InfoLog.InfoPrintf($"{DownIofo.房间_频道号}:{DownIofo.主播名称}下载任务续下,历史文件加入待合并文件列表:{DownIofo.文件保存路径}", InfoLog.InfoClass.载必要提示);
                                        //if (!string.IsNullOrEmpty(DownIofo.继承.合并后的文件路径))
                                        //{
                                        //    DownIofo.文件保存路径 = DownIofo.继承.合并后的文件路径;
                                        //}
                                    }
                                    DownIofo.载状态 = false;
                                    Downloader 重连下载对象 = Downloader.新建下载对象(
                                        DownIofo.平台,
                                        DownIofo.房间_频道号,
                                        bilibili.根据房间号获取房间信息.获取标题(DownIofo.房间_频道号),
                                        Guid.NewGuid().ToString(),
                                        bilibili.根据房间号获取房间信息.载地址(DownIofo.房间_频道号),
                                        "重连",
                                        DownIofo.是否保存,
                                        DownIofo.主播名称,
                                        true,
                                        DownIofo.文件保存路径,
                                        DownIofo
                                        );
                                    if (!重连下载对象.DownIofo.载状态)
                                    {
                                        try
                                        {
                                            重连下载对象.DownIofo.弹幕录制基准时间 = DownIofo.弹幕录制基准时间;
                                            重连下载对象.DownIofo.阿B直播流对象 = DownIofo.阿B直播流对象;
                                            重连下载对象.DownIofo.弹幕储存流 = DownIofo.弹幕储存流;
                                            重连下载对象.DownIofo.礼物储存流 = DownIofo.礼物储存流;
                                            重连下载对象.DownIofo.载状态 = false;
                                            重连下载对象.DownIofo.结束时间 = Convert.ToInt32((DateTime.Now - new DateTime(1970, 1, 1, 0, 0, 0, 0)).TotalSeconds);
                                            重连下载对象.DownIofo.备注 = "服务器主动断开连接,直播结束";
                                            foreach (var item in RoomInit.bilibili房间主表)
                                            {
                                                if (item.唯一码 == DownIofo.房间_频道号)
                                                {
                                                    item.直播状态 = false;
                                                    break;
                                                }
                                            }
                                            if (DownIofo.继承.是否为继承对象 && !DownIofo.是否是播放任务)
                                            {
                                                DownIofo.继承.合并后的文件路径 = 载完成合并FLV(DownIofo, true);
                                                if (!string.IsNullOrEmpty(DownIofo.继承.合并后的文件路径))
                                                {
                                                    DownIofo.文件保存路径 = DownIofo.继承.合并后的文件路径;
                                                }
                                            }
                                            if (!DownIofo.是否是播放任务)
                                            {
                                                FlvMethod.转码(DownIofo.文件保存路径);
                                            }
                                            DownIofo.备注 = "服务器主动断开连接,直播结束";
                                            重连下载对象.DownIofo.载状态 = false;
                                            重连下载对象.DownIofo.结束时间 = Convert.ToInt32((DateTime.Now - new DateTime(1970, 1, 1, 0, 0, 0, 0)).TotalSeconds);
                                            DownIofo.载状态 = false;
                                            DownIofo.结束时间 = Convert.ToInt32((DateTime.Now - new DateTime(1970, 1, 1, 0, 0, 0, 0)).TotalSeconds);
                                            载结束提醒(true, "下载任务结束", 重连下载对象.DownIofo);
                                        }
                                        catch (Exception) {}
                                        return;
                                    }
                                    new Task((() =>
                                    {
                                        while (true)
                                        {
                                            Thread.Sleep(10000);
                                            if (重连下载对象.DownIofo.已下载大小bit > 5000)
                                            {
                                                DownIofo.载状态 = false;
                                                DownIofo.结束时间 = Convert.ToInt32((DateTime.Now - new DateTime(1970, 1, 1, 0, 0, 0, 0)).TotalSeconds);
                                                载结束提醒(true, "下载任务结束", DownIofo);
                                                重连下载对象.DownIofo.备注 = "完成重连,正在续命..";
                                                //下载对象.DownIofo.下载状态 = true;
                                                return;
                                            }
                                            if (!bilibili.根据房间号获取房间信息.是否正在直播(DownIofo.房间_频道号, true))
                                            {
                                                重连下载对象.DownIofo.备注 = "停止直播";
                                                DownIofo.备注 = "直播停止,下载完成下载完成";
                                                重连下载对象.DownIofo.载状态 = false;
                                                重连下载对象.DownIofo.结束时间 = Convert.ToInt32((DateTime.Now - new DateTime(1970, 1, 1, 0, 0, 0, 0)).TotalSeconds);
                                                DownIofo.载状态 = false;
                                                DownIofo.结束时间 = Convert.ToInt32((DateTime.Now - new DateTime(1970, 1, 1, 0, 0, 0, 0)).TotalSeconds);
                                                重连下载对象.DownIofo.WC.CancelAsync();
                                                MMPU.DownList.Remove(重连下载对象);
                                                载结束提醒(true, "下载任务结束", DownIofo);
                                                载结束提醒(true, "下载任务结束", 重连下载对象.DownIofo);
                                                return;
                                            }
                                        }
                                    })).Start();
                                    DownIofo.载状态 = false;
                                    break;
                                }

                            default:
                                DownIofo.备注 = "不受支持的平台";
                                DownIofo.载状态 = false;
                                DownIofo.结束时间 = Convert.ToInt32((DateTime.Now - new DateTime(1970, 1, 1, 0, 0, 0, 0)).TotalSeconds);
                                InfoLog.InfoPrintf("该房间的配置文件发现了与当前版本不支持的平台,请检查文件配置或者检查更新", InfoLog.InfoClass.系统错误信息);
                                //下载结束提醒(false);
                                return;
                            }
                        }
                        else
                        {
                            DownIofo.备注 = "直播停止,下载完成下载完成";
                            载结束提醒(true, "下载任务结束", DownIofo);
                            DownIofo.载状态 = false;
                            return;
                        }
                    }
                    DownIofo.载状态 = false;
                    DownIofo.结束时间 = Convert.ToInt32((DateTime.Now - new DateTime(1970, 1, 1, 0, 0, 0, 0)).TotalSeconds);
                    DownIofo.备注 = "下载任务结束";
                }
                catch (Exception ES)
                {
                    InfoLog.InfoPrintf($"录制任务意外终止:\r\n{ES.ToString()}", InfoLog.InfoClass.系统错误信息);
                    DownIofo.载状态 = false;
                    DownIofo.备注 = "录制任务意外终止,已新建续命任务";
                    载结束提醒(true, "录制任务意外终止,已新建续命任务", DownIofo);
                    Downloader 载对象 = new Downloader();
                    try
                    {
                        DownIofo.载状态 = false;
                        载对象 = Downloader.新建下载对象(
                            DownIofo.平台,
                            DownIofo.房间_频道号,
                            bilibili.根据房间号获取房间信息.获取标题(DownIofo.房间_频道号),
                            Guid.NewGuid().ToString(),
                            bilibili.根据房间号获取房间信息.载地址(DownIofo.房间_频道号),
                            "前一个下载出现异常,新建下载",
                            DownIofo.是否保存,
                            DownIofo.主播名称,
                            false,
                            DownIofo.文件保存路径
                            );
                    }
                    catch (Exception)
                    {
                        try
                        {
                            载对象.DownIofo.备注 = "新建续下载对象出现异常,放弃新建任务";
                            载结束提醒(true, "下载任务结束", DownIofo);
                            载对象.DownIofo.载状态 = false;
                            载对象.DownIofo.结束时间 = Convert.ToInt32((DateTime.Now - new DateTime(1970, 1, 1, 0, 0, 0, 0)).TotalSeconds);
                            载对象.DownIofo.WC.CancelAsync();
                            MMPU.DownList.Remove(载对象);
                        }
                        catch (Exception)
                        {
                        }
                    }
                }
            })).Start();
        }
Example #4
0
        public static Downloader 新建下载对象(string 平台, string 唯一码, string 标题, string GUID, string 载地址, string 备注, bool 是否保存, string 主播名称, bool 是否为继承项目, string 继承项目的原始文件)
        {
            Downloader 载对象 = new Downloader();

            载对象.DownIofo.继承 = new 继承();
            string 保存路径;

            if (MMPU.载储存目录 == "./tmp/")
            {
                保存路径 = "./tmp/" + 平台 + "_" + 主播名称 + "_" + 唯一码 + "/";
                if (Directory.Exists(保存路径))//如果不存在就创建文件夹
                {
                    Directory.CreateDirectory(保存路径);
                }
                保存路径 = 保存路径 + 标题 + "_" + DateTime.Now.ToString("yyyyMMddHHmmssfff") + ".flv";
            }
            else
            {
                保存路径 = MMPU.载储存目录 + "/" + 平台 + "_" + 主播名称 + "_" + 唯一码 + "/";
                if (!Directory.Exists(保存路径))//如果不存在就创建file文件夹
                {
                    try
                    {
                        Directory.CreateDirectory(保存路径);
                    }
                    catch (Exception)
                    {
                        MMPU.载储存目录 = "./tmp/";
                        MMPU.setFiles("file", MMPU.载储存目录);
                        保存路径 = MMPU.载储存目录 + "/" + 平台 + "_" + 主播名称 + "_" + 唯一码 + "/";
                    }
                }
                保存路径 = 保存路径 + 标题 + "_" + DateTime.Now.ToString("yyyyMMddHHmmssfff") + ".flv";
            }
            switch (平台)
            {
            case "bilibili":
            {
                载地址 = 载地址;
                break;
            }

            case "youtube":
            {
                break;
            }
            }
            载对象.DownIofo = new Downloader.DownIofoData
            {
                平台     = 平台,
                房间_频道号 = 唯一码,
                文件保存路径 = 保存路径,
                事件GUID = GUID,
                载地址    = 载地址,
                是否保存   = 是否保存,
                标题     = 标题,
                备注     = 备注,
                主播名称   = 主播名称,
                继承     = new 继承()
                {
                    是否为继承对象   = 是否为继承项目,
                    继承的下载文件路径 = 继承项目的原始文件,
                }
            };
            if (!是否保存)
            {
                int 随机值 = new Random().Next(1000, 9999);
                载对象.DownIofo.文件保存路径 = "./tmp/LiveCache/" + 载对象.DownIofo.标题 + DateTime.Now.ToString("yyyyMMddHHmmssfff") + "_" + 随机值 + ".flv";
                if (File.Exists(载对象.DownIofo.文件保存路径))
                {
                    载对象.DownIofo.文件保存路径 = "./tmp/LiveCache/" + 载对象.DownIofo.标题 + DateTime.Now.ToString("yyyyMMddHHmmssfff") + "_" + (随机值) + 1 + ".flv";
                }
            }
            MMPU.DownList.Add(载对象);
            载对象.Start(备注);
            InfoLog.InfoPrintf(主播名称 + "开始直播,建立下载任务\n==============建立下载任务================\n主播名:" + 载对象.DownIofo.主播名称 + "\n房间号:" + 唯一码 + "\n标题:" + 标题 + "\n开播时间:" + MMPU.Unix转换为DateTime(载对象.DownIofo.开始时间.ToString()) + "\n保存路径:" + 载对象.DownIofo.文件保存路径 + "\n下载任务类型:" + (载对象.DownIofo.继承.是否为继承对象 ? "续下任务" : "新建下载任务") + "\n===============建立下载任务===============\n", InfoLog.InfoClass.载必要提示);
            return(载对象);
        }
Example #5
0
        public static Downloader 新建下载对象(string 平台, string 唯一码, string 标题, string GUID, string 载地址, string 备注, bool 是否保存, string 主播名称, bool 是否为继承项目, string 继承项目的原始文件, DownIofoData 继承的项目 = null)
        {
            foreach (var item in MMPU.DownList)
            {
                if (item.DownIofo.房间_频道号 == 唯一码)
                {
                    if (item.DownIofo.载状态 && item.DownIofo.是否保存 && 是否保存)
                    {
                        InfoLog.InfoPrintf($"新建任务冲突,放弃新建任务,任务内容:\r\n房间号:{唯一码}\r\n主播名称:{主播名称}\r\n标题:{标题}", InfoLog.InfoClass.载必要提示);
                        return(null);
                    }
                    else
                    {
                        break;
                    }
                }
            }
            if (string.IsNullOrEmpty(标题))
            {
                标题 = $"V{new Random().Next(10000,99999)}";
            }
            Downloader 载对象 = new Downloader();

            载对象.DownIofo.继承 = new 继承();
            string 缓存路径 = MMPU.缓存路径;
            string 保存路径;

            if (MMPU.载储存目录 == 缓存路径)
            {
                保存路径 = 缓存路径 + 平台 + "_" + 主播名称 + "_" + 唯一码 + "/";
                if (Directory.Exists(保存路径))//如果不存在就创建文件夹
                {
                    Directory.CreateDirectory(保存路径);
                }
                保存路径 = 保存路径 + 标题 + "_" + DateTime.Now.ToString("yyyyMMddHHmmssfff") + ".flv";
            }
            else
            {
                保存路径 = MMPU.载储存目录 + "/" + 平台 + "_" + 主播名称 + "_" + 唯一码 + "/";
                if (!Directory.Exists(保存路径))//如果不存在就创建file文件夹
                {
                    try
                    {
                        Directory.CreateDirectory(保存路径);
                    }
                    catch (Exception)
                    {
                        MMPU.载储存目录 = 缓存路径;
                        MMPU.setFiles("file", MMPU.载储存目录);
                        保存路径 = MMPU.载储存目录 + "/" + 平台 + "_" + 主播名称 + "_" + 唯一码 + "/";
                    }
                }
                保存路径 = 保存路径 + 标题 + "_" + DateTime.Now.ToString("yyyyMMddHHmmssfff") + ".flv";
                if (File.Exists(保存路径))
                {
                    Thread.Sleep(1);
                    保存路径 = MMPU.载储存目录 + "/" + 平台 + "_" + 主播名称 + "_" + 唯一码 + "/" + 标题 + "_" + DateTime.Now.ToString("yyyyMMddHHmmssfff") + ".flv";
                }
            }
            switch (平台)
            {
            case "bilibili":
            {
                载地址 = 载地址;
                break;
            }

            case "youtube":
            {
                break;
            }
            }
            载对象.DownIofo = new Downloader.DownIofoData
            {
                平台     = 平台,
                载状态    = true,
                房间_频道号 = 唯一码,
                文件保存路径 = 保存路径,
                事件GUID = GUID,
                载地址    = 载地址,
                是否保存   = 是否保存,
                标题     = 标题,
                备注     = 备注,
                主播名称   = 主播名称,
                继承     = new 继承()
                {
                    是否为继承对象   = 是否为继承项目,
                    继承的下载文件路径 = 继承项目的原始文件,
                }
            };
            if (继承的项目 != null)
            {
                载对象.DownIofo.继承.待合并文件列表 = 继承的项目.继承.待合并文件列表;
            }
            if (!是否保存)
            {
                int 随机值 = new Random().Next(1000, 9999);
                载对象.DownIofo.文件保存路径 = 缓存路径 + "LiveCache/" + 载对象.DownIofo.标题 + DateTime.Now.ToString("yyyyMMddHHmmssfff") + "_" + 随机值 + ".flv";
                if (File.Exists(载对象.DownIofo.文件保存路径))
                {
                    载对象.DownIofo.文件保存路径 = 缓存路径 + "LiveCache/" + 载对象.DownIofo.标题 + DateTime.Now.ToString("yyyyMMddHHmmssfff") + "_" + (随机值) + 1 + ".flv";
                }
            }

            载对象.Start(备注);

            return(载对象);
        }