Vladimir
372 lines
15 KiB
C#
372 lines
15 KiB
C#
using System.IO;
|
|
using System.IO.Compression;
|
|
using System.Net.Http;
|
|
using System.Net.Http.Headers;
|
|
using System.Security.Policy;
|
|
using System.Text;
|
|
using System.Text.RegularExpressions;
|
|
using System.Xml;
|
|
|
|
namespace TV_Player
|
|
{
|
|
public class ProgramInfo : ObservableViewModelBase
|
|
{
|
|
private string _title;
|
|
private int _durationValue;
|
|
|
|
public string Title { get => _title; set => SetProperty(ref _title, value); }
|
|
|
|
public DateTime StartTime { get; set; }
|
|
public DateTime EndTime { get; set; }
|
|
public int DurationValue { get => _durationValue; set => SetProperty(ref _durationValue, value); }
|
|
|
|
}
|
|
|
|
public class ProgramGuide
|
|
{
|
|
public string Id { get; set; }
|
|
public string DisplayName { get; set; }
|
|
public List<ProgramInfo> Programs { get; set; } = new List<ProgramInfo>();
|
|
}
|
|
public static class M3UParser
|
|
{
|
|
private static string GetWritableAppDataFolder()
|
|
{
|
|
var localAppData = Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData);
|
|
if (!string.IsNullOrWhiteSpace(localAppData))
|
|
{
|
|
return localAppData;
|
|
}
|
|
|
|
var appData = Environment.GetFolderPath(Environment.SpecialFolder.ApplicationData);
|
|
if (!string.IsNullOrWhiteSpace(appData))
|
|
{
|
|
return appData;
|
|
}
|
|
|
|
return AppContext.BaseDirectory;
|
|
}
|
|
|
|
public static async Task DownloadGuideFromWebAsync(string name, string url)
|
|
{
|
|
var fileName = name + "_guide.xml";
|
|
string programDataPath = GetWritableAppDataFolder();
|
|
string filePath = Path.Combine(programDataPath, "TVPlayer", fileName);
|
|
|
|
|
|
if (File.Exists(filePath))
|
|
{
|
|
DateTime creationTime = File.GetCreationTime(filePath);
|
|
DateTime modificationTime = File.GetLastWriteTime(filePath);
|
|
DateTime currentTime = DateTime.Now;
|
|
|
|
if ((currentTime - creationTime).TotalDays < 3 || (currentTime - modificationTime).TotalDays < 3)
|
|
{
|
|
return;
|
|
}
|
|
}
|
|
;
|
|
var channelsContent = string.Empty;
|
|
|
|
if (url.Contains(".gz"))
|
|
{
|
|
channelsContent = await DownloadGzip(url);
|
|
}
|
|
else
|
|
{
|
|
channelsContent = await DownloadXMLProgram(url);
|
|
}
|
|
Directory.CreateDirectory(Path.GetDirectoryName(filePath));
|
|
await File.WriteAllTextAsync(filePath, channelsContent);
|
|
}
|
|
|
|
private static async Task<string> DownloadXMLProgram(string url)
|
|
{
|
|
try
|
|
{
|
|
using (var client = new HttpClient())
|
|
using (var request = new HttpRequestMessage())
|
|
{
|
|
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/text"));
|
|
request.Method = HttpMethod.Get;
|
|
request.RequestUri = new Uri(url);
|
|
var response = await client.GetAsync(url);
|
|
response.EnsureSuccessStatusCode();
|
|
return await response.Content.ReadAsStringAsync();
|
|
}
|
|
}
|
|
catch (HttpRequestException ex)
|
|
{
|
|
System.Diagnostics.Debug.WriteLine($"Network error downloading XML from {url}: {ex.Message}");
|
|
throw;
|
|
}
|
|
catch (UriFormatException ex)
|
|
{
|
|
System.Diagnostics.Debug.WriteLine($"Invalid URL: {url} - {ex.Message}");
|
|
throw;
|
|
}
|
|
}
|
|
|
|
public static async Task<string> DownloadGzip(string url)
|
|
{
|
|
try
|
|
{
|
|
using HttpClient httpClient = new HttpClient();
|
|
byte[] compressedData = await httpClient.GetByteArrayAsync(url);
|
|
|
|
using MemoryStream compressedStream = new MemoryStream(compressedData);
|
|
using GZipStream decompressionStream = new GZipStream(compressedStream, CompressionMode.Decompress);
|
|
using MemoryStream decompressedStream = new MemoryStream();
|
|
await decompressionStream.CopyToAsync(decompressedStream);
|
|
|
|
string xmlContent = Encoding.UTF8.GetString(decompressedStream.ToArray());
|
|
return xmlContent;
|
|
}
|
|
catch (HttpRequestException ex)
|
|
{
|
|
System.Diagnostics.Debug.WriteLine($"Network error downloading gzip from {url}: {ex.Message}");
|
|
return null;
|
|
}
|
|
catch (InvalidOperationException ex)
|
|
{
|
|
System.Diagnostics.Debug.WriteLine($"Invalid gzip data: {ex.Message}");
|
|
return null;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
System.Diagnostics.Debug.WriteLine($"Error decompressing gzip: {ex.Message}");
|
|
return null;
|
|
}
|
|
}
|
|
|
|
public static async Task<ProgramGuide> ParseEpg(string groupName, string channelId)
|
|
{
|
|
XmlReaderSettings settings = new XmlReaderSettings();
|
|
settings.IgnoreWhitespace = true;
|
|
settings.IgnoreComments = true;
|
|
settings.DtdProcessing = DtdProcessing.Parse;
|
|
settings.Async = true;
|
|
ProgramGuide channel = null;
|
|
|
|
var fileName = groupName + "_guide.xml";
|
|
string programDataPath = GetWritableAppDataFolder();
|
|
string filePath = Path.Combine(programDataPath, "TVPlayer", fileName);
|
|
|
|
if (!File.Exists(filePath))
|
|
{
|
|
System.Diagnostics.Debug.WriteLine($"EPG file not found: {filePath}");
|
|
return null;
|
|
}
|
|
|
|
using (XmlReader reader = XmlReader.Create(filePath, settings))
|
|
{
|
|
try
|
|
{
|
|
while (await reader.ReadAsync())
|
|
{
|
|
if (reader.NodeType == XmlNodeType.Element && reader.Name == "channel")
|
|
{
|
|
var id = reader.GetAttribute("id");
|
|
if (id == channelId)
|
|
{
|
|
channel = new ProgramGuide
|
|
{
|
|
Id = id
|
|
};
|
|
reader.Read();
|
|
channel.DisplayName = reader.ReadElementContentAsString();
|
|
}
|
|
continue;
|
|
}
|
|
|
|
if (channel != null && reader.NodeType == XmlNodeType.Element && reader.Name == "programme")
|
|
{
|
|
ProgramInfo program = new ProgramInfo();
|
|
|
|
var id = reader.GetAttribute("channel");
|
|
if (id != channelId) continue;
|
|
|
|
if (!DateTime.TryParseExact(reader.GetAttribute("start"), "yyyyMMddHHmmss zzz", System.Globalization.CultureInfo.InvariantCulture, System.Globalization.DateTimeStyles.None, out var startTime))
|
|
continue;
|
|
if (!DateTime.TryParseExact(reader.GetAttribute("stop"), "yyyyMMddHHmmss zzz", System.Globalization.CultureInfo.InvariantCulture, System.Globalization.DateTimeStyles.None, out var endTime))
|
|
continue;
|
|
|
|
program.StartTime = startTime;
|
|
program.EndTime = endTime;
|
|
|
|
reader.Read();
|
|
program.Title = reader.ReadElementContentAsString();
|
|
|
|
channel.Programs.Add(program);
|
|
}
|
|
}
|
|
}
|
|
catch (XmlException ex)
|
|
{
|
|
System.Diagnostics.Debug.WriteLine($"XML parsing error in EPG file: {ex.Message}");
|
|
}
|
|
catch (FileNotFoundException ex)
|
|
{
|
|
System.Diagnostics.Debug.WriteLine($"EPG file not found: {ex.Message}");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
System.Diagnostics.Debug.WriteLine($"Unexpected error parsing EPG: {ex.Message}");
|
|
}
|
|
}
|
|
return channel;
|
|
}
|
|
|
|
private static async Task<string> ReadFile(string url)
|
|
{
|
|
try
|
|
{
|
|
using var client = new HttpClient();
|
|
using var request = new HttpRequestMessage();
|
|
client.DefaultRequestHeaders.Accept.Add(new MediaTypeWithQualityHeaderValue("application/text"));
|
|
request.Method = HttpMethod.Get;
|
|
request.RequestUri = new Uri(url);
|
|
var response = await client.GetAsync(url);
|
|
response.EnsureSuccessStatusCode();
|
|
return await response.Content.ReadAsStringAsync();
|
|
}
|
|
catch (HttpRequestException ex)
|
|
{
|
|
System.Diagnostics.Debug.WriteLine($"Network error reading file from {url}: {ex.Message}");
|
|
throw;
|
|
}
|
|
catch (UriFormatException ex)
|
|
{
|
|
System.Diagnostics.Debug.WriteLine($"Invalid URL: {url} - {ex.Message}");
|
|
throw;
|
|
}
|
|
}
|
|
|
|
public static async Task<(List<M3UInfo> programList, string programGuide)> DownloadM3UFromWebAsync(string url)
|
|
{
|
|
string fileData;
|
|
if (Uri.IsWellFormedUriString(url, UriKind.Absolute))
|
|
{
|
|
fileData = await ReadFile(url);
|
|
}
|
|
else
|
|
{
|
|
fileData = File.ReadAllText(url);
|
|
}
|
|
|
|
return ParseM3UFromString(fileData);
|
|
}
|
|
private static string[] SplitStringBeforeSeparator(string input, string separator)
|
|
{
|
|
string[] parts = input.Split(separator);
|
|
|
|
// Reconstruct the string until the separator is reached
|
|
int separatorIndex = input.IndexOf(separator);
|
|
if (separatorIndex != -1)
|
|
{
|
|
parts[0] = input.Substring(0, separatorIndex + 1);
|
|
for (int i = 1; i < parts.Length; i++)
|
|
{
|
|
parts[i] = separator + parts[i];
|
|
}
|
|
}
|
|
|
|
return parts;
|
|
}
|
|
|
|
private static (List<M3UInfo> programList, string programGuide) ParseM3UFromString(string content)
|
|
{
|
|
List<M3UInfo> playlistItems = new List<M3UInfo>();
|
|
string programGuideLink = string.Empty;
|
|
try
|
|
{
|
|
if (string.IsNullOrWhiteSpace(content))
|
|
{
|
|
System.Diagnostics.Debug.WriteLine("[M3UParser] M3U content is empty");
|
|
return (playlistItems, programGuideLink);
|
|
}
|
|
|
|
System.Diagnostics.Debug.WriteLine($"[M3UParser] Starting parse of M3U content ({content.Length} bytes)");
|
|
var m3u = SplitStringBeforeSeparator(content, "#EXT");
|
|
|
|
foreach (var line in m3u)
|
|
{
|
|
if (line.StartsWith("#EXTINF:"))
|
|
{
|
|
if (TryParseM3ULine(line, out var m3uInfo))
|
|
{
|
|
if (!string.IsNullOrEmpty(m3uInfo?.Url))
|
|
{
|
|
playlistItems.Add(m3uInfo);
|
|
System.Diagnostics.Debug.WriteLine($"[M3UParser] Parsed: {m3uInfo.Name} -> group='{m3uInfo.GroupTitle}'");
|
|
}
|
|
}
|
|
}
|
|
if (line.StartsWith("#EXTM3U"))
|
|
{
|
|
programGuideLink = ExtractXtvgUrl(line);
|
|
}
|
|
}
|
|
|
|
var groupSummary = playlistItems.GroupBy(p => p.GroupTitle).Select(g => $"{g.Key}({g.Count()})").ToList();
|
|
System.Diagnostics.Debug.WriteLine($"[M3UParser] Parse complete: {playlistItems.Count} programs in {groupSummary.Count} groups: {string.Join(", ", groupSummary)}");
|
|
}
|
|
catch (ArgumentException ex)
|
|
{
|
|
System.Diagnostics.Debug.WriteLine($"Invalid M3U format: {ex.Message}");
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
System.Diagnostics.Debug.WriteLine($"Error parsing M3U file: {ex.Message}");
|
|
}
|
|
|
|
return (playlistItems, programGuideLink);
|
|
}
|
|
|
|
private static bool TryParseM3ULine(string m3uLine, out M3UInfo? info)
|
|
{
|
|
info = null;
|
|
string pattern = @"#EXTINF:(-?\d+)\s*?(?:timeshift=""(?<Timeshift>.*?)""\s+)?(?:catchup-days=""(?<CatchupDays>.*?)""\s+)?(?:catchup-type=""(?<CatchupType>.*?)""\s+)?(?:CUID=""(?<CUID>.*?)""\s+)?(?:number=""(?<Number>.*?)""\s+)?(?:tvg-id=""(?<TvgID>.*?)""\s+)?(?:tvg-name=""(?<TvgName>.*?)""\s+)?(?:group-title=""(?<GroupTitle>.*?)""\s+)?(?:tvg-logo=""(?<Logo>.*?)""\s*)?(?:group-title=""(?<GroupTitle>.*?)"")?(?:,(?<Name>.*?)\s*\r?\n(?<URL>.*))";
|
|
//string pattern = @"#EXTINF:(-?\d+)\s+?(?:timeshift=""(?<Timeshift>.*?)""\s+)?(?:catchup-days=""(?<CatchupDays>.*?)""\s+)?(?:catchup-type=""(?<CatchupType>.*?)""\s+)?(?:CUID=""(?<CUID>.*?)""\s+)?(?:number=""(?<Number>.*?)""\s+)?(?:tvg-id=""(?<TvgID>.*?)""\s+)?(?:tvg-name=""(?<TvgName>.*?)""\s+)?(?:group-title=""(?<GroupTitle>.*?)""\s+)?(?:tvg-logo=""(?<Logo>.*?)"")?,(?<Name>.*?)\s*\r?\n(?<URL>.*)";
|
|
Regex regex = new Regex(pattern, RegexOptions.IgnoreCase);
|
|
|
|
Match match = regex.Match(m3uLine);
|
|
if (match.Success)
|
|
{
|
|
info = new M3UInfo
|
|
{
|
|
CUID = match.Groups["CUID"].Value,
|
|
Number = match.Groups["Number"].Value,
|
|
TvgID = match.Groups["TvgID"].Value,
|
|
TvgName = match.Groups["TvgName"].Value,
|
|
GroupTitle = string.IsNullOrEmpty(match.Groups["GroupTitle"].Value) ? "undefined" : match.Groups["GroupTitle"].Value,
|
|
Logo = match.Groups["Logo"].Value,
|
|
Name = match.Groups["Name"].Value,
|
|
Url = match.Groups["URL"].Value
|
|
};
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
private static string ExtractXtvgUrl(string m3uEntry)
|
|
{
|
|
// Define a regular expression pattern to match x-tvg-url attribute
|
|
string pattern = @"(x-tvg-url=""(.*?)"")?(url-tvg=""(.*?)"")";
|
|
|
|
// Use Regex.Match to find the first match
|
|
Match match = Regex.Match(m3uEntry, pattern);
|
|
|
|
// Check if a match is found and get the value from the capturing group
|
|
if (match.Success && match.Groups.Count > 1)
|
|
{
|
|
return match.Groups[4].Value;
|
|
}
|
|
|
|
// Return null or an empty string if no match is found
|
|
return string.Empty;
|
|
}
|
|
}
|
|
}
|