private JObject _getResponseJObject()
{
byte[] responseBytes;
try
{
responseBytes = getWebClient().DownloadData(_request.Url);
}
catch (Exception e)
{
InfoLog.InfoPrintf($"[{_id}] {_request.ExceptionString}: {e.Message}",
InfoLog.InfoClass.Debug);
return(null);
}
var responseString = Encoding.UTF8.GetString(responseBytes);
var jsonObject = JObject.Parse(responseString);
return(jsonObject);
}
public static string 通过UID获取房间号(string uid)
{
var wc = new WebClient();
wc.Headers.Add("Accept: */*");
wc.Headers.Add("Accept-Language: zh-CN,zh;q=0.8,en;q=0.6,ja;q=0.4");
//发送HTTP请求
byte[] roomHtml = wc.DownloadData("https://api.live.bilibili.com/room/v1/Room/getRoomInfoOld?mid=" + uid);
var result = JObject.Parse(Encoding.UTF8.GetString(roomHtml));
string roomId = result["data"]["roomid"].ToString();
InfoLog.InfoPrintf("根据UID获取到房间号:" + roomId, InfoLog.InfoClass.Debug);
return(roomId);
}
public static void start()
{
Task.Run(async() =>
{
InfoLog.InfoPrintf("启动youtube频道信息本地缓存更新线程", InfoLog.InfoClass.Debug);
while (true)
{
try
{
周期更新youtube频道状态();
await Task.Delay(MMPU.直播更新时间 * 1000);
}
catch (Exception e)
{
InfoLog.InfoPrintf("youtube频道信息本地缓存更新出现错误:" + e.ToString(), InfoLog.InfoClass.Debug);
}
}
});
}
public static string 获取真实房间号(string roomID)
{
var roomWebPageUrl = "https://api.live.bilibili.com/room/v1/Room/get_info?id=" + roomID;
var wc = new WebClient();
wc.Headers.Add("Accept: */*");
wc.Headers.Add("User-Agent: " + MMPU.UA.Ver.UA());
wc.Headers.Add("Accept-Language: zh-CN,zh;q=0.8,en;q=0.6,ja;q=0.4");
if (!string.IsNullOrEmpty(MMPU.Cookie))
{
wc.Headers.Add("Cookie", MMPU.Cookie);
}
//发送HTTP请求
byte[] roomHtml;
try
{
roomHtml = wc.DownloadData(roomWebPageUrl);
}
catch (Exception e)
{
InfoLog.InfoPrintf(roomID + "获取房间信息失败:" + e.Message, InfoLog.InfoClass.Debug);
return(null);
}
//从返回结果中提取真实房间号
try
{
var roomJson = Encoding.UTF8.GetString(roomHtml);
var result = JObject.Parse(roomJson);
var live_status = result["data"]["live_status"].ToString();
if (live_status != "1")
{
return("-1");
}
var roomid = result["data"]["room_id"].ToString();
InfoLog.InfoPrintf("获取到真实房间号: " + roomid, InfoLog.InfoClass.杂项提示);
return(roomid);
}
catch
{
return(roomID);
}
}
/// <summary>
/// 获取BILIBILI直播流下载地址
/// </summary>
/// <param name="roomid">房间号</param>
/// <param name="R">是否为重试</param>
/// <returns></returns>
public static string 载地址(string roomid)
{
roomid = 获取真实房间号(roomid);
if (roomid == null)
{
InfoLog.InfoPrintf("房间号获取错误", InfoLog.InfoClass.Debug);
return(null);
}
string resultString;
try
{
resultString = MMPU.使用WC获取网络内容("https://api.live.bilibili.com/room/v1/Room/playUrl?cid=" + roomid + "&otype=json&qn=10000&platform=web");
}
catch (Exception e)
{
InfoLog.InfoPrintf("发送解析请求失败：" + e.Message, InfoLog.InfoClass.Debug);
return("");
}
//解析结果使用最高清晰度
try
{
MMPU.判断网络路径是否存在 判断文件是否存在 = new MMPU.判断网络路径是否存在();
string BBBC = "";
BBBC = (JObject.Parse(resultString)["data"]["durl"][0]["url"].ToString());
//BBBC = (JObject.Parse(resultString)["data"]["durl"][0]["url"].ToString() + "&platform=web").Replace("&pt=", "&pt=web") + "&pSession=" + Guid.NewGuid();
if (!判断文件是否存在.判断(BBBC, "bilibili", roomid))
{
InfoLog.InfoPrintf("请求的开播房间当前推流数据为空，推测还未开播，等待数据流...：", InfoLog.InfoClass.Debug);
BBBC = (JObject.Parse(resultString)["data"]["durl"][1]["url"].ToString());
}
DataCache.BilibiliApiCount++;
return(BBBC);
}
catch (Exception e)
{
InfoLog.InfoPrintf("视频流地址解析失败：" + e.Message, InfoLog.InfoClass.Debug);
return("");
}
}
public static string 获取标题(string roomID)
{
string CacheStr = "byRoomIdgetRoomTitle";
if (DataCache.读缓存(CacheStr + roomID, 20, out string CacheData))
{
return(CacheData);
}
roomID = 获取真实房间号(roomID);
if (roomID == null)
{
InfoLog.InfoPrintf("房间号获取错误", InfoLog.InfoClass.Debug);
return(null);
}
string roomHtml;
try
{
roomHtml = MMPU.使用WC获取网络内容("https://api.live.bilibili.com/room/v1/Room/get_info?id=" + roomID);
}
catch (Exception e)
{
InfoLog.InfoPrintf(roomID + "获取房间信息失败:" + e.Message, InfoLog.InfoClass.载必要提示);
return(null);
}
//解析结果
try
{
JObject result = JObject.Parse(roomHtml);
string roomName = result["data"]["title"].ToString().Replace(" ", "").Replace("/", "").Replace("\\", "").Replace("\"", "").Replace(":", "").Replace("*", "").Replace("?", "").Replace("<", "").Replace(">", "").Replace("|", "").ToString();
InfoLog.InfoPrintf("根据RoomId获取到标题:" + roomName, InfoLog.InfoClass.Debug);
DataCache.写缓存(CacheStr + roomID, roomName);
return(roomName);
}
catch (Exception e)
{
InfoLog.InfoPrintf("视频标题解析失败：" + e.Message, InfoLog.InfoClass.Debug);
return("");
}
}
public static void ByQRCode_QrCodeStatus_Changed(ByQRCode.QrCodeStatus status, Account account = null)
{
if (status == ByQRCode.QrCodeStatus.Success)
{
BiliUser.account = account;
InfoLog.InfoPrintf("UID:" + account.Uid + ",登陆成功", InfoLog.InfoClass.杂项提示);
//MessageBox.Show("UID:"+account.Uid+",登陆成功");
MMPU.UID = account.Uid;
MMPU.写ini配置文件("User", "UID", MMPU.UID, MMPU.BiliUserFile);
foreach (var item in account.Cookies)
{
MMPU.Cookie = MMPU.Cookie + item + ";";
}
MMPU.CookieEX = account.Expires_Cookies;
MMPU.csrf = account.CsrfToken;
;
MMPU.写ini配置文件("User", "csrf", MMPU.csrf, MMPU.BiliUserFile);
MMPU.写ini配置文件("User", "Cookie", Encryption.AesStr(MMPU.Cookie, MMPU.AESKey, MMPU.AESVal), MMPU.BiliUserFile);
MMPU.写ini配置文件("User", "CookieEX", MMPU.CookieEX.ToString("yyyy-MM-dd HH:mm:ss"), MMPU.BiliUserFile);
}
}
public static void start()
{
new Task(() => {
#region MyRegion
while (true)
{
try
{
更新VTBS房间数据();
Thread.Sleep(1000 * 60 * 60);
}
catch (Exception) { }
}
#endregion
}).Start();
Task.Run(async() =>
{
InfoLog.InfoPrintf("启动房间信息本地缓存更新线程", InfoLog.InfoClass.Debug);
//是否启动WS连接组 = MMPU.读取exe默认配置文件("DataSource", "0") == "1" ? true : MMPU.读取exe默认配置文件("NotVTBStatus", "0") == "1";
if (是否启动WS连接组)
{
new Task(() => {
持续连接获取阿B房间信息类.初始化所有房间连接();
}).Start();
}
while (true)
{
try
{
周期更新B站房间状态();
await Task.Delay(MMPU.直播更新时间 * 1000);
}
catch (Exception e)
{
InfoLog.InfoPrintf("房间信息本地缓存更新出现错误:" + e.ToString(), InfoLog.InfoClass.Debug);
}
}
});
}
/// <summary>
/// 读缓存
/// </summary>
/// <param name="key">查询的键名</param>
/// <param name="ExTime">超时时间,0为永远有效</param>
/// <param name="data">查询到的结果</param>
/// <returns>该键名是否有对应的数据</returns>
public static bool 读缓存(string key, double ExTime, out string data)
{
data = null;
Dictionary <string, string> 缓存缓存队列 = 缓存队列;
Dictionary <string, DateTime> 缓存缓存创建时间 = 缓存创建时间;
try
{
if (缓存缓存创建时间.TryGetValue(key, out DateTime Cache))
{
TimeSpan TS = DateTime.Now - Cache;
if ((TS.TotalSeconds < ExTime || ExTime == 0) && 缓存缓存队列.TryGetValue(key, out string CacheData))
{
data = CacheData;
InfoLog.InfoPrintf("缓存命中,读取数据:" + key + "|" + CacheData, InfoLog.InfoClass.Debug);
缓存缓存队列.Clear();
缓存缓存创建时间.Clear();
return(true);
}
else
{
InfoLog.InfoPrintf("命中缓存，但数据已过期，返回false:" + key, InfoLog.InfoClass.Debug);
缓存缓存队列.Clear();
缓存缓存创建时间.Clear();
return(false);
}
}
缓存缓存队列.Clear();
缓存缓存创建时间.Clear();
return(false);
}
catch (Exception ex)
{
InfoLog.InfoPrintf($"读缓存异常:{ex}", InfoLog.InfoClass.Debug);
缓存缓存队列.Clear();
缓存缓存创建时间.Clear();
return(false);
}
}
public static void 周期更新B站房间状态()
{
if (!是否正在更新房间信息)
{
是否正在更新房间信息 = true;
InfoLog.InfoPrintf("本地房间状态缓存更新开始", InfoLog.InfoClass.Debug);
switch (MMPU.数据源)
{
case 0:
{
使用vtbsAPI更新房间状态();
InfoLog.InfoPrintf("本地房间状态更新结束", InfoLog.InfoClass.Debug);
是否正在更新房间信息 = false;
break;
}
case 1:
{
//启动WS房间连接
是否正在更新房间信息 = false;
break;
}
case 2:
{
使用B站API更新房间状态();
InfoLog.InfoPrintf("当前阿B API调用次数为:" + DataCache.BilibiliApiCount, InfoLog.InfoClass.杂项提示);
InfoLog.InfoPrintf("本地房间状态更新结束", InfoLog.InfoClass.Debug);
是否正在更新房间信息 = false;
break;
}
default:
break;
}
是否正在更新房间信息 = false;
}
}
public static string 获取真实房间号(string roomID)
{
string CacheStr = "byROOMIDgetTRUEroomid";
if (DataCache.读缓存(CacheStr + roomID, 0, out string CacheData))
{
return(CacheData);
}
string roomHtml;
try
{
roomHtml = MMPU.使用WC获取网络内容("https://api.live.bilibili.com/room/v1/Room/get_info?id=" + roomID);
}
catch (Exception e)
{
InfoLog.InfoPrintf(roomID + "获取房间信息失败:" + e.Message, InfoLog.InfoClass.Debug);
return(null);
}
//从返回结果中提取真实房间号
try
{
JObject result = JObject.Parse(roomHtml);
string live_status = result["data"]["live_status"].ToString();
if (live_status != "1")
{
return("-1");
}
string roomid = result["data"]["room_id"].ToString();
DataCache.写缓存(CacheStr + roomID, roomid);
return(roomid);
}
catch
{
return(roomID);
}
}
public void 载结束提醒(bool 是否结束弹幕录制, string 提醒标题, DownIofoData DOL)
{
try
{
if (是否结束弹幕录制 && MMPU.录制弹幕 && MMPU.弹幕录制种类 == 2)
{
try
{
DOL.弹幕储存流.WriteLine("</i>");
DOL.弹幕储存流.Flush();//写入弹幕数据
}
catch (Exception)
{ }
if (DOL != DownIofo)
{
Clear(false, DownIofo);
}
Clear(false, DOL);
}
else
{
Clear(true, DOL);
}
}
catch (Exception) { }
InfoLog.InfoPrintf($"\r\n=============={提醒标题}================\r\n" +
$"主播名:{DOL.主播名称}" +
$"\r\n房间号:{DOL.房间_频道号}" +
$"\r\n标题:{DOL.标题}" +
$"\r\n开播时间:{MMPU.Unix转换为DateTime(DOL.开始时间.ToString())}" +
$"\r\n结束时间:{MMPU.Unix转换为DateTime(DOL.结束时间.ToString())}" +
$"\r\n保存路径:{DOL.文件保存路径}" +
$"\r\n下载任务类型:{(DOL.继承.是否为继承对象 ? "续下任务" : "新建下载任务")}" +
$"\r\n结束原因:{DOL.备注}" +
$"\r\n==============={提醒标题}===============\r\n", InfoLog.InfoClass.载必要提示);
}
new public static void start()
{
InitializeRoomConfigFile();
InitializeRoomList(0, false, false);
bilibili.start();
//youtube.start();
Task.Run(async() =>
{
InfoLog.InfoPrintf("开始周期轮询bilibili房间开播状态", InfoLog.InfoClass.Debug);
while (true)
{
try
{
刷新B站房间列表();
bilibili房间信息更新次数++;
await Task.Delay(5 * 1000).ConfigureAwait(false);
}
catch (Exception e)
{
InfoLog.InfoPrintf($"在常规主线程B2中发生严重错误，错误堆栈内容:\n{e}", InfoLog.InfoClass.系统错误信息);
}
}
});
//Task.Run(async () =>
//{
// InfoLog.InfoPrintf("开始周期轮询youtube频道开播状态", InfoLog.InfoClass.Debug);
// while (true)
// {
// 刷新youtube站房间列表();
// youtube房间信息更新次数++;
// await Task.Delay(5 * 1000).ConfigureAwait(false);
// }
//});
}
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(载对象);
}
public string Start(string 开始后显示的备注)
{
DownIofo.开始时间 = Gettime();
MMPU.DownList.Add(this);
int a = 0;
DownIofo.WC = new WebClient();
DownIofo.WC.Headers.Add("Accept: */*");
DownIofo.WC.Headers.Add("User-Agent: " + MMPU.UA.Ver.UA());
DownIofo.WC.Headers.Add("Accept-Language: zh-CN,zh;q=0.8,en;q=0.6,ja;q=0.4");
DownIofo.WC.DownloadFileCompleted += 载完成事件;
DownIofo.WC.DownloadProgressChanged += 载过程中事件;
DownIofo.WC.Headers.Add("Accept-Encoding: gzip, deflate, br");
DownIofo.WC.Headers.Add("Cache-Control: max-age=0");
DownIofo.WC.Headers.Add("Sec-Fetch-Mode: navigate");
DownIofo.WC.Headers.Add("Sec-Fetch-Site: none");
DownIofo.WC.Headers.Add("Sec-Fetch-User: ?1");
DownIofo.WC.Headers.Add("Upgrade-Insecure-Requests: 1");
DownIofo.WC.Headers.Add("Cache-Control: max-age=0");
DownIofo.WC.Headers.Add("Referer: https://www.bilibili.com/");
if (!string.IsNullOrEmpty(MMPU.Cookie))
{
DownIofo.WC.Headers.Add("Cookie", MMPU.Cookie);
}
if (!Directory.Exists(GetDirectoryName(DownIofo.文件保存路径)))
{
Directory.CreateDirectory(GetDirectoryName(DownIofo.文件保存路径));
}
// ReSharper restore AssignNullToNotNullAttribute
DownIofo.备注 = "等待接收直播数据流";
DownIofo.载状态 = true;
MMPU.判断网络路径是否存在 判断文件是否存在 = new MMPU.判断网络路径是否存在();
while (true)
{
Thread.Sleep(5000);
switch (DownIofo.平台)
{
case "bilibili":
if (!bilibili.根据房间号获取房间信息.是否正在直播(DownIofo.房间_频道号, true))
{
InfoLog.InfoPrintf(DownIofo.房间_频道号 + "房间:" + DownIofo.主播名称 + " 房间直播状态为False,取消建立新的下载任务", InfoLog.InfoClass.载必要提示);
DownIofo.载状态 = false;
DownIofo.备注 = "该房间未直播";
DownIofo.结束时间 = Convert.ToInt32((DateTime.Now - new DateTime(1970, 1, 1, 0, 0, 0, 0)).TotalSeconds);
MMPU.DownList.Remove(this);
return(null);
}
break;
case "主站视频":
break;
default:
DownIofo.载状态 = false;
DownIofo.结束时间 = Convert.ToInt32((DateTime.Now - new DateTime(1970, 1, 1, 0, 0, 0, 0)).TotalSeconds);
DownIofo.备注 = "不支持的平台";
MMPU.DownList.Remove(this);
return(null);
}
if (判断文件是否存在.判断(DownIofo.载地址, DownIofo.平台, DownIofo.房间_频道号))
{
break;
}
else
{
Thread.Sleep(5000);
switch (DownIofo.平台)
{
case "bilibili":
{
if (bilibili.根据房间号获取房间信息.是否正在直播(DownIofo.房间_频道号, true))
{
a++;
if (判断文件是否存在.判断(DownIofo.载地址, DownIofo.平台, DownIofo.房间_频道号))
{
//DownIofo.下载地址 = bilibili.根据房间号获取房间信息.下载地址(DownIofo.房间_频道号);
break;
}
else
{
DownIofo.载地址 = bilibili.根据房间号获取房间信息.载地址(DownIofo.房间_频道号);
if (判断文件是否存在.判断(DownIofo.载地址, DownIofo.平台, DownIofo.房间_频道号))
{
break;
}
else
{
DownIofo.备注 = "等待房间推流...";
Thread.Sleep(30000);
//return null;
}
}
}
else
{
InfoLog.InfoPrintf(DownIofo.房间_频道号 + "房间:" + DownIofo.主播名称 + " 房间未直播，下载任务取消", InfoLog.InfoClass.载必要提示);
DownIofo.载状态 = false;
DownIofo.备注 = "该房间未直播";
DownIofo.结束时间 = Convert.ToInt32((DateTime.Now - new DateTime(1970, 1, 1, 0, 0, 0, 0)).TotalSeconds);
MMPU.DownList.Remove(this);
if (DownIofo.继承.是否为继承对象)
{
//MMPU.弹窗.Add(3000, "重连任务取消", DownIofo.房间_频道号 + "，该房间未直播");
}
else
{
MMPU.弹窗.Add(3000, "下载任务取消", DownIofo.房间_频道号 + "，该房间未直播");
}
return(null);
}
break;
}
case "主站视频":
{
break;
}
}
}
}
DownIofo.开始时间 = Convert.ToInt32((DateTime.Now - new DateTime(1970, 1, 1, 0, 0, 0, 0)).TotalSeconds);
try
{
DownIofo.WC.DownloadFileTaskAsync(new Uri(DownIofo.载地址), DownIofo.文件保存路径);
InfoLog.InfoPrintf(DownIofo.主播名称 + "开始直播，建立下载任务\r\n==============建立下载任务================\r\n主播名:" + DownIofo.主播名称 + "\r\n房间号:" + DownIofo.房间_频道号 + "\r\n标题:" + DownIofo.标题 + "\r\n开播时间:" + MMPU.Unix转换为DateTime(DownIofo.开始时间.ToString()) + "\r\n保存路径:" + DownIofo.文件保存路径 + "\r\n下载任务类型:" + (DownIofo.继承.是否为继承对象 ? "续下任务" : "新建下载任务") + "\r\n===============建立下载任务===============\r\n", InfoLog.InfoClass.载必要提示);
if (MMPU.录制弹幕 && !DownIofo.继承.是否为继承对象)
{
DownIofo.弹幕储存流 = new StreamWriter(DownIofo.文件保存路径.Substring(0, DownIofo.文件保存路径.Length - 4) + (MMPU.弹幕录制种类 == 1 ? ".ass" : ".xml"));
DownIofo.礼物储存流 = new StreamWriter(DownIofo.文件保存路径 + ".txt");
DownIofo.阿B直播流对象.Connect(int.Parse(DownIofo.房间_频道号));
DownIofo.阿B直播流对象.MessageReceived += Listener_MessageReceived;
DownIofo.弹幕储存流.WriteLine(danmu.返回ASS字幕文件头(DownIofo.标题, DownIofo.房间_频道号, DownIofo.主播名称));
}
}
catch (WebException) {
DownIofo.备注 = "主播未推流，已结束直播";
DownIofo.载状态 = false;
return(null);
}
DownIofo.备注 = 开始后显示的备注;
DownIofo.载状态 = true;
return(DownIofo.文件保存路径);
}
public static void BiliUser配置文件初始化(int 模式)
{
//账号登陆cookie
try
{
MMPU.Cookie = Encryption.UnAesStr(MMPU.读ini配置文件("User", "Cookie", MMPU.BiliUserFile), MMPU.AESKey, MMPU.AESVal);
if (!MMPU.Cookie.Contains("=") || !MMPU.Cookie.Contains(";"))
{
MMPU.Cookie = "";
MMPU.写ini配置文件("User", "Cookie", "", MMPU.BiliUserFile);
MMPU.csrf = null;
MMPU.写ini配置文件("User", "csrf", "", MMPU.BiliUserFile);
}
}
catch (Exception)
{
Console.WriteLine("读取cookie缓存错误");
MMPU.Cookie = "";
MMPU.写ini配置文件("User", "Cookie", "", MMPU.BiliUserFile);
}
//账号UID
MMPU.UID = MMPU.读ini配置文件("User", "UID", MMPU.BiliUserFile); //string.IsNullOrEmpty(MMPU.读取exe默认配置文件("UID", "")) ? null : MMPU.读取exe默认配置文件("UID", "");
//账号登陆cookie的有效期
try
{
if (!string.IsNullOrEmpty(MMPU.读ini配置文件("User", "CookieEX", MMPU.BiliUserFile)))
{
MMPU.CookieEX = DateTime.Parse(MMPU.读ini配置文件("User", "CookieEX", MMPU.BiliUserFile));
if (DateTime.Compare(DateTime.Now, MMPU.CookieEX) > 0)
{
MMPU.Cookie = "";
if (模式 == 0)
{
//MessageBox.Show("BILIBILI账号登陆已过期");
MMPU.写ini配置文件("User", "Cookie", "", MMPU.BiliUserFile);
MMPU.csrf = null;
MMPU.写ini配置文件("User", "csrf", "", MMPU.BiliUserFile);
}
}
}
}
catch (Exception)
{
if (模式 == 0)
{
MMPU.写ini配置文件("User", "Cookie", "", MMPU.BiliUserFile);
}
MMPU.Cookie = null;
}
//账号csrf
if (string.IsNullOrEmpty(MMPU.Cookie))
{
InfoLog.InfoPrintf("\r\n===============================\r\nbilibili账号cookie为空或已过期，请更新BiliUser.ini信息\r\n===============================", InfoLog.InfoClass.载必要提示);
InfoLog.InfoPrintf("\r\n==============\r\nBiliUser.ini文件无效，请使用DDTV本体登陆成功后把DDTV本体里的BiliUser.ini文件覆盖无效的文件\r\n==============", InfoLog.InfoClass.载必要提示);
if (模式 == 1)
{
InfoLog.InfoPrintf("\r\n如果短信验证方式验证启动失败，请复制DDTV2本体中有效BiliUser.ini覆盖本地文件后重启DDTVLiveRec\r\n[======如果是非windows系统，请检查文件权限======]", InfoLog.InfoClass.载必要提示);
try
{
bilibili.BiliUser.登陆();
}
catch (Exception e)
{
Console.WriteLine(e.ToString());
}
while (string.IsNullOrEmpty(MMPU.Cookie))
{
InfoLog.InfoPrintf("\r\n请根据登陆验证提示操作", InfoLog.InfoClass.系统错误信息);
//InfoLog.InfoPrintf("\r\n阿B登陆验证失败！！！请重启DDTVLiveRec进行登陆验证", InfoLog.InfoClass.下载必要提示);
Thread.Sleep(10000);
}
}
}
else
{
if (模式 == 0)
{
if (!MMPU.加载网络房间方法.是否正在缓存)
{
new Task(() =>
{
加载网络房间方法.更新网络房间缓存();
}).Start();
}
}
}
MMPU.csrf = MMPU.读ini配置文件("User", "csrf", MMPU.BiliUserFile);
}
private static void Output(object sender, DataReceivedEventArgs e)
{
InfoLog.InfoPrintf(e.Data, InfoLog.InfoClass.载必要提示);
// Console.WriteLine(e.Data);
}
private static void Process_Exited(object sender, EventArgs e)
{
Process P = (Process)sender;
InfoLog.InfoPrintf("转码任务完成:" + P.StartInfo.Arguments, InfoLog.InfoClass.载必要提示);
}
public static void 更新网络房间缓存()
{
int A = 1;
new Task((() =>
{
是否正在缓存 = true;
// while(true)
{
try
{
InfoLog.InfoPrintf("开始更新网络房间缓存", InfoLog.InfoClass.Debug);
try
{
string roomHtml = "";
try
{
roomHtml = 返回网页内容_GET(VTBS.API.VTBS服务器CDN.VTBS_Url + "/v1/short", 8000);
InfoLog.InfoPrintf("网络房间缓存vtbs加载完成", InfoLog.InfoClass.Debug);
}
catch (Exception)
{
try
{
InfoLog.InfoPrintf("网络房间缓存vtbs加载失败", InfoLog.InfoClass.Debug);
roomHtml = 返回网页内容_GET("https://raw.githubusercontent.com/CHKZL/DDTV2/master/Auxiliary/DDcenter/vtbsroomlist.json", 12000);
InfoLog.InfoPrintf("网络房间缓存github加载完成", InfoLog.InfoClass.Debug);
}
catch (Exception)
{
InfoLog.InfoPrintf("网络房间缓存github加载失败", InfoLog.InfoClass.Debug);
roomHtml = File.ReadAllText("VtbsList.json");
}
}
JArray result = JArray.Parse(roomHtml);
InfoLog.InfoPrintf("网络房间缓存下载完成，开始预处理", InfoLog.InfoClass.Debug);
列表缓存2.Clear();
foreach (var item in result)
{
if (int.Parse(item["roomid"].ToString()) != 0)
{
列表缓存2.Add(new 列表加载缓存
{
编号 = A,
roomId = item["roomid"].ToString(),
称 = item["uname"].ToString(),
官方名称 = item["uname"].ToString(),
平台 = "bilibili",
UID = item["mid"].ToString(),
类型 = "V"
});
A++;
}
else
{
;
}
}
列表缓存1 = 列表缓存2;
//foreach (var item in result["vtbs"])
//{
// foreach (var x in item["accounts"])
// {
// try
// {
// string name = item["name"][item["name"]["default"].ToString()].ToString();
// if (x["platform"].ToString() == "bilibili")
// {
// 列表缓存.Add(new 列表加载缓存
// {
// 编号 = A,
// 名称 = name,
// 官方名称 = name,
// 平台 = "bilibili",
// UID = x["id"].ToString(),
// 类型 = x["type"].ToString()
// });
// A++;
// }
// //else if (x["platform"].ToString() == "youtube")
// //{
// // 列表缓存.Add(new 列表加载缓存
// // {
// // 编号 = A,
// // 名称 = name,
// // 官方名称 = name,
// // 平台 = "youtube",
// // UID = x["id"].ToString(),
// // 类型 = x["type"].ToString()
// // });
// // A++;
// //}
// }
// catch (Exception)
// {
// 是否正在缓存 = false;
// //throw;
// }
// }
//}
}
catch (Exception)
{
是否正在缓存 = false;
}
是否正在缓存 = false;
InfoLog.InfoPrintf("网络房间缓存更新成功", InfoLog.InfoClass.Debug);
}
catch (Exception)
{
是否正在缓存 = false;
}
// Thread.Sleep(300000);
}
//this.Dispatcher.Invoke(new Action(delegate
//{
// 选中内容展示.Content = "";
// 更新网络房间列表.IsEnabled = true;
//}));
})).Start();
}
public static string FlvSum(Flv A, bool 是否直播结束)
{
List <string> DelFileList = new List <string>();
String path1 = A.File1Url;
String path2 = A.File2Url;
if (!File.Exists(path1))
{
InfoLog.InfoPrintf("续录文件[" + path1 + "]文件不存在，不符合合并条件，文件合并取消", InfoLog.InfoClass.Debug);
return(null);
}
else if (!File.Exists(path2))
{
InfoLog.InfoPrintf("续录文件[" + path2 + "]文件不存在，不符合合并条件，文件合并取消", InfoLog.InfoClass.Debug);
return(null);
}
string output = "";
if (是否直播结束)
{
string file = A.File1Url.Replace("_202", "⒂").Split('⒂')[0];
if (file.Substring(file.Length - 4, 4) == ".flv")
{
file = file.Substring(0, file.Length - 4);
}
if (!string.IsNullOrEmpty(file))
{
output = file + $"_{DateTime.Now.ToString("yyyyMMddHHmmssfff")}合并.flv";
}
else
{
string T1 = A.File1Url.Replace("_202", "⒂").Split('⒂')[0];
if (T1.Substring(T1.Length - 4, 4) == ".flv")
{
T1 = T1.Substring(0, T1.Length - 4);
}
if (!string.IsNullOrEmpty(T1))
{
output = T1 + $"_{DateTime.Now.ToString("yyyyMMddHHmmssfff")}合并.flv";
}
else
{
output = $"_{new Random().Next(10000,99999)}合并.flv";
}
}
}
else
{
output = A.File1Url.Replace("_202", "⒂").Split('⒂')[0] + "_" + DateTime.Now.ToString("yyyyMMddHHmmssfff") + ".flv";
}
if (File.Exists(output))
{
output.Replace(".flv", new Random().Next(1000, 9999) + ".flv");
}
using (FileStream fs1 = new FileStream(path1, FileMode.Open))
using (FileStream fs2 = new FileStream(path2, FileMode.Open))
//using (FileStream fs3 = new FileStream(path3, FileMode.Open))
using (FileStream fsMerge = new FileStream(output, FileMode.Create))
{
if (GetFLVFileInfo(fs1) != null && GetFLVFileInfo(fs2) != null)
{
if (IsSuitableToMerge(GetFLVFileInfo(fs1), GetFLVFileInfo(fs2)) == false
)//|| IsSuitableToMerge(GetFLVFileInfo(fs1), GetFLVFileInfo(fs3)) == false)
{
InfoLog.InfoPrintf("1该视频不适合合并，放弃合并", InfoLog.InfoClass.载必要提示);
return(null);
}
int time = Merge(fs1, fsMerge, true, 0);
time = Merge(fs2, fsMerge, false, time);
//time = Merge(fs3, fsMerge, false, time);
InfoLog.InfoPrintf("续录文件[" + output + "]合并完成", InfoLog.InfoClass.载必要提示);
fs1.Close();
fs1.Dispose();
fs2.Close();
fs2.Dispose();
fsMerge.Close();
fsMerge.Dispose();
//if (是否直播结束)
//{
// try
// {
// 转码(output);
// }
// catch (Exception)
// {
// }
//}
//else
//{
// GC.Collect();
//}
return(output);
}
else
{
InfoLog.InfoPrintf("2该视频不适合合并，放弃合并", InfoLog.InfoClass.载必要提示);
return(null);
}
}
}
public static int 启动模式 = 0;//0：DDTV,1：DDTVLive
/// <summary>
/// 配置文件初始化
/// </summary>
/// <param name="模式">//0：DDTV,1：DDTVLive</param>
public static bool 配置文件初始化(int 模式)
{
if (模式 == 0)
{
InfoLog.InfoInit("./DDTVLog.out", new InfoLog.InfoClasslBool()
{
Debug = false,
载必要提示 = true,
杂项提示 = false,
系统错误信息 = true,
输出到文件 = false
});
启动模式 = 0;
}
else if (模式 == 1)
{
InfoLog.InfoInit("./DDTVLiveRecLog.out", new InfoLog.InfoClasslBool()
{
Debug = false,
载必要提示 = true,
杂项提示 = false,
系统错误信息 = true,
输出到文件 = true
});
启动模式 = 1;
}
InfoLog.InfoPrintf("消息系统初始化完成", InfoLog.InfoClass.Debug);
#region 配置文件设置
if (模式 == 0)
{
//默认音量
MMPU.默认音量 = int.Parse(MMPU.读取exe默认配置文件("DefaultVolume", "50"));
//缩小功能
MMPU.缩小功能 = int.Parse(MMPU.读取exe默认配置文件("Zoom", "1"));
//最大直播并行数量
MMPU.最大直播并行数量 = int.Parse(MMPU.读取exe默认配置文件("PlayNum", "5"));
//默认弹幕颜色
MMPU.默认弹幕颜色 = MMPU.读取exe默认配置文件("DanMuColor", "0xFF, 0x00, 0x00, 0x00");
//默认字幕颜色
MMPU.默认字幕颜色 = MMPU.读取exe默认配置文件("ZiMuColor", "0xFF, 0x00, 0x00, 0x00");
//默认字幕大小
MMPU.默认字幕大小 = int.Parse(MMPU.读取exe默认配置文件("ZiMuSize", "24"));
//默认弹幕大小
MMPU.默认弹幕大小 = int.Parse(MMPU.读取exe默认配置文件("DanMuSize", "20"));
//默认弹幕大小
MMPU.播放缓冲时长 = int.Parse(MMPU.读取exe默认配置文件("BufferDuration", "3"));
//直播缓存目录
MMPU.直播缓存目录 = MMPU.读取exe默认配置文件("Livefile", "./tmp/LiveCache/");
//播放窗口默认高度
MMPU.播放器默认高度 = int.Parse(MMPU.读取exe默认配置文件("PlayWindowH", "450"));
//播放窗口默认宽度
MMPU.播放器默认宽度 = int.Parse(MMPU.读取exe默认配置文件("PlayWindowW", "800"));
//剪切板监听
MMPU.剪贴板监听 = MMPU.读取exe默认配置文件("ClipboardMonitoring", "0") == "0" ? false : true;
}
else if (模式 == 1)
{
}
//检查配置文件
bilibili.BiliUser.CheckPath(MMPU.BiliUserFile);
//房间配置文件
RoomInit.RoomConfigFile = MMPU.读取exe默认配置文件("RoomConfiguration", "./RoomListConfig.json");
//房间配置文件
MMPU.载储存目录 = MMPU.读取exe默认配置文件("file", "./tmp/");
//直播表刷新默认间隔
MMPU.直播列表刷新间隔 = int.Parse(MMPU.读取exe默认配置文件("LiveListTime", "5"));
//直播更新时间
MMPU.直播更新时间 = int.Parse(MMPU.读取exe默认配置文件("RoomTime", "40"));
//转码功能使能
MMPU.转码功能使能 = MMPU.读取exe默认配置文件("AutoTranscoding", "0") == "1" ? true : false;
#endregion
InfoLog.InfoPrintf("通用配置加载完成", InfoLog.InfoClass.Debug);
#region BiliUser配置文件初始化
//账号登陆cookie
try
{
MMPU.Cookie = string.IsNullOrEmpty(MMPU.读ini配置文件("User", "Cookie", MMPU.BiliUserFile)) ? "" : Encryption.UnAesStr(MMPU.读ini配置文件("User", "Cookie", MMPU.BiliUserFile), MMPU.AESKey, MMPU.AESVal);
}
catch (Exception)
{
MMPU.Cookie = "";
}
//账号UID
MMPU.UID = MMPU.读ini配置文件("User", "UID", MMPU.BiliUserFile); //string.IsNullOrEmpty(MMPU.读取exe默认配置文件("UID", "")) ? null : MMPU.读取exe默认配置文件("UID", "");
//账号登陆cookie的有效期
try
{
if (!string.IsNullOrEmpty(MMPU.读ini配置文件("User", "CookieEX", MMPU.BiliUserFile)))
{
MMPU.CookieEX = DateTime.Parse(MMPU.读ini配置文件("User", "CookieEX", MMPU.BiliUserFile));
if (DateTime.Compare(DateTime.Now, MMPU.CookieEX) > 0)
{
MMPU.Cookie = "";
if (模式 == 0)
{
//MessageBox.Show("BILIBILI账号登陆已过期");
MMPU.写ini配置文件("User", "Cookie", "", MMPU.BiliUserFile);
MMPU.csrf = null;
MMPU.写ini配置文件("User", "csrf", "", MMPU.BiliUserFile);
}
}
}
}
catch (Exception)
{
if (模式 == 0)
{
MMPU.写ini配置文件("User", "Cookie", "", MMPU.BiliUserFile);
}
MMPU.Cookie = null;
}
//账号csrf
if (string.IsNullOrEmpty(MMPU.Cookie))
{
InfoLog.InfoPrintf("\r\n==========================================\r\nbilibili账号cookie为空或已过期，请更新BiliUser.ini信息\r\n==========================================", InfoLog.InfoClass.载必要提示);
InfoLog.InfoPrintf("\r\n==========================================\r\nbilibili账号cookie为空或已过期，请更新BiliUser.ini信息\r\n==========================================", InfoLog.InfoClass.载必要提示);
InfoLog.InfoPrintf("\r\n==========================================\r\nbilibili账号cookie为空或已过期，请更新BiliUser.ini信息\r\n==========================================", InfoLog.InfoClass.载必要提示);
if (模式 == 1)
{
bilibili.BiliUser.登陆();
InfoLog.InfoPrintf("\r\nB站账号登陆信息过期或无效,启动失败，请自行打开目录中的[BiliQR.png]或访问[http://本机IP:11419/login]使用B站客户端扫描二维码登陆", InfoLog.InfoClass.载必要提示);
while (string.IsNullOrEmpty(MMPU.Cookie))
{
// break;
}
}
}
MMPU.csrf = MMPU.读ini配置文件("User", "csrf", MMPU.BiliUserFile);
#endregion
InfoLog.InfoPrintf("Bilibili账号信息加载完成", InfoLog.InfoClass.Debug);
//初始化房间
RoomInit.start();
return(true);
}
/// <summary>
///
/// </summary>
/// <param name="url">目标路径</param>
/// <param name="P">平台</param>
/// <returns></returns>
public bool 判断(string url, string P, string roomId)
{
try
{
switch (P)
{
case "bilibili":
{
HttpWebRequest httpWebRequest = (HttpWebRequest)WebRequest.CreateDefault(new Uri(url));
httpWebRequest.Accept = "*/*";
httpWebRequest.UserAgent = MMPU.UA.Ver.UA();
httpWebRequest.Headers.Add("Accept-Language: zh-CN,zh;q=0.8,en;q=0.6,ja;q=0.4");
if (!string.IsNullOrEmpty(MMPU.Cookie))
{
httpWebRequest.Headers.Add("Cookie", MMPU.Cookie);
}
httpWebRequest.Timeout = 3000;
//返回响应状态是否是成功比较的布尔值
if (((HttpWebResponse)httpWebRequest.GetResponse()).StatusCode == HttpStatusCode.OK)
{
}
InfoLog.InfoPrintf("判断文件存在", InfoLog.InfoClass.杂项提示);
return(true);
}
case "主站视频":
return(true);
default:
return(false);
}
}
//catch (WebException e)
//{
// if(e.Status== WebExceptionStatus.Timeout)
// {
// return true;
// }
// return false;
//}
catch (Exception)
{
InfoLog.InfoPrintf("判断文件不存在", InfoLog.InfoClass.杂项提示);
return(false);
//if (E.Message.Contains("404"))
//{
// InfoLog.InfoPrintf("判断文件不存在", InfoLog.InfoClass.杂项提示);
// return false;
//}
//else if (E.Message.Contains("475"))
//{
// InfoLog.InfoPrintf("判断文件不存在", InfoLog.InfoClass.杂项提示);
// return false;
//}
//else
//{
// return true;
//}
}
}
public static void 更新网络房间缓存()
{
int A = 1;
new Task((() =>
{
InfoLog.InfoPrintf("开始更新网络房间缓存", InfoLog.InfoClass.Debug);
try
{
var wc = new WebClient();
wc.Headers.Add("Accept: */*");
wc.Headers.Add("Accept-Language: zh-CN,zh;q=0.8,en;q=0.6,ja;q=0.4");
string roomHtml = wc.DownloadString("https://gitee.com/SYXM/vdb/raw/master/vdbList.txt");
var result = JObject.Parse(roomHtml);
InfoLog.InfoPrintf("网络房间缓存下载完成，开始预处理", InfoLog.InfoClass.Debug);
foreach (var item in result["vtbs"])
{
foreach (var x in item["accounts"])
{
try
{
string name = item["name"][item["name"]["default"].ToString()].ToString();
if (x["platform"].ToString() == "bilibili")
{
列表缓存.Add(new 列表加载缓存
{
编号 = A,
称 = name,
官方名称 = name,
平台 = "bilibili",
UID = x["id"].ToString(),
类型 = x["type"].ToString()
});
A++;
}
//else if (x["platform"].ToString() == "youtube")
//{
// 列表缓存.Add(new 列表加载缓存
// {
// 编号 = A,
// 名称 = name,
// 官方名称 = name,
// 平台 = "youtube",
// UID = x["id"].ToString(),
// 类型 = x["type"].ToString()
// });
// A++;
//}
}
catch (Exception)
{
//throw;
}
}
}
}
catch (Exception)
{
;
}
InfoLog.InfoPrintf("网络房间缓存更新成功", InfoLog.InfoClass.Debug);
//this.Dispatcher.Invoke(new Action(delegate
//{
// 选中内容展示.Content = "";
// 更新网络房间列表.IsEnabled = true;
//}));
})).Start();
}
public static int 启动模式 = 0;//0：DDTV,1：DDTVLive
/// <summary>
/// 配置文件初始化
/// </summary>
/// <param name="模式">//0：DDTV,1：DDTVLive</param>
public static bool 配置文件初始化(int 模式)
{
ServicePointManager.SecurityProtocol = SecurityProtocolType.Tls12; //加上这一句
if (模式 == 0)
{
InfoLog.InfoInit("./DDTVLog.out", new InfoLog.InfoClasslBool()
{
Debug = false,
载必要提示 = true,
杂项提示 = true,
系统错误信息 = true,
输出到文件 = false
});
启动模式 = 0;
}
else if (模式 == 1)
{
InfoLog.InfoInit("./DDTVLiveRecLog.out", new InfoLog.InfoClasslBool()
{
Debug = false,
载必要提示 = true,
杂项提示 = false,
系统错误信息 = true,
输出到文件 = true
});
启动模式 = 1;
}
InfoLog.InfoPrintf("消息系统初始化完成", InfoLog.InfoClass.Debug);
#region 配置文件设置
if (模式 == 0)
{
//默认音量
MMPU.默认音量 = int.Parse(MMPU.读取exe默认配置文件("DefaultVolume", "50"));
//缩小功能
MMPU.缩小功能 = int.Parse(MMPU.读取exe默认配置文件("Zoom", "1"));
//最大直播并行数量
MMPU.最大直播并行数量 = int.Parse(MMPU.读取exe默认配置文件("PlayNum", "5"));
//默认弹幕颜色
MMPU.默认弹幕颜色 = MMPU.读取exe默认配置文件("DanMuColor", "0xFF,0x00,0x00,0x00");
//默认字幕颜色
MMPU.默认字幕颜色 = MMPU.读取exe默认配置文件("ZiMuColor", "0xFF,0x00,0x00,0x00");
//默认字幕大小
MMPU.默认字幕大小 = int.Parse(MMPU.读取exe默认配置文件("ZiMuSize", "24"));
//默认弹幕大小
MMPU.默认弹幕大小 = int.Parse(MMPU.读取exe默认配置文件("DanMuSize", "20"));
//默认弹幕大小
MMPU.播放缓冲时长 = int.Parse(MMPU.读取exe默认配置文件("BufferDuration", "3"));
//直播缓存目录
MMPU.直播缓存目录 = MMPU.读取exe默认配置文件("Livefile", "./tmp/LiveCache/");
//播放窗口默认高度
MMPU.播放器默认高度 = int.Parse(MMPU.读取exe默认配置文件("PlayWindowH", "450"));
//播放窗口默认宽度
MMPU.播放器默认宽度 = int.Parse(MMPU.读取exe默认配置文件("PlayWindowW", "800"));
//剪切板监听
MMPU.剪贴板监听 = MMPU.读取exe默认配置文件("ClipboardMonitoring", "0") == "0" ? false : true;
//数据源
MMPU.数据源 = int.Parse(MMPU.读取exe默认配置文件("DataSource", "0"));
//第一次使用DDTV
MMPU.是否第一次使用DDTV = MMPU.读取exe默认配置文件("IsFirstTimeUsing", "1") == "0" ? false :true;
}
else if (模式 == 1)
{
}
//转码功能使能
MMPU.转码功能使能 = MMPU.读取exe默认配置文件("AutoTranscoding", "0") == "1" ? true : false;
//检查配置文件
bilibili.BiliUser.CheckPath(MMPU.BiliUserFile);
//房间配置文件
RoomInit.RoomConfigFile = MMPU.读取exe默认配置文件("RoomConfiguration", "./RoomListConfig.json");
//房间配置文件
MMPU.载储存目录 = MMPU.读取exe默认配置文件("file", "./tmp/");
//直播表刷新默认间隔
MMPU.直播列表刷新间隔 = int.Parse(MMPU.读取exe默认配置文件("LiveListTime", "5"));
//直播更新时间
MMPU.直播更新时间 = int.Parse(MMPU.读取exe默认配置文件("RoomTime", "40"));
#endregion
InfoLog.InfoPrintf("通用配置加载完成", InfoLog.InfoClass.Debug);
BiliUser配置文件初始化(模式);
InfoLog.InfoPrintf("Bilibili账号信息加载完成", InfoLog.InfoClass.Debug);
ServicePointManager.ServerCertificateValidationCallback += (sender, cert, chain, sslPolicyErrors) => true;
if (MMPU.数据源 == 0)
{
DDcenter.DdcClient.Connect();
}
RoomInit.start();
return(true);
}
public static void 更新网络房间缓存()
{
int A = 1;
new Task((() =>
{
是否正在缓存 = true;
// while(true)
{
try
{
InfoLog.InfoPrintf("开始更新网络房间缓存", InfoLog.InfoClass.Debug);
try
{
string roomHtml = "";
try
{
roomHtml = 返回网页内容_GET("https://vdb.vtbs.moe/json/list.json", 8000);
InfoLog.InfoPrintf("网络房间缓存vtbs加载完成", InfoLog.InfoClass.Debug);
}
catch (Exception e1)
{
try
{
InfoLog.InfoPrintf("网络房间缓存vtbs加载失败", InfoLog.InfoClass.Debug);
roomHtml = 返回网页内容_GET("https://raw.githubusercontent.com/CHKZL/DDTV2/master/Auxiliary/DDcenter/list.json", 12000);
InfoLog.InfoPrintf("网络房间缓存github加载完成", InfoLog.InfoClass.Debug);
}
catch (Exception e2)
{
InfoLog.InfoPrintf("网络房间缓存github加载失败", InfoLog.InfoClass.Debug);
roomHtml = File.ReadAllText("AddList.json");
}
}
var result = JObject.Parse(roomHtml);
InfoLog.InfoPrintf("网络房间缓存下载完成，开始预处理", InfoLog.InfoClass.Debug);
foreach (var item in result["vtbs"])
{
foreach (var x in item["accounts"])
{
try
{
string name = item["name"][item["name"]["default"].ToString()].ToString();
if (x["platform"].ToString() == "bilibili")
{
列表缓存.Add(new 列表加载缓存
{
编号 = A,
称 = name,
官方名称 = name,
平台 = "bilibili",
UID = x["id"].ToString(),
类型 = x["type"].ToString()
});
A++;
}
//else if (x["platform"].ToString() == "youtube")
//{
// 列表缓存.Add(new 列表加载缓存
// {
// 编号 = A,
// 名称 = name,
// 官方名称 = name,
// 平台 = "youtube",
// UID = x["id"].ToString(),
// 类型 = x["type"].ToString()
// });
// A++;
//}
}
catch (Exception e)
{
是否正在缓存 = false;
//throw;
}
}
}
}
catch (Exception e)
{
是否正在缓存 = false;
}
是否正在缓存 = false;
InfoLog.InfoPrintf("网络房间缓存更新成功", InfoLog.InfoClass.Debug);
}
catch (Exception)
{
是否正在缓存 = false;
}
// Thread.Sleep(300000);
}
//this.Dispatcher.Invoke(new Action(delegate
//{
// 选中内容展示.Content = "";
// 更新网络房间列表.IsEnabled = true;
//}));
})).Start();
}
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(() =>
{
string 载地址 = bilibili.根据房间号获取房间信息.载地址(之前的状态.唯一码);
if (string.IsNullOrEmpty(载地址))
{
InfoLog.InfoPrintf("解析下载地址失败，一般是该房间未开播或已加密", InfoLog.InfoClass.载必要提示);
return;
}
Downloader DLL = Downloader.新建下载对象(之前的状态.平台, 之前的状态.唯一码, bilibili.根据房间号获取房间信息.获取标题(之前的状态.唯一码), Guid.NewGuid().ToString(), 载地址, "自动录制", true, 最新的状态.称 + "-" + 最新的状态.原名, false, null);
if (DLL != null)
{
if (string.IsNullOrEmpty(DLL.DownIofo.备注))
{
DLL.DownIofo.备注 = "新建自动录制任务..等待数据..";
}
}
}).Start();
}
break;
}
}
int B = 之前的bilibili房间主表状态.Count();
临时主表.Add(new RL {
称 = 最新的状态.称, 唯一码 = 最新的状态.房间号, 平台 = "bilibili", 是否录制 = 最新的状态.是否录制视频, 是否提醒 = 最新的状态.是否提醒, 直播状态 = 最新的状态.直播状态, 原名 = 最新的状态.原名
});
}
bilibili房间主表.Clear();
foreach (var item in 临时主表)
{
bilibili房间主表.Add(item);
}
bilibili房间主表长度 = bilibili房间主表.Count();
B站更新刷新次数++;
}
// 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.继承.待合并文件列表.Add(DownIofo.文件保存路径);
InfoLog.InfoPrintf($"{DownIofo.房间_频道号}:{DownIofo.主播名称}下载任务续下，历史文件加入待合并文件列表:{DownIofo.文件保存路径}", InfoLog.InfoClass.载必要提示);
}
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();
}
public static RoomInit.RoomInfo GetRoomInfo(string originalRoomId)
{
//发送HTTP请求
string roomHtml;
try
{
roomHtml = MMPU.返回网页内容_GET("https://www.youtube.com/channel/" + originalRoomId + "/live");
}
catch (Exception e)
{
InfoLog.InfoPrintf(originalRoomId + "获取房间信息失败:" + e.Message, InfoLog.InfoClass.Debug);
return(null);
}
//解析返回结果
try
{
string tltie = "";
try
{
tltie = roomHtml.Replace("\\\"title\\\":\\\"", "⒆").Split('⒆')[1].Replace("\\\",\\\"", "⒆").Split('⒆')[0];
}
catch (Exception)
{
}
RoomInit.RoomInfo roominfo = new RoomInit.RoomInfo()
{
房间号 = originalRoomId,
标题 = tltie,
直播状态 = false,
UID = originalRoomId,
直播开始时间 = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss"),
平台 = "youtube",
youtubeVideoId = roomHtml.Replace(":{\\\"videoId\\\":\\\"", "⒆").Split('⒆')[1].Replace("\\\",", "⒆").Split('⒆')[0]
};
try
{
// Console.WriteLine(roomHtml);
string BC = roomHtml.Replace("(window.ytcsi) {window.ytcsi.tick(\"cfg\", null, '')", "⒆").Split('⒆')[1].Replace("</div>", "⒆").Split('⒆')[0];
if (BC.Contains("\\\"isLive\\\":true"))
{
roominfo.直播状态 = true;
}
else
{
roominfo.直播状态 = false;
}
}
catch (Exception)
{
roominfo.直播状态 = false;
}
InfoLog.InfoPrintf("获取到房间信息:" + roominfo.UID + " " + (roominfo.直播状态 ? "已开播" : "未开播") + " " + (roominfo.直播状态 ? "开播时间:" + roominfo.直播开始时间 : ""), InfoLog.InfoClass.Debug);
return(roominfo);
}
catch (Exception e)
{
InfoLog.InfoPrintf(originalRoomId + "房间信息解析失败:" + e.Message, InfoLog.InfoClass.Debug);
return(null);
}
}
/// <summary>
/// 初始化房间列表
/// </summary>
/// <param name="roomId">有变动的房间号</param>
/// <param name="R">是否是删除操作</param>
public static void InitializeRoomList(int roomId, bool Rem, bool Rst)
{
//if(Rst)
//{
// 首次启动 = true;
// foreach (var BWSitem in biliWebSocket)
// {
// BWSitem.listener.Close();
// BWSitem.listener.Dispose();
// biliWebSocket.Remove(BWSitem);
// }
//}
//if (roomId > 0)
//{
// if(!Rem)
// {
// BiliWebSocket BWS = new BiliWebSocket();
// BWS.WebSocket(roomId);
// biliWebSocket.Add(BWS);
// }
// else
// {
// foreach (var item in biliWebSocket)
// {
// if(item.room_id==roomId)
// {
// item.listener.Close();
// item.listener.Dispose();
// biliWebSocket.Remove(item);
// break;
// }
// }
// }
//}
InfoLog.InfoPrintf("开始刷新本地房间列表", InfoLog.InfoClass.Debug);
var rlc = new RoomBox();
try
{
rlc = JsonConvert.DeserializeObject <RoomBox>(ReadConfigFile(RoomConfigFile));
}
catch (Exception)
{
rlc = JsonConvert.DeserializeObject <RoomBox>("{}");
InfoLog.InfoPrintf("房间json配置文件格式错误！请检测核对！", InfoLog.InfoClass.系统错误信息);
InfoLog.InfoPrintf("房间json配置文件格式错误！请检测核对！", InfoLog.InfoClass.系统错误信息);
InfoLog.InfoPrintf("房间json配置文件格式错误！请检测核对！", InfoLog.InfoClass.系统错误信息);
return;
}
List <RoomCadr> RoomConfigList = new List <RoomCadr>();//房间信息1List
RoomConfigList = rlc?.data;
if (RoomConfigList == null)
{
RoomConfigList = new List <RoomCadr>();
}
bilibili.RoomList.Clear();
youtube.RoomList.Clear();
if (初始化储存房间储存一次)
{
string JOO = JsonConvert.SerializeObject(rlc);
MMPU.储存文本(JOO, RoomConfigFile);
初始化储存房间储存一次 = false;
}
foreach (var item in RoomConfigList)
{
if (item.Types == "bilibili")
{
//if(首次启动)
//{
// BiliWebSocket BWS = new BiliWebSocket();
// BWS.WebSocket(int.Parse(item.RoomNumber));
// biliWebSocket.Add(BWS);
//}
bilibili.RoomList.Add(new RoomInfo
{
房间号 = item.RoomNumber,
标题 = "",
是否录制弹幕 = item.VideoStatus,
是否录制视频 = item.VideoStatus,
UID = "",
直播开始时间 = "",
称 = item.Name,
直播状态 = item.LiveStatus,
原名 = item.OfficialName,
是否提醒 = item.RemindStatus,
平台 = "bilibili"
});
if (首次启动)
{
bilibili.RoomList[bilibili.RoomList.Count - 1].直播状态 = false;
}
}
else if (item.Types == "youtube")
{
youtube.RoomList.Add(new RoomInfo
{
房间号 = item.RoomNumber,
标题 = "",
是否录制弹幕 = item.VideoStatus,
是否录制视频 = item.VideoStatus,
UID = "",
直播开始时间 = "",
称 = item.Name,
直播状态 = item.LiveStatus,
原名 = item.OfficialName,
是否提醒 = item.RemindStatus,
平台 = "youtube"
});
if (首次启动)
{
youtube.RoomList[youtube.RoomList.Count - 1].直播状态 = false;
}
}
}
if (首次启动)
{
InfoLog.InfoPrintf("监控列表中有" + (bilibili.RoomList.Count() + youtube.RoomList.Count()) + "个单推对象，开始监控", InfoLog.InfoClass.载必要提示);
}
首次启动 = false;
InfoLog.InfoPrintf("刷新本地房间列表完成", InfoLog.InfoClass.Debug);
}
public void 更新正在直播数据()
{
string UURL = MMPU.TcpSend(30002, "{}", true);
string URL = string.IsNullOrEmpty(UURL)?"https://hiyoko.sonoj.net/dy-st/30s/6c6cb639-1d2f-4151-81c7-fd877700cf98.json": UURL;
JArray jo = (JArray)JsonConvert.DeserializeObject(MMPU.返回网页内容(URL));
for (int i = 0; i < jo.Count; i++)
{
JToken item = jo[i];
try
{
直播数据.Add(new 直播信息());
#region 实际开始时间
try
{
直播数据[直播数据.Count - 1].实际开始时间 = long.Parse(item["actual_start_time"].ToString());
}
catch (Exception)
{
直播数据[直播数据.Count - 1].实际开始时间 = 0;
}
#endregion
#region 频道ID
try
{
直播数据[直播数据.Count - 1].频道ID = item["ch_id"].ToString();
}
catch (Exception)
{
直播数据[直播数据.Count - 1].频道ID = "0";
}
#endregion
#region 频道类型
try
{
直播数据[直播数据.Count - 1].频道类型 = int.Parse(item["ch_type"].ToString());
}
catch (Exception)
{
直播数据[直播数据.Count - 1].频道类型 = 0;
}
#endregion
#region 称
try
{
直播数据[直播数据.Count - 1].称 = item["name"].ToString();
}
catch (Exception)
{
直播数据[直播数据.Count - 1].称 = "获取失败";
}
#endregion
#region 已直播时长_秒
try
{
直播数据[直播数据.Count - 1].已直播时长_秒 = int.Parse(item["seconds"].ToString());
}
catch (Exception)
{
直播数据[直播数据.Count - 1].已直播时长_秒 = 0;
}
#endregion
#region 已直播时长_日本时间
try
{
直播数据[直播数据.Count - 1].已直播时长_日本时间 = item["start_time_str"].ToString();
}
catch (Exception)
{
直播数据[直播数据.Count - 1].已直播时长_日本时间 = "null";
}
#endregion
#region 主播名称
try
{
直播数据[直播数据.Count - 1].主播名称 = item["streamer_name"].ToString();
}
catch (Exception)
{
直播数据[直播数据.Count - 1].主播名称 = "null";
}
#endregion
#region 标题
try
{
直播数据[直播数据.Count - 1].标题 = item["title"].ToString();
}
catch (Exception)
{
直播数据[直播数据.Count - 1].标题 = "null";
}
#endregion
#region 当前观众
try
{
直播数据[直播数据.Count - 1].当前观众 = item["viewers"].ToString();
}
catch (Exception)
{
直播数据[直播数据.Count - 1].当前观众 = "null";
}
#endregion
#region 频道相关信息
try
{
直播数据[直播数据.Count - 1].频道相关信息 = item["channel_misc"].ToString();
}
catch (Exception)
{
直播数据[直播数据.Count - 1].频道相关信息 = "null";
}
#endregion
#region 阿B房间号
try
{
直播数据[直播数据.Count - 1].阿B房间号 = item["desc"].ToString();
}
catch (Exception)
{
直播数据[直播数据.Count - 1].阿B房间号 = "null";
}
#endregion
直播数据[直播数据.Count() - 1].直播连接 = 根据频道类型返回直播地址(直播数据[直播数据.Count() - 1]);
}
catch (Exception ex)
{
InfoLog.InfoPrintf("外部API:正在直播的列表更新出现错误" + ex.ToString(), InfoLog.InfoClass.系统错误信息);
}
}
}
