public override void 保存至配置文件()
{
MMPU.默认字幕颜色 = 颜色字符串;
MMPU.setFiles("ZiMuColor", 颜色字符串);
MMPU.默认字幕大小 = 大小;
MMPU.setFiles("ZiMuSize", 大小.ToString());
}
private void 播放窗口退出事件(object sender, EventArgs e)
{
NewThreadTask.Run(() =>
{
MMPU.当前直播窗口数量--;
PlayW.MainWindow p = (PlayW.MainWindow)sender;
playList1.Remove(p);
foreach (var item in MMPU.DownList)
{
if (item.DownIofo.事件GUID == p.DD.DownIofo.事件GUID)
{
item.DownIofo.WC.CancelAsync();
item.DownIofo.载状态 = false;
item.DownIofo.备注 = "播放窗口关闭，停止下载";
item.DownIofo.结束时间 = Convert.ToInt32((DateTime.UtcNow - new DateTime(1970, 1, 1, 0, 0, 0, 0)).TotalSeconds);
if (item.DownIofo.是否保存)
{
}
else
{
MMPU.文件删除委托(p.DD.DownIofo.文件保存路径);
}
break;
}
}
});
}
private void 登录bilibili按钮_Click(object sender, RoutedEventArgs e)
{
if (!string.IsNullOrEmpty(MMPU.读ini配置文件("User", "Cookie", MMPU.BiliUserFile)))
{
登录bilibili提示文本1.Text = "您似乎已经登录";
登录bilibili提示文本2.Text = "正在初始化BiliUser配置文件，请稍候……";
MMPU.BiliUser配置文件初始化(0);
登录bilibili提示文本2.Text = "初始化BiliUser配置文件成功！请点击\"下一步\"";
登录bilibili按钮.IsEnabled = false;
return;
}
BiliLoginWindowQR BLW = new BiliLoginWindowQR();
BLW.ShowDialog();
if (!string.IsNullOrEmpty(MMPU.Cookie))
{
登录bilibili提示文本1.Text = "登录成功！";
登录bilibili提示文本2.Text = "请点击\"下一步\"";
登录bilibili按钮.IsEnabled = false;
}
else
{
登录bilibili提示文本1.Text = "登录失败，请重试";
}
}
private void 修改播放器默认大小确定按钮点击事件(object sender, RoutedEventArgs e)
{
MMPU.PlayWindowW = int.Parse(默认播放宽度.Text);
MMPU.setFiles("PlayWindowW", 默认播放宽度.Text);
MMPU.PlayWindowH = int.Parse(默认播放高度.Text);
MMPU.setFiles("PlayWindowH", 默认播放高度.Text);
System.Windows.MessageBox.Show("修改成功");
}
public void 打开直播列表(Downloader DL)
{
DL.DownIofo.播放状态 = true;
DL.DownIofo.是否是播放任务 = true;
PlayW.MainWindow PlayWindow = new PlayW.MainWindow(DL, MMPU.默认音量, 弹幕颜色, 字幕颜色, MMPU.默认弹幕大小, MMPU.默认字幕大小, MMPU.PlayWindowW, MMPU.PlayWindowH);
PlayWindow.Closed += 播放窗口退出事件;
PlayWindow.Show();
PlayWindow.BossKey += 老板键事件;
playList.Add(PlayWindow);
MMPU.ClearMemory();
}
private void 修改默认下载目录按钮事件(object sender, RoutedEventArgs e)
{
FolderBrowserDialog P_File_Folder = new FolderBrowserDialog();
if (P_File_Folder.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
MMPU.载储存目录 = P_File_Folder.SelectedPath;
默认下载路径.Text = MMPU.载储存目录;
MMPU.setFiles("file", MMPU.载储存目录);
}
}
private void 完成初始化()
{
//写配置文件
MMPU.setFiles("IsFirstTimeUsing", "0");
MMPU.setFiles("DataSource", _数据源.ToString());
MMPU.数据源 = _数据源;
MMPU.是否第一次使用DDTV = false;
//关闭此窗口
this.Close();
}
private void 修改字幕颜色按钮点击事件(object sender, RoutedEventArgs e)
{
System.Windows.Forms.ColorDialog colorDialog = new System.Windows.Forms.ColorDialog();
if (colorDialog.ShowDialog() == System.Windows.Forms.DialogResult.OK)
{
System.Drawing.SolidBrush sb = new System.Drawing.SolidBrush(colorDialog.Color);
SolidColorBrush solidColorBrush = new SolidColorBrush(Color.FromArgb(sb.Color.A, sb.Color.R, sb.Color.G, sb.Color.B));
字幕默认颜色.Foreground = solidColorBrush;
MMPU.默认字幕颜色 = solidColorBrush.Color.A.ToString("X2") + "," + solidColorBrush.Color.R.ToString("X2") + "," + solidColorBrush.Color.G.ToString("X2") + "," + solidColorBrush.Color.B.ToString("X2");
MMPU.setFiles("ZiMuColor", MMPU.默认字幕颜色);
字幕颜色 = solidColorBrush;
}
}
private void 主站列表_MouseDoubleClick(object sender, MouseButtonEventArgs e)
{
try
{
string person = 主站列表.SelectedItem.ToString();
if (person.Contains("\\|/"))
{
string BVID = person.Replace("\\|/", "⒆").Split('⒆')[0];
string cid = "";
string dlurl = "";
foreach (var item in BiliVideoInfo.VideoInfo.Info)
{
if (item.BV == BVID)
{
if (item.data.Count < 2)
{
cid = item.data[0].cid.ToString();
break;
}
}
}
JObject JO = JObject.Parse(MMPU.使用WC获取网络内容("https://api.bilibili.com/x/player/playurl?bvid=" + BVID + "&cid=" + cid + "&otype=json"));
if (JO["code"].ToString() == "0")
{
dlurl = JO["data"]["durl"][0]["url"].ToString();
Downloader 载对象 = new Downloader
{
DownIofo = new Downloader.DownIofoData()
{
平台 = "主站视频", 房间_频道号 = "", 标题 = person.Replace("\\|/", "⒆").Split('⒆')[1], 事件GUID = Guid.NewGuid().ToString(), 载地址 = dlurl, 备注 = "视频播放缓存", 是否保存 = false, 继承 = new Downloader.继承(), 是否是播放任务 = true
}
};
//Downloader 下载对象 = Downloader.新建下载对象(平台, 唯一码, 标题, GUID, 下载地址, "视频播放缓存", false);
Task.Run(() =>
{
this.Dispatcher.Invoke(new Action(delegate
{
打开直播列表(载对象);
MMPU.当前直播窗口数量++;
}));
});
}
}
}
catch (Exception)
{
MessageBox.Show("出现未知错误");
return;
}
}
public static void Connect()
{
new Task(() =>
{
try
{
MMPU.DDC采集间隔 = int.Parse(MMPU.TcpSend(30001, "{}", true));
}
catch (Exception)
{
MMPU.DDC采集间隔 = 1000;
}
DDC DDC = new DDC();
DDC.WebSocket();
}).Start();
}
/// <summary>
/// 初始化OneDrive
/// </summary>
private static void InitOneDrive()
{
enableOneDrive = MMPU.读取exe默认配置文件("EnableOneDrive", "0");
InfoLog.InfoPrintf($"配置文件初始化任务[EnableOneDrive]:{enableOneDrive}", InfoLog.InfoClass.Debug);
if (enableOneDrive != "0")
{
UploadOrderTemp.Add(int.Parse(enableOneDrive), "OneDrive");
CheckEnableUpload = true;
InfoLog.InfoPrintf($"已检测到OneDrive上传任务，上传顺序为{enableOneDrive}", InfoLog.InfoClass.必要提示);
oneDriveConfig = MMPU.读取exe默认配置文件("OneDriveConfig", "");
InfoLog.InfoPrintf($"配置文件初始化任务[oneDriveConfig]:{oneDriveConfig}", InfoLog.InfoClass.Debug);
oneDrivePath = MMPU.读取exe默认配置文件("OneDrivePath", "/");
MMPU.CheckPath(ref oneDrivePath);
InfoLog.InfoPrintf($"配置文件初始化任务[oneDrivePath]:{oneDrivePath}", InfoLog.InfoClass.Debug);
}
}
public static void Connect()
{
new Task(() =>
{
try
{
MMPU.DDC采集间隔 = int.Parse(MMPU.TcpSend(Server.RequestCode.GET_DDC_TIME_NUMBER, "{}", true, 50));
}
catch (Exception)
{
//如果服务器无响应或者返回内容错误，保守使用延迟
MMPU.DDC采集间隔 = 60000;
}
DDC DDC = new DDC();
DDC.WebSocket();
}).Start();
}
public static void Connect()
{
new Task(() =>
{
try
{
MMPU.DDC采集间隔 = int.Parse(MMPU.TcpSend(30001, "{}", true, 50));
}
catch (Exception)
{
//如果服务器无响应或者返回内容错误，保守使用延迟
MMPU.DDC采集间隔 = 60000;
}
DDC DDC = new DDC();
DDC.WebSocket();
}).Start();
}
public static void 根据CDN更新VTBS_Url()
{
new Task(() => {
string CDN_Url = MMPU.返回网页内容("https://api.tokyo.vtbs.moe/meta/cdn");
JArray JO = string.IsNullOrEmpty(CDN_Url) ? (JArray)JsonConvert.DeserializeObject("[]") : (JArray)JsonConvert.DeserializeObject(CDN_Url);
List <延迟对象> PING = new List <延迟对象>();
foreach (var item in JO)
{
PING.Add(new 延迟对象()
{
CDN_URL = item.ToString()
});
}
VTBS_Url = 返回延迟最低的连接(PING, 5);
InfoLog.InfoPrintf("获取到VTBS当前可用CDN为:" + VTBS_Url, InfoLog.InfoClass.Debug);
}).Start();
}
static void Main(string[] args)
{
Auxiliary.VTBS.API.VTBS服务器CDN.根据CDN更新VTBS_Url();
MMPU.配置文件初始化(1);
new Task(() =>
{
DDTVLiveRecWebServer.Program.Main(new string[] { });
}).Start();
new Task(() =>
{
while (true)
{
try
{
string 务器版本号 = MMPU.TcpSend(Server.RequestCode.GET_VER, "{}", true, 50);
if (!string.IsNullOrEmpty(务器版本号))
{
bool 检测状态 = true;
foreach (var item in MMPU.检测的版本号)
{
if (务器版本号 == item)
{
检测状态 = false;
}
}
if (MMPU.版本号 != 务器版本号 && 检测状态)
{
MMPU.更新公告 = MMPU.TcpSend(Server.RequestCode.GET_UPDATE_ANNOUNCEMENT, "{}", true, 100);
MMPU.是否有新版本 = true;
InfoLog.InfoPrintf("检测到版本更新,更新内容:\n" + MMPU.TcpSend(Server.RequestCode.GET_VERTEXT, "{}", true, 100) + "\n\n", InfoLog.InfoClass.载必要提示);
}
}
}
catch (Exception) { }
Thread.Sleep(3600 * 1000);
}
}).Start();
MMPU.缓存路径 = MMPU.载储存目录;
InfoLog.InfoPrintf(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") + ": " + "DDTVLiveRec启动完成", InfoLog.InfoClass.载必要提示);
while (true)
{
Thread.Sleep(10);
}
}
/// <summary>
/// 初始化房间列表
/// </summary>
public static void InitializeRoomList()
{
var rlc = new RoomBox();
rlc = JsonConvert.DeserializeObject <RoomBox>(ReadConfigFile(RoomConfigFile));
List <RoomCadr> RoomConfigList = new List <RoomCadr>();//房间信息1List
RoomConfigList = rlc?.data;
if (RoomConfigList == null)
{
RoomConfigList = new List <RoomCadr>();
}
bilibili.RoomList.Clear();
if (初始化储存房间储存一次)
{
string JOO = JsonConvert.SerializeObject(rlc);
MMPU.储存文本(JOO, RoomConfigFile);
初始化储存房间储存一次 = false;
}
foreach (var item in RoomConfigList)
{
if (item.Types == "bilibili")
{
bilibili.RoomList.Add(new bilibili.RoomInfo
{
房间号 = item.RoomNumber,
标题 = "",
是否录制弹幕 = item.VideoStatus,
是否录制视频 = item.VideoStatus,
UID = "",
直播开始时间 = "",
称 = item.Name,
直播状态 = item.LiveStatus,
原名 = item.OfficialName,
是否提醒 = item.RemindStatus
});
if (首次启动)
{
bilibili.RoomList[bilibili.RoomList.Count() - 1].直播状态 = false;
}
}
}
首次启动 = false;
}
static void Main(string[] args)
{
#if false
载("14275133");
#else
Auxiliary.VTBS.API.VTBS服务器CDN.根据CDN更新VTBS_Url();
MMPU.配置文件初始化(1);
new Task(() => {
DDTVLiveRecWebServer.Program.Main(new string[] { });
}).Start();
#endif
new Task(() =>
{
try
{
string 务器版本号 = MMPU.TcpSend(20013, "{}", true, 50);
if (!string.IsNullOrEmpty(务器版本号))
{
bool 检测状态 = true;
foreach (var item in MMPU.检测的版本号)
{
if (务器版本号 == item)
{
检测状态 = false;
}
}
if (MMPU.版本号 != 务器版本号 && 检测状态)
{
MMPU.是否有新版本 = true;
InfoLog.InfoPrintf("检测到版本更新,更新公告:\n" + MMPU.TcpSend(20014, "{}", true, 100) + "\n\n", InfoLog.InfoClass.载必要提示);
//Console.ReadKey();
}
}
}
catch (Exception) { }
}).Start();
MMPU.载储存目录 = MMPU.缓存路径;
InfoLog.InfoPrintf(DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss") + ": " + "DDTVLiveRec启动完成", InfoLog.InfoClass.载必要提示);
while (true)
{
Thread.Sleep(10);
}
}
private void 监控非VTB直播间使能按钮开关点击事件(object sender, RoutedEventArgs e)
{
if (监控非VTB直播间使能按钮.IsChecked == true)
{
NewThreadTask.Run(() =>
{
持续连接获取阿B房间信息类.初始化所有房间连接();
});
bilibili.是否启动WS连接组 = true;
MMPU.setFiles("NotVTBStatus", "1");
}
else
{
//bilibili.是否启动WS连接组 = false;
//MMPU.setFiles("NotVTBStatus", "0");
}
提示.Content = "监控非VTB直播间状态使能发生变化，需手动重启DDTV生效";
}
/// <summary>
/// 初始化上传信息
/// </summary>
/// <param name="downIofo">下载信息</param>
public UploadInfo(DownIofoData downIofo)
{
try
{
streamerName = downIofo.主播名称;
streamTitle = downIofo.标题;
srcFile = downIofo.文件保存路径;
fileName = System.IO.Path.GetFileName(srcFile);
fileSize = (double)new FileInfo(srcFile).Length;
remotePath = $"{downIofo.主播名称}_{downIofo.房间_频道号}/{MMPU.Unix转换为DateTime(downIofo.开始时间.ToString()).ToString("yyyyMMdd")}_{downIofo.标题}/";
type = null;
retries = 0;
}
catch
{
InfoLog.InfoPrintf($"创建{srcFile}上传任务失败，无法获取文件信息", InfoLog.InfoClass.系统错误信息);
throw new CreateUploadTaskFailure("fail to ctreate upload task");//处理获取文件名、文件大小的错误
}
}
private void 监控非VTB直播间使能按钮开关点击事件(object sender, RoutedEventArgs e)
{
if (监控非VTB直播间使能按钮.IsChecked == true)
{
//NewThreadTask.Run(() =>
//{
// 持续连接获取阿B房间信息类.初始化所有房间连接();
//});
bilibili.是否启动WSS连接组 = true;
MMPU.setFiles("NotVTBStatus", "1");
}
else
{
bilibili.是否启动WSS连接组 = false;
MMPU.setFiles("NotVTBStatus", "0");
}
提示.Content = "监控非VTB直播间状态使能发生变化，需手动重启DDTV生效";
MessageBox.Show("!!重要功能更改!!\r需手动重启DDTV生效，重要配置变化，不重启可能会出现未知错误");
}
public static void DDTV关闭事件()
{
MessageBoxResult dr = System.Windows.MessageBox.Show("确定退出DDTV？", "退出", MessageBoxButton.OKCancel, MessageBoxImage.Question);
if (dr == MessageBoxResult.OK)
{
new Thread(new ThreadStart(delegate
{
try
{
FileInfo[] files = new DirectoryInfo("./tmp/LiveCache/").GetFiles();
foreach (var item in files)
{
MMPU.文件删除委托("./tmp/LiveCache/" + item.Name);
}
}
catch (Exception)
{
}
Environment.Exit(0);
})).Start();
}
}
public static void 导入VTBVUP(Action <string> callback, System.Windows.Window W, bool 是否初始化)
{
NewThreadTask.Run(runOnLocalThread =>
{
try
{
if (string.IsNullOrEmpty(MMPU.Cookie))
{
callback("未登录，请先登录");
return;
}
MMPU.加载网络房间方法.更新网络房间缓存();
MMPU.加载网络房间方法.是否正在缓存 = true;
while (MMPU.加载网络房间方法.是否正在缓存)
{
Thread.Sleep(500);
}
if (是否初始化)
{
RoomInit.RoomConfigFile = MMPU.读取exe默认配置文件("RoomConfiguration", "./RoomListConfig.json");
RoomInit.InitializeRoomConfigFile();
RoomInit.InitializeRoomList(0, false, false);
}
int 增加的数量 = 0;
int 已经存在的数量 = 0;
RoomBox rlc = JsonConvert.DeserializeObject <RoomBox>(ReadConfigFile(RoomConfigFile));
RoomBox RB = new RoomBox
{
data = new List <RoomCadr>()
};
if (rlc.data != null)
{
foreach (var item in rlc.data)
{
RB.data.Add(item);
}
}
List <MMPU.加载网络房间方法.中的网络房间> 符合条件的房间 = new List <MMPU.加载网络房间方法.中的网络房间>();
JObject BB = bilibili.根据UID获取关注列表(MMPU.UID);
foreach (var 账号关注数据 in BB["data"])
{
foreach (var 网络房间数据 in MMPU.加载网络房间方法.列表缓存1)
{
if (账号关注数据["UID"].ToString() == 网络房间数据.UID)
{
符合条件的房间.Add(new MMPU.加载网络房间方法.中的网络房间()
{
UID = 网络房间数据.UID,
称 = 网络房间数据.称,
官方名称 = 网络房间数据.官方名称,
平台 = 网络房间数据.平台,
房间号 = 网络房间数据.roomId,
编号 = 0
});
break;
}
}
}
foreach (var 符合条件的 in 符合条件的房间)
{
bool BF = false;
if (!string.IsNullOrEmpty(符合条件的.UID))
{
string 房间号 = string.Empty;
if (string.IsNullOrEmpty(符合条件的.房间号))
{
BF = true;
房间号 = bilibili.通过UID获取房间号(符合条件的.UID);
符合条件的.房间号 = 房间号;
}
else
{
房间号 = 符合条件的.房间号;
}
bool 是否已经存在 = false;
foreach (var item in bilibili.RoomList)
{
if (item.房间号 == 房间号)
{
是否已经存在 = true;
break;
}
}
if (!是否已经存在 && !string.IsNullOrEmpty(房间号.Trim('0')))
{
增加的数量++;
long UIDD = 0;
try
{
UIDD = long.Parse(符合条件的.UID);
}
catch (Exception) {}
RB.data.Add(new RoomCadr {
Name = 符合条件的.称, RoomNumber = 符合条件的.房间号, Types = 符合条件的.平台, RemindStatus = false, status = false, VideoStatus = false, OfficialName = 符合条件的.官方名称, LiveStatus = false, UID = UIDD
});
}
else
{
已经存在的数量++;
}
}
if (BF)
{
Thread.Sleep(200);
}
}
string JOO = JsonConvert.SerializeObject(RB);
MMPU.储存文本(JOO, RoomConfigFile);
InitializeRoomList(0, false, false);
runOnLocalThread(() =>
{
callback("导入成功！原有:" + 已经存在的数量 + "个，新增VTB/VUP数：" + 增加的数量);
});
}
catch (Exception E)
{
;
}
}, W);
}
/// <summary>
///
/// </summary>
/// <param name="提示内容"></param>
/// <param name="来源">真为手动，假为自动</param>
public void 刷新播放(string 提示内容, bool 来源)
{
this.Dispatcher.Invoke(new Action(delegate
{
提示框.Visibility = Visibility.Visible;
提示文字.Content = 提示内容;
}));
switch (DD.DownIofo.平台)
{
case "bilibili":
{
if (bilibili.根据房间号获取房间信息.是否正在直播(DD.DownIofo.房间_频道号, true))
{
new Task((() =>
{
///需要DEBUG：CancelAsync过后，刷新播放没有显示出来
DD.DownIofo.WC.CancelAsync();
DD.DownIofo.备注 = "播放刷新";
DD.DownIofo.载状态 = false;
DD.DownIofo.结束时间 = Convert.ToInt32((DateTime.Now - new DateTime(1970, 1, 1, 0, 0, 0, 0)).TotalSeconds);
Downloader 载对象 = Downloader.新建下载对象(DD.DownIofo.平台, DD.DownIofo.房间_频道号, bilibili.根据房间号获取房间信息.获取标题(DD.DownIofo.房间_频道号), Guid.NewGuid().ToString(), bilibili.根据房间号获取房间信息.载地址(DD.DownIofo.房间_频道号), "播放缓冲重连", false, DD.DownIofo.主播名称, false, null);
MMPU.文件删除委托(DD.DownIofo.文件保存路径, "刷新播放窗口，删除LiveCache过期的缓存文件");
DD = 载对象;
for (int i = 0; i < MMPU.播放缓冲时长; i++)
{
Thread.Sleep(1000);
if (载对象.DownIofo.已下载大小bit > 1000)
{
Thread.Sleep(MMPU.播放缓冲时长 * 1000);
try
{
Play_Open(载对象.DownIofo.文件保存路径);
//this.VlcControl.SourceProvider.MediaPlayer.Play(new Uri(下载对象.DownIofo.文件保存路径));
}
catch (Exception)
{
return;
}
this.Dispatcher.Invoke(new Action(delegate
{
DD = 载对象;
提示框.Visibility = Visibility.Collapsed;
}));
return;
}
else
{
this.Dispatcher.Invoke(new Action(delegate
{
提示文字.Content = "直播源推流停止或卡顿，正在尝试重连,第" + (i + 1) + "次失败/一共尝试" + MMPU.播放缓冲时长 + "次";
if (i >= MMPU.播放缓冲时长 - 1)
{
提示文字.Content += "\n请尝试重开播放窗口";
return;
}
}));
}
}
})).Start();
}
else
{
InfoLog.InfoPrintf(DD.DownIofo.房间_频道号 + "房间:" + DD.DownIofo.主播名称 + " 下播放，录制完成", InfoLog.InfoClass.载必要提示);
this.Dispatcher.Invoke(new Action(delegate
{
提示文字.Content = "======该房间/频道 直播停止，请关闭播放窗口======";
return;
}));
}
break;
}
default:
System.Windows.MessageBox.Show("发现了与当前版本不支持的平台，请检查更新");
this.Dispatcher.Invoke(new Action(delegate
{
提示框.Visibility = Visibility.Collapsed;
}));
return;
}
}
private void Button_Click(object sender, RoutedEventArgs e)
{
if (string.IsNullOrEmpty(称.Text) || string.IsNullOrEmpty(唯一码.Text))
{
提示.Content = "名称或唯一码不能为空！";
}
else
{
int roomId = 0;
try
{
roomId = int.Parse(唯一码.Text);
string roomDD = bilibili.根据房间号获取房间信息.获取真实房间号(roomId.ToString());
if (!string.IsNullOrEmpty(roomDD))
{
roomId = int.Parse(roomDD);
}
}
catch (Exception)
{
MessageBox.Show("输入的直播间房间号不符合房间号规则(数字)");
return;
}
RoomBox rlc = JsonConvert.DeserializeObject <RoomBox>(ReadConfigFile(RoomConfigFile));
RoomBox RB = new RoomBox
{
data = new List <RoomCadr>()
};
if (rlc.data != null)
{
foreach (var item in rlc.data)
{
if (item.RoomNumber == 唯一码.Text)
{
提示.Content = "配置文件中已有改房间号存在!";
return;
}
RB.data.Add(item);
}
}
long UID = 0;
if (DataCache.读缓存(DataCache.缓存头.通过房间号获取UID + roomId, 0, out string GETUID))
{
try
{
UID = long.Parse(GETUID);
}
catch (Exception) {}
}
if (UID < 1)
{
try
{
UID = long.Parse(bilibili.根据房间号获取房间信息.通过房间号获取UID(roomId.ToString()));
}
catch (Exception) {}
}
RB.data.Add(new RoomCadr()
{
Name = 称.Text, OfficialName = 称.Text, RoomNumber = roomId.ToString(), UID = UID
});
string JOO = JsonConvert.SerializeObject(RB);
MMPU.储存文本(JOO, RoomConfigFile);
提示.Content = 称.Text + "[" + 唯一码.Text + "]添加完成";
bilibili.已连接的直播间状态.Add(new 直播间状态()
{
房间号 = roomId
});
bilibili.RoomList.Add(new RoomInfo
{
房间号 = roomId.ToString(),
标题 = "",
是否录制弹幕 = false,
是否录制视频 = false,
UID = UID.ToString(),
直播开始时间 = "",
称 = 称.Text,
直播状态 = false,
原名 = 称.Text,
是否提醒 = false,
平台 = "bilibili"
});
称.Text = "";
唯一码.Text = "";
}
}
public void 软件启动配置初始化()
{
#region 配置文件设置
try
{
RoomConfigFile = MMPU.getFiles("RoomConfiguration");
}
catch (Exception)
{
MMPU.setFiles("RoomConfiguration", "./RoomListConfig.json");
RoomConfigFile = "./RoomListConfig.json";
}
//播放窗口默认高度
try
{
MMPU.PlayWindowH = int.Parse(MMPU.getFiles("PlayWindowH"));
}
catch (Exception)
{
MMPU.setFiles("PlayWindowH", "450");
MMPU.PlayWindowH = 450;
}
//播放窗口默认宽度
try
{
MMPU.PlayWindowW = int.Parse(MMPU.getFiles("PlayWindowW"));
}
catch (Exception)
{
MMPU.setFiles("PlayWindowW", "800");
MMPU.PlayWindowH = 800;
}
//直播缓存目录
try
{
MMPU.直播缓存目录 = MMPU.getFiles("Livefile");
}
catch (Exception)
{
MMPU.setFiles("Livefile", "./tmp/LiveCache/");
MMPU.直播缓存目录 = "./tmp/LiveCache/";
}
//直播缓存目录
try
{
MMPU.载储存目录 = MMPU.getFiles("file");
}
catch (Exception)
{
MMPU.setFiles("file", "./tmp/");
MMPU.载储存目录 = "./tmp/";
}
//直播更新时间
try
{
MMPU.直播更新时间 = int.Parse(MMPU.getFiles("RoomTime"));
}
catch (Exception)
{
MMPU.setFiles("RoomTime", "40");
MMPU.直播更新时间 = 40;
}
//默认音量
try
{
MMPU.默认音量 = int.Parse(MMPU.getFiles("DefaultVolume"));
}
catch (Exception)
{
MMPU.setFiles("DefaultVolume", "50");
MMPU.默认音量 = 50;
}
//缩小功能
try
{
MMPU.缩小功能 = int.Parse(MMPU.getFiles("Zoom"));
}
catch (Exception)
{
MMPU.setFiles("Zoom", "1");
MMPU.缩小功能 = 1;
}
//最大直播并行数量
try
{
MMPU.最大直播并行数量 = int.Parse(MMPU.getFiles("PlayNum"));
}
catch (Exception)
{
MMPU.setFiles("PlayNum", "5");
MMPU.最大直播并行数量 = 5;
}
//默认弹幕颜色
try
{
MMPU.默认弹幕颜色 = MMPU.getFiles("DanMuColor");
}
catch (Exception)
{
MMPU.setFiles("DanMuColor", "0xFF, 0x00, 0x00, 0x00");
MMPU.默认弹幕颜色 = "0xFF, 0x00, 0x00, 0x00";
}
//默认字幕颜色
try
{
MMPU.默认字幕颜色 = MMPU.getFiles("ZiMuColor");
}
catch (Exception)
{
MMPU.setFiles("ZiMuColor", "0xFF, 0x00, 0x00, 0x00");
MMPU.默认字幕颜色 = "0xFF, 0x00, 0x00, 0x00";
}
//默认字幕大小
try
{
MMPU.默认字幕大小 = int.Parse(MMPU.getFiles("ZiMuSize"));
}
catch (Exception)
{
MMPU.setFiles("ZiMuSize", "24");
MMPU.默认字幕大小 = 24;
}
//默认弹幕大小
try
{
MMPU.默认弹幕大小 = int.Parse(MMPU.getFiles("DanMuSize"));
}
catch (Exception)
{
MMPU.setFiles("DanMuSize", "20");
MMPU.默认弹幕大小 = 20;
}
#endregion
//初始化房间
RoomInit.start();
//公告加载线程
new Thread(new ThreadStart(delegate {
公告项目启动();
})).Start();
//房间刷新线程
new Thread(new ThreadStart(delegate
{
while (true)
{
刷新房间列表UI();
Thread.Sleep(5 * 1000);
this.Dispatcher.Invoke(new Action(delegate
{
newtime.Content = "数据更新时间：" + DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
}));
while (true)
{
if (房间信息更新次数 > 0)
{
this.Dispatcher.Invoke(new Action(delegate
{
首次更新.Visibility = Visibility.Collapsed;
}));
break;
}
Thread.Sleep(100);
}
}
})).Start();
//延迟测试
new Thread(new ThreadStart(delegate
{
while (true)
{
try
{
double 国内 = MMPU.测试延迟("https://live.bilibili.com");
string 国内延迟 = string.Empty;
string 国外延迟 = string.Empty;
if (国内 > 0)
{
国内延迟 = "国内服务器延迟(阿B):" + 国内.ToString().Split('.')[0] + "ms";
MMPU.是否能连接阿B = true;
}
else
{
国内延迟 = "国内服务器延迟(阿B): 连接超时";
MMPU.是否能连接阿B = false;
}
if (MMPU.连接404使能)
{
double 国外 = MMPU.测试延迟("https://www.google.com");
if (国外 > 0)
{
国外延迟 = "国内服务器延迟(404):" + 国外.ToString().Split('.')[0] + "ms";
MMPU.是否能连接404 = true;
}
else
{
国外延迟 = "国内服务器延迟(404): 连接超时";
MMPU.是否能连接404 = false;
}
}
else
{
MMPU.是否能连接404 = false;
国外延迟 = "";
}
this.Dispatcher.Invoke(new Action(delegate
{
国内服务器延迟.Content = 国内延迟;
}));
if (MMPU.连接404使能)
{
this.Dispatcher.Invoke(new Action(delegate
{
国外服务器延迟.Content = 国外延迟;
}));
}
else
{
this.Dispatcher.Invoke(new Action(delegate
{
国外服务器延迟.Content = "";
}));
}
}
catch (Exception) { }
Thread.Sleep(4000);
}
})).Start();
//缩小功能
{
MMPU.缩小功能 = int.Parse(MMPU.getFiles("Zoom"));
if (MMPU.缩小功能 == 1)
{
缩小到任务栏选择按钮.IsChecked = true;
}
else
{
隐藏到后台托盘选择按钮.IsChecked = true;
}
}
//加载配置文件
{
默认音量值显示.Content = MMPU.默认音量;
修改默认音量.Value = MMPU.默认音量;
默认下载路径.Text = MMPU.载储存目录;
//读取字幕弹幕颜色
{
SolidColorBrush S1 = new SolidColorBrush(Color.FromArgb(0xFF, Convert.ToByte(MMPU.默认字幕颜色.Split(',')[1], 16), Convert.ToByte(MMPU.默认字幕颜色.Split(',')[2], 16), Convert.ToByte(MMPU.默认字幕颜色.Split(',')[3], 16)));
this.Dispatcher.Invoke(new Action(delegate
{
字幕默认颜色.Foreground = S1;
字幕颜色 = S1;
}));
SolidColorBrush S2 = new SolidColorBrush(Color.FromArgb(0xFF, Convert.ToByte(MMPU.默认弹幕颜色.Split(',')[1], 16), Convert.ToByte(MMPU.默认弹幕颜色.Split(',')[2], 16), Convert.ToByte(MMPU.默认弹幕颜色.Split(',')[3], 16)));
this.Dispatcher.Invoke(new Action(delegate
{
弹幕默认颜色.Foreground = S2;
弹幕颜色 = S2;
}));
}
//读取字幕弹幕字体大小
{
字幕文字大小.Text = MMPU.默认字幕大小.ToString();
弹幕文字大小.Text = MMPU.默认弹幕大小.ToString();
}
//默认音量
{
修改默认音量.Value = MMPU.默认音量;
}
//播放窗口默认大小
{
默认播放宽度.Text = MMPU.PlayWindowW.ToString();
默认播放高度.Text = MMPU.PlayWindowH.ToString();
}
}
//增加插件列表
{
PluginC.Items.Add(new
{
编号 = "1",
称 = "bilibili数据接口插件",
版本 = "1.0.1.1",
是否加载 = "√",
说明 = "获取和处理来自阿B的直播数据流",
备注 = ""
});
PluginC.Items.Add(new
{
编号 = "2",
称 = "播放插件",
版本 = "1.0.0.4",
是否加载 = "√",
说明 = "用于播放直播视频流",
备注 = ""
});
PluginC.Items.Add(new
{
编号 = "3",
称 = "DDNA直播统计插件",
版本 = "1.0.0.1",
是否加载 = "√",
说明 = "用于获取目前已知正在直播的vtb列表(工具箱内)",
备注 = ""
});
}
//剪切板监听，用于播放主站视频
// Thread T1 = new Thread(new ThreadStart(delegate
//{
// while (true)
// {
// try
// {
// System.Windows.IDataObject iData = System.Windows.Clipboard.GetDataObject();
// string A = (string)iData.GetData(System.Windows.DataFormats.Text);
// if (!string.IsNullOrEmpty(A))
// {
// if (A.Substring(0, 4).ToLower() == "http" && A.Contains("www.bilibili.com/video/"))
// {
// string C = A.Replace("www.bilibili.com/video/", "㈨").Split('㈨')[1].Split('/')[0].ToLower().Replace("av", "");
// System.Windows.Clipboard.SetDataObject("");
// // string AB = MMPU.获取网页数据_下载视频用("https://www.bilibili.com/video/av68188405");
// string CIDstr = MMPU.获取网页数据_下载视频用("https://www.bilibili.com/widget/getPageList?aid=" + C, true);
// JArray JO1 = (JArray)JsonConvert.DeserializeObject(CIDstr);
// string CID = JO1[0]["cid"].ToString();
// string 下载地址 = MMPU.获取网页数据_下载视频用("https://api.bilibili.com/x/player/playurl?avid=" + C + "&cid=" + "118184249" + "&otype=json&qn=116", false);
// JObject JO2 = (JObject)JsonConvert.DeserializeObject(下载地址);
// 下载地址 = JO2["data"]["durl"][0]["url"].ToString();
// Downloader 下载对象 = new Downloader
// {
// DownIofo = new Downloader.DownIofoData() { 平台 = "主站视频", 房间_频道号 = "主站视频", 标题 = "主站视频", 事件GUID = Guid.NewGuid().ToString(), 下载地址 = 下载地址, 备注 = "主站视频播放", 是否保存 = false }
// };
// //Downloader 下载对象 = Downloader.新建下载对象(平台, 唯一码, 标题, GUID, 下载地址, "视频播放缓存", false);
// Task.Run(() =>
// {
// this.Dispatcher.Invoke(new Action(delegate
// {
// 打开直播列表(下载对象);
// MMPU.当前直播窗口数量++;
// 等待框.Visibility = Visibility.Collapsed;
// }));
// });
// }
// }
// }
// catch (Exception ex)
// {
// }
// Thread.Sleep(500);
// }
//}));
// T1.TrySetApartmentState(ApartmentState.STA);
// T1.Start();
this.Dispatcher.Invoke(new Action(delegate
{
版本显示.Content = "版本：" + MMPU.版本号;
}));
}
private void 默认音量修改事件(object sender, System.Windows.Input.MouseEventArgs e)
{
默认音量值显示.Content = (int)修改默认音量.Value;
MMPU.默认音量 = (int)修改默认音量.Value;
MMPU.修改默认音量设置(MMPU.默认音量);
}
public async Task ConnectAsync(int roomId, CancellationToken?cancellationToken = null)
{
if (_disposed)
{
throw new ObjectDisposedException("");
}
m_client = new ClientWebSocket();
m_innerRts = new CancellationTokenSource();
string BB = MMPU.返回网页内容_GET("https://api.live.bilibili.com/xlive/web-room/v1/index/getDanmuInfo?id=" + roomId, 20000);
JObject JO = (JObject)JsonConvert.DeserializeObject(BB);
try
{
foreach (var item in JO["data"]["host_list"])
{
if (!bilibili.已经使用的服务器组.Contains(item["host"].ToString()))
{
wss_S = item["host"].ToString();
bilibili.已经使用的服务器组.Add(wss_S);
break;
}
}
if (string.IsNullOrEmpty(wss_S))
{
wss_S = JO["data"]["host_list"][1]["host"].ToString();
bilibili.已经使用的服务器组.Add(wss_S);
}
await m_client.ConnectAsync(new Uri("wss://" + wss_S + "/sub"), cancellationToken ?? new CancellationTokenSource(30000).Token);
//await m_client.ConnectAsync(new Uri("wss://broadcastlv.chat.bilibili.com/sub"), cancellationToken ?? new CancellationTokenSource(300000).Token);
}
catch (Exception e)
{
InfoLog.InfoPrintf("WSS连接发生错误:" + e.ToString(), InfoLog.InfoClass.Debug);
//Console.WriteLine(e.ToString());
}
int realRoomId = roomId;//await _getRealRoomId(roomId);
await _sendObject(7, new
{
uid = 0,
roomid = realRoomId,
protover = 2,
platform = "web",
clientver = "1.7.3",
type = "1",
key = JO["data"]["token"].ToString()
});
_ = _innerLoop().ContinueWith((t) =>
{
if (t.IsFaulted)
{
//UnityEngine.Debug.LogError(t.Exception.);
if (!m_innerRts.IsCancellationRequested)
{
MessageReceived(this, new ExceptionEventArgs(t.Exception.InnerException));
m_innerRts.Cancel();
}
}
else
{
//POST-CANCEL
InfoLog.InfoPrintf("LiveChatListener连接断开，房间号:" + realRoomId, InfoLog.InfoClass.Debug);
//Console.WriteLine("LiveChatListender cancelled.");
}
try
{
m_client.CloseAsync(WebSocketCloseStatus.NormalClosure, string.Empty, CancellationToken.None).Wait();
}
catch (Exception)
{
Dispose();
}
});
_ = _innerHeartbeat();
}
private void BT1_Click(object sender, RoutedEventArgs e)
{
try
{
if (string.IsNullOrEmpty(平台.SelectedItem.ToString()))
{
MessageBox.Show("未选择平台");
return;
}
}
catch (Exception)
{
MessageBox.Show("未选择平台");
return;
}
if (string.IsNullOrEmpty(中文名称.Text) || string.IsNullOrEmpty(平台.SelectedItem.ToString()) || string.IsNullOrEmpty(唯一码.Text))
{
MessageBox.Show("不能留空");
return;
}
if (this.Title == "添加新单推" || this.Title == "从网络添加房间")
{
if (平台.SelectedItem.ToString() == "bilibili")
{
foreach (var item in RoomInit.bilibili房间主表)
{
if (item.唯一码 == 唯一码.Text)
{
MessageBox.Show("已存在相同的房间号!\n" + item.称 + " " + item.平台 + " " + item.唯一码);
return;
}
}
}
else if (平台.SelectedItem.ToString() == "youtube")
{
foreach (var item in RoomInit.youtube房间主表)
{
if (item.唯一码 == 唯一码.Text)
{
MessageBox.Show("已存在相同的房间号!\n" + item.称 + " " + item.平台 + " " + item.唯一码);
return;
}
}
}
新增V信息 NEWV = new 新增V信息()
{
CN_Name = 中文名称.Text, LA_Name = 官方名称.Text, Platform = 平台.SelectedItem.ToString(), GUID = 唯一码.Text
};
NewThreadTask.Run(() =>
{
MMPU.TcpSend(Server.RequestCode.GET_NEW_MEMBER_LIST_CONTENT,
JsonConvert.SerializeObject(NEWV), true);
});
RoomBox rlc = JsonConvert.DeserializeObject <RoomBox>(ReadConfigFile(RoomConfigFile));
RoomBox RB = new RoomBox();
RB.data = new List <RoomCadr>();
if (rlc.data != null)
{
foreach (var item in rlc.data)
{
RB.data.Add(item);
if (RoomInit.根据唯一码获取直播状态(item.RoomNumber))
{
RB.data[RB.data.Count() - 1].LiveStatus = true;
}
}
}
RB.data.Add(new RoomCadr {
Name = 中文名称.Text, RoomNumber = 唯一码.Text, Types = 平台.SelectedItem.ToString(), RemindStatus = false, status = false, VideoStatus = false, OfficialName = 官方名称.Text, LiveStatus = RoomInit.根据唯一码获取直播状态(GUID)
});
string JOO = JsonConvert.SerializeObject(RB);
MMPU.储存文本(JOO, RoomConfigFile);
if (平台.SelectedItem.ToString() == "bilibili")
{
InitializeRoomList(int.Parse(唯一码.Text), false, false);
}
else
{
InitializeRoomList(0, false, false);
}
//更新房间列表(平台.SelectedItem.ToString(), 唯一码.Text,1);
//MessageBox.Show("添加成功");
}
else if (this.Title == "修改单推属性")
{
新增V信息 NEWV = new 新增V信息()
{
CN_Name = 中文名称.Text, LA_Name = 官方名称.Text, Platform = 平台.SelectedItem.ToString(), GUID = 唯一码.Text
};
NewThreadTask.Run(() =>
{
MMPU.TcpSend(Server.RequestCode.GET_NEW_MEMBER_LIST_CONTENT,
JsonConvert.SerializeObject(NEWV), true);
});
RoomBox rlc = JsonConvert.DeserializeObject <RoomBox>(ReadConfigFile(RoomConfigFile));
RoomBox RB = new RoomBox();
RB.data = new List <RoomCadr>();
if (rlc.data != null)
{
foreach (var item in rlc.data)
{
if (item.RoomNumber == GUID)
{
RB.data.Add(item);
RB.data[RB.data.Count - 1].Name = 中文名称.Text;
RB.data[RB.data.Count - 1].OfficialName = 官方名称.Text;
RB.data[RB.data.Count - 1].Types = 平台.SelectedItem.ToString();
}
else
{
RB.data.Add(item);
if (RoomInit.根据唯一码获取直播状态(item.RoomNumber))
{
RB.data[RB.data.Count() - 1].LiveStatus = true;
}
}
}
}
string JOO = JsonConvert.SerializeObject(RB);
MMPU.储存文本(JOO, RoomConfigFile);
InitializeRoomList(0, false, false);
//var rlc2 = JsonConvert.DeserializeObject<RoomBox>(ReadConfigFile(RoomConfigFile));
//RoomBox RB = new RoomBox();
//RB.data = new List<RoomCadr>();
//int rlclen = 房间主表.Count()-1;
//int 覆盖的编号 = 0;
//for (int i =0;i< rlclen; i++)
//{
// if(房间主表[i].唯一码==GUID)
// {
// 覆盖的编号 = i;
// //房间主表.Remove(房间主表[i]);
// //i--;
// RB.data.Add(new RoomCadr { Name = 中文名称.Text, RoomNumber = 唯一码.Text, Types = 平台.SelectedItem.ToString(), RemindStatus = false, status = false, VideoStatus = false, OfficialName = 官方名称.Text,LiveStatus= RoomInit.根据唯一码获取直播状态(GUID) });
// }
// else
// {
// RB.data.Add(new RoomCadr(){ LiveStatus= 房间主表[i] .直播状态,Name= 房间主表[i] .名称,OfficialName= 房间主表[i] .原名,RoomNumber= 房间主表[i] .唯一码,VideoStatus= 房间主表[i] .是否录制,Types= 房间主表[i] .平台, RemindStatus= 房间主表[i] .是否提醒,status=false });
// if (RoomInit.根据唯一码获取直播状态(房间主表[i].唯一码))
// {
// RB.data[RB.data.Count() - 1].LiveStatus = true;
// }
// }
//}
//房间主表.Clear();
//foreach (var item in RB.data)
//{
// 房间主表.Add(new RL { 名称=item.Name,原名=item.OfficialName,唯一码=item.RoomNumber,平台=item.Types,是否录制=item.VideoStatus,是否提醒=item.RemindStatus,直播状态=item.LiveStatus});
//}
//新增V信息 NEWV = new 新增V信息() { CN_Name = 中文名称.Text, LA_Name = 官方名称.Text, Platform = 平台.SelectedItem.ToString(), GUID = 唯一码.Text };
//new Task(() => { MMPU.TcpSend(20001, JsonConvert.SerializeObject(NEWV), true); }).Start();
//string JOO = JsonConvert.SerializeObject(RB);
//MMPU.储存文本(JOO, RoomConfigFile);
//InitializeRoomList();
////MessageBox.Show("修改成功");
}
this.Close();
}
/// <summary>
///
/// </summary>
/// <param name="a">T修改录制设置，F修改提醒设置</param>
public void 修改列表设置(bool a)
{
Console.WriteLine(已选内容);
bool 是否改过 = false;
if (string.IsNullOrEmpty(已选内容))
{
System.Windows.MessageBox.Show("未选择");
return;
}
//编号 = 1, 名称 = 智障爱, 状态 = ○未直播, 平台 = bilibili, 是否提醒 = √, 是否录制 = , 唯一码 = 1485080, 原名 =
等待框.Visibility = Visibility.Visible;
RoomBox RB = new RoomBox
{
data = new List <RoomCadr>()
};
while (RoomInit.房间主表长度 != 房间主表.Count() && RoomInit.房间主表长度 != 0)
{
Thread.Sleep(10);
}
int rlclen = 房间主表.Count();
for (int i = 0; i < rlclen; i++)
{
if (房间主表[i].唯一码 == MMPU.获取livelist平台和唯一码.唯一码(已选内容))
{
if (!是否改过)
{
是否改过 = true;
房间主表.Remove(房间主表[i]);
rlclen--;
i--;
bool 是否录制 = MMPU.获取livelist平台和唯一码.是否录制(已选内容) == "√" ? true : false;
bool 是否提醒 = MMPU.获取livelist平台和唯一码.是否提醒(已选内容) == "√" ? true : false;
if (a)
{
是否录制 = !是否录制;
if (是否录制)
{
已选内容 = 已选内容.Replace("是否录制 = ", "是否录制 = √");
}
else
{
已选内容 = 已选内容.Replace("是否录制 = √", "是否录制 = ");
}
}
else
{
是否提醒 = !是否提醒;
if (是否提醒)
{
已选内容 = 已选内容.Replace("是否提醒 = ", "是否提醒 = √");
}
else
{
已选内容 = 已选内容.Replace("是否提醒 = √", "是否提醒 = ");
}
}
RB.data.Add(new RoomCadr
{
Name = MMPU.获取livelist平台和唯一码.称(已选内容),
RoomNumber = MMPU.获取livelist平台和唯一码.唯一码(已选内容),
Types = MMPU.获取livelist平台和唯一码.平台(已选内容),
RemindStatus = 是否提醒,
status = MMPU.获取livelist平台和唯一码.状态(已选内容) == "●直播中" ? true : false,
VideoStatus = 是否录制,
OfficialName = MMPU.获取livelist平台和唯一码.原名(已选内容),
LiveStatus = MMPU.获取livelist平台和唯一码.状态(已选内容) == "●直播中" ? true : false
});
}
}
else
{
RB.data.Add(new RoomCadr()
{
LiveStatus = 房间主表[i].直播状态, Name = 房间主表[i].称, OfficialName = 房间主表[i].原名, RoomNumber = 房间主表[i].唯一码, VideoStatus = 房间主表[i].是否录制, Types = 房间主表[i].平台, RemindStatus = 房间主表[i].是否提醒, status = false
});
if (RoomInit.根据唯一码获取直播状态(房间主表[i].唯一码))
{
RB.data[RB.data.Count() - 1].LiveStatus = true;
}
}
}
string JOO = JsonConvert.SerializeObject(RB);
MMPU.储存文本(JOO, RoomConfigFile);
InitializeRoomList();
//更新房间列表(平台.SelectedItem.ToString(), 唯一码.Text,2);
//System.Windows.MessageBox.Show("修改成功");
}
private void 导入VTBVUP(Action <int, int> callback)
{
NewThreadTask.Run(runOnLocalThread =>
{
runOnLocalThread(() => 导入VTBVUP提示文本.Text = "正在加载房间列表数据，该过程耗时较长，请耐心等待……");
MMPU.加载网络房间方法.更新网络房间缓存();
MMPU.加载网络房间方法.是否正在缓存 = true;
while (MMPU.加载网络房间方法.是否正在缓存)
{
Thread.Sleep(500);
}
runOnLocalThread(() => 导入VTBVUP提示文本.Text = "正在导入关注列表里符合的VTB/VUP数据，请稍候……");
int 增加的数量 = 0;
int 已经存在的数量 = 0;
RoomInit.RoomConfigFile = MMPU.读取exe默认配置文件("RoomConfiguration", "./RoomListConfig.json");
RoomInit.InitializeRoomConfigFile();
RoomInit.InitializeRoomList(0, false, false);
RoomBox rlc = JsonConvert.DeserializeObject <RoomBox>(ReadConfigFile(RoomConfigFile));
RoomBox RB = new RoomBox
{
data = new List <RoomCadr>()
};
if (rlc.data != null)
{
foreach (var item in rlc.data)
{
RB.data.Add(item);
}
}
List <MMPU.加载网络房间方法.中的网络房间> 符合条件的房间 = new List <MMPU.加载网络房间方法.中的网络房间>();
JObject BB = bilibili.根据UID获取关注列表(MMPU.UID);
foreach (var 账号关注数据 in BB["data"])
{
foreach (var 网络房间数据 in MMPU.加载网络房间方法.列表缓存1)
{
if (账号关注数据["UID"].ToString() == 网络房间数据.UID)
{
符合条件的房间.Add(new MMPU.加载网络房间方法.中的网络房间()
{
UID = 网络房间数据.UID,
称 = 网络房间数据.称,
官方名称 = 网络房间数据.官方名称,
平台 = 网络房间数据.平台,
房间号 = null,
编号 = 0
});
break;
}
}
}
foreach (var 符合条件的 in 符合条件的房间)
{
if (!string.IsNullOrEmpty(符合条件的.UID))
{
string 房间号 = bilibili.通过UID获取房间号(符合条件的.UID);
符合条件的.房间号 = 房间号;
bool 是否已经存在 = false;
foreach (var item in bilibili.RoomList)
{
if (item.房间号 == 房间号)
{
是否已经存在 = true;
break;
}
}
if (!是否已经存在 && !string.IsNullOrEmpty(房间号.Trim('0')))
{
增加的数量++;
RB.data.Add(new RoomCadr {
Name = 符合条件的.称, RoomNumber = 符合条件的.房间号, Types = 符合条件的.平台, RemindStatus = false, status = false, VideoStatus = false, OfficialName = 符合条件的.官方名称, LiveStatus = false
});
}
else
{
已经存在的数量++;
}
}
Thread.Sleep(100);
}
string JOO = JsonConvert.SerializeObject(RB);
MMPU.储存文本(JOO, RoomConfigFile);
InitializeRoomList(0, false, false);
_已导入 = true;
runOnLocalThread(() =>
{
callback(增加的数量, 已经存在的数量);
});
}, this);
}
