1569 lines
75 KiB
C#
1569 lines
75 KiB
C#
using System.Globalization;
|
|
using System.Net.Http.Headers;
|
|
using System.Text;
|
|
using System.Text.Encodings.Web;
|
|
using System.Text.Json;
|
|
using System.Text.Json.Nodes;
|
|
|
|
namespace YMhut.Box.Core.Music;
|
|
|
|
/// <summary>
|
|
/// Direct KuGou provider integration. Account requests use the provider's signed HTTPS
|
|
/// gateway and never synthesize entitlements or media addresses.
|
|
/// </summary>
|
|
public sealed class KugouMusicProvider : IMusicProvider, IDisposable
|
|
{
|
|
private const string DeviceCredentialKey = "kugou-device";
|
|
private const int MaximumAccountItems = 500;
|
|
private const string WebOrigin = "https://www.kugou.com";
|
|
private const string WebUserAgent = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 Chrome/140.0.0.0 Safari/537.36";
|
|
private static readonly JsonSerializerOptions CredentialJsonOptions = new(JsonSerializerDefaults.Web)
|
|
{
|
|
Encoder = JavaScriptEncoder.UnsafeRelaxedJsonEscaping,
|
|
WriteIndented = false
|
|
};
|
|
private static readonly (MusicPlaybackQuality Quality, string Value, int Bitrate)[] QualityOrder =
|
|
[
|
|
(MusicPlaybackQuality.Master, "viper_tape", 1000),
|
|
(MusicPlaybackQuality.HiRes, "high", 900),
|
|
(MusicPlaybackQuality.Lossless, "flac", 800),
|
|
(MusicPlaybackQuality.High, "320", 320),
|
|
(MusicPlaybackQuality.Standard, "128", 128)
|
|
];
|
|
private static readonly string[] KugouPlaybackQualities =
|
|
[
|
|
"128", "320", "flac", "high", "multitrack", "viper_atmos",
|
|
"viper_tape", "viper_clear", "super"
|
|
];
|
|
|
|
private readonly IMusicCredentialStore _credentials;
|
|
private readonly IMusicAccountSessionStore? _sessions;
|
|
private readonly HttpClient _publicClient;
|
|
private readonly KugouApiClient _api;
|
|
private readonly KugouLocalApiProxyHandler? _localApi;
|
|
private readonly SemaphoreSlim _initialization = new(1, 1);
|
|
private readonly SemaphoreSlim _accountCacheGate = new(1, 1);
|
|
private readonly Dictionary<string, KugouPlaylistData> _playlistData = new(StringComparer.OrdinalIgnoreCase);
|
|
private readonly Dictionary<string, KugouSongData> _songData = new(StringComparer.OrdinalIgnoreCase);
|
|
private readonly Dictionary<string, long> _favoriteFiles = new(StringComparer.OrdinalIgnoreCase);
|
|
private readonly Dictionary<string, long> _subscriptionLists = new(StringComparer.OrdinalIgnoreCase);
|
|
private KugouAccountCredential? _account;
|
|
private long _likedPlaylistListId;
|
|
private bool _deviceInitialized;
|
|
private bool _accountCacheLoaded;
|
|
private bool _favoriteCacheLoaded;
|
|
private bool _initialized;
|
|
private readonly object _refreshSync = new();
|
|
private Task<MusicLoginState>? _refreshTask;
|
|
private DateTimeOffset? _lastRefreshFailure;
|
|
|
|
public KugouMusicProvider(IMusicCredentialStore credentials, HttpMessageHandler? handler = null)
|
|
: this(credentials, handler, null, null)
|
|
{
|
|
}
|
|
|
|
public KugouMusicProvider(
|
|
IMusicCredentialStore credentials,
|
|
HttpMessageHandler handler,
|
|
IMusicAccountSessionStore sessions)
|
|
: this(credentials, handler, null, sessions)
|
|
{
|
|
}
|
|
|
|
internal KugouMusicProvider(
|
|
IMusicCredentialStore credentials,
|
|
HttpMessageHandler? handler,
|
|
Func<string>? playlistKeyFactory,
|
|
IMusicAccountSessionStore? sessions = null)
|
|
{
|
|
_credentials = credentials;
|
|
_sessions = sessions;
|
|
_api = new KugouApiClient(handler, playlistKeyFactory);
|
|
_localApi = handler as KugouLocalApiProxyHandler;
|
|
_publicClient = handler is null ? new HttpClient() : new HttpClient(handler, disposeHandler: false);
|
|
_publicClient.Timeout = TimeSpan.FromSeconds(12);
|
|
_publicClient.DefaultRequestHeaders.UserAgent.ParseAdd(WebUserAgent);
|
|
_publicClient.DefaultRequestHeaders.Referrer = new Uri(WebOrigin + "/");
|
|
_publicClient.DefaultRequestHeaders.TryAddWithoutValidation("Origin", WebOrigin);
|
|
_publicClient.DefaultRequestHeaders.TryAddWithoutValidation("Accept-Language", "zh-CN,zh;q=0.9,en;q=0.7");
|
|
}
|
|
|
|
public string Id => "kugou";
|
|
|
|
public MusicLoginState LoginState { get; private set; } = new(false);
|
|
|
|
public IReadOnlyList<MusicQualityOption> QualityOptions => BuildQualityOptions(LoginState);
|
|
|
|
public async Task InitializeAsync(CancellationToken cancellationToken = default)
|
|
{
|
|
if (_initialized) return;
|
|
await _initialization.WaitAsync(cancellationToken).ConfigureAwait(false);
|
|
try
|
|
{
|
|
if (_initialized) return;
|
|
await EnsureDeviceCoreAsync(cancellationToken).ConfigureAwait(false);
|
|
var secret = await _credentials.LoadAsync(Id, cancellationToken).ConfigureAwait(false);
|
|
if (_sessions is not null)
|
|
{
|
|
var session = await _sessions.LoadAsync(Id, cancellationToken).ConfigureAwait(false);
|
|
var cachedAccount = session is null ? null : ParseStoredAccount(session.Credential, out _);
|
|
if (session is not null && cachedAccount is not null && session.LoginState.LoggedIn)
|
|
{
|
|
_account = cachedAccount;
|
|
var refreshedAt = session.LoginState.RefreshedAt ?? session.SavedAt;
|
|
LoginState = session.LoginState with
|
|
{
|
|
RefreshedAt = refreshedAt,
|
|
IsCached = true,
|
|
IsStale = session.LoginState.IsStale || DateTimeOffset.UtcNow - refreshedAt >= TimeSpan.FromHours(12)
|
|
};
|
|
_initialized = true;
|
|
return;
|
|
}
|
|
}
|
|
if (!string.IsNullOrWhiteSpace(secret))
|
|
{
|
|
var account = ParseStoredAccount(secret, out var migrated);
|
|
if (account is null)
|
|
{
|
|
await _credentials.ClearAsync(Id, cancellationToken).ConfigureAwait(false);
|
|
}
|
|
else
|
|
{
|
|
try
|
|
{
|
|
await ValidateAccountAsync(account, cancellationToken).ConfigureAwait(false);
|
|
await CommitAccountAsync(account, migrated, cancellationToken).ConfigureAwait(false);
|
|
}
|
|
catch (KugouApiException exception) when (exception.AuthenticationFailure)
|
|
{
|
|
await ClearAccountAsync(cancellationToken).ConfigureAwait(false);
|
|
}
|
|
}
|
|
}
|
|
_initialized = true;
|
|
}
|
|
finally
|
|
{
|
|
_initialization.Release();
|
|
}
|
|
}
|
|
|
|
public Task<MusicLoginState> RefreshLoginStateAsync(bool force = false, CancellationToken cancellationToken = default)
|
|
{
|
|
lock (_refreshSync)
|
|
{
|
|
if (!force && LoginState.LoggedIn && !LoginState.IsStale && LoginState.Entitlements.Count > 0)
|
|
{
|
|
return Task.FromResult(LoginState);
|
|
}
|
|
if (!force && _lastRefreshFailure is { } failedAt && DateTimeOffset.UtcNow - failedAt < TimeSpan.FromMinutes(2))
|
|
{
|
|
return Task.FromResult(LoginState with { IsCached = true, IsStale = true });
|
|
}
|
|
return _refreshTask ??= RefreshLoginStateCoreAsync(cancellationToken);
|
|
}
|
|
}
|
|
|
|
private async Task<MusicLoginState> RefreshLoginStateCoreAsync(CancellationToken cancellationToken)
|
|
{
|
|
try
|
|
{
|
|
await InitializeAsync(cancellationToken).ConfigureAwait(false);
|
|
if (_account is null) return LoginState;
|
|
await ValidateAccountAsync(_account, cancellationToken).ConfigureAwait(false);
|
|
var refreshedState = EnrichLoginState(ToLoginState(_account));
|
|
var entitlementResult = await LoadEntitlementsAsync(_account, cancellationToken).ConfigureAwait(false);
|
|
if (_localApi is not null && !entitlementResult.Succeeded)
|
|
{
|
|
_lastRefreshFailure = DateTimeOffset.UtcNow;
|
|
LoginState = LoginState with { IsCached = true, IsStale = true };
|
|
return LoginState;
|
|
}
|
|
LoginState = _localApi is null
|
|
? refreshedState
|
|
: refreshedState with { Entitlements = entitlementResult.Grants };
|
|
_lastRefreshFailure = null;
|
|
await SaveSessionAsync(_account, LoginState, cancellationToken).ConfigureAwait(false);
|
|
return LoginState;
|
|
}
|
|
catch (KugouApiException exception) when (exception.AuthenticationFailure)
|
|
{
|
|
await ClearAccountAsync(cancellationToken).ConfigureAwait(false);
|
|
return LoginState;
|
|
}
|
|
catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
|
|
{
|
|
throw;
|
|
}
|
|
catch
|
|
{
|
|
_lastRefreshFailure = DateTimeOffset.UtcNow;
|
|
LoginState = LoginState with { IsCached = true, IsStale = true };
|
|
return LoginState;
|
|
}
|
|
finally
|
|
{
|
|
lock (_refreshSync) _refreshTask = null;
|
|
}
|
|
}
|
|
|
|
public async Task<MusicLoginState> LoginWithCookieAsync(string cookie, CancellationToken cancellationToken = default)
|
|
{
|
|
await EnsureDeviceAsync(cancellationToken).ConfigureAwait(false);
|
|
var account = ParseStoredAccount(cookie, out _);
|
|
if (account is null) return new MusicLoginState(false);
|
|
try
|
|
{
|
|
await ValidateAccountAsync(account, cancellationToken).ConfigureAwait(false);
|
|
}
|
|
catch (KugouApiException exception) when (exception.AuthenticationFailure)
|
|
{
|
|
return new MusicLoginState(false);
|
|
}
|
|
await CommitAccountAsync(account, save: true, cancellationToken).ConfigureAwait(false);
|
|
_initialized = true;
|
|
return LoginState;
|
|
}
|
|
|
|
public async Task<MusicQrSession> CreateQrSessionAsync(CancellationToken cancellationToken = default)
|
|
{
|
|
await EnsureDeviceAsync(cancellationToken).ConfigureAwait(false);
|
|
var key = await _api.CreateQrKeyAsync(cancellationToken).ConfigureAwait(false);
|
|
return new MusicQrSession(
|
|
key,
|
|
$"https://h5.kugou.com/apps/loginQRCode/html/index.html?qrcode={Uri.EscapeDataString(key)}",
|
|
DateTimeOffset.Now.AddMinutes(3));
|
|
}
|
|
|
|
public async Task<MusicQrStatus> CheckQrSessionAsync(MusicQrSession session, CancellationToken cancellationToken = default)
|
|
{
|
|
if (DateTimeOffset.Now >= session.ExpiresAt) return new MusicQrStatus(800, "二维码已过期。", false, true, true);
|
|
var result = await _api.CheckQrAsync(session.Key, cancellationToken).ConfigureAwait(false);
|
|
var data = result.Json["data"] ?? result.Json;
|
|
var status = KugouApiClient.Integer(data, "status");
|
|
switch (status)
|
|
{
|
|
case 0:
|
|
return new MusicQrStatus(800, "二维码已过期。", false, true, true);
|
|
case 1:
|
|
return new MusicQrStatus(801, "等待扫码。", false, false);
|
|
case 2:
|
|
return new MusicQrStatus(802, "已扫码，等待手机确认。", false, false);
|
|
case 4:
|
|
{
|
|
var token = KugouApiClient.Text(data, "token") ?? result.Cookies.GetValueOrDefault("token") ?? string.Empty;
|
|
var userId = KugouApiClient.Text(data, "userid") ?? result.Cookies.GetValueOrDefault("userid") ?? string.Empty;
|
|
if (string.IsNullOrWhiteSpace(token) || string.IsNullOrWhiteSpace(userId))
|
|
{
|
|
return new MusicQrStatus(805, "手机已确认，但酷狗未返回完整登录令牌。请刷新二维码重试。", false, false, true);
|
|
}
|
|
var account = new KugouAccountCredential(
|
|
2,
|
|
userId,
|
|
token,
|
|
KugouApiClient.Text(data, "nickname") ?? KugouApiClient.Text(data, "username") ?? "酷狗用户",
|
|
NormalizeImage(KugouApiClient.Text(data, "pic") ?? KugouApiClient.Text(data, "avatar") ?? string.Empty),
|
|
KugouApiClient.Text(data, "vip_type") ?? "none",
|
|
KugouApiClient.Text(data, "vip_token") ?? string.Empty,
|
|
KugouApiClient.Text(data, "t1") ?? string.Empty);
|
|
try
|
|
{
|
|
await ValidateAccountAsync(account, cancellationToken).ConfigureAwait(false);
|
|
await CommitAccountAsync(account, save: true, cancellationToken).ConfigureAwait(false);
|
|
_initialized = true;
|
|
return new MusicQrStatus(803, "登录成功。", true, false, true);
|
|
}
|
|
catch (KugouApiException exception) when (exception.AuthenticationFailure)
|
|
{
|
|
return new MusicQrStatus(805, "酷狗拒绝了登录令牌，请刷新二维码重试。", false, false, true);
|
|
}
|
|
}
|
|
default:
|
|
return new MusicQrStatus(805,
|
|
KugouApiClient.Text(data, "msg") ?? KugouApiClient.Text(result.Json, "msg") ?? "酷狗返回了未知扫码状态。",
|
|
false,
|
|
false,
|
|
true);
|
|
}
|
|
}
|
|
|
|
public async Task LogoutAsync(CancellationToken cancellationToken = default)
|
|
{
|
|
await ClearAccountAsync(cancellationToken).ConfigureAwait(false);
|
|
_initialized = true;
|
|
}
|
|
|
|
public async Task<MusicSearchResult> SearchAsync(string keywords, MusicSearchKind kind, int limit = 30, CancellationToken cancellationToken = default)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(keywords) || kind != MusicSearchKind.Songs) return new([], [], []);
|
|
var uri = "https://songsearch.kugou.com/song_search_v2?keyword=" +
|
|
Uri.EscapeDataString(keywords.Trim()) +
|
|
$"&page=1&pagesize={Math.Clamp(limit, 1, 100)}&userid=-1&platform=WebFilter&filter=2&iscorrection=1&privilege_filter=0";
|
|
var result = await GetPublicJsonAsync(uri, cancellationToken).ConfigureAwait(false);
|
|
var songs = MusicSongRules.FilterDisplayable(
|
|
KugouApiClient.Array(result["data"]?["lists"]).Select(MapSong));
|
|
return new MusicSearchResult(songs, [], []);
|
|
}
|
|
|
|
public async Task<IReadOnlyList<MusicPlaylist>> GetUserPlaylistsAsync(CancellationToken cancellationToken = default)
|
|
{
|
|
var account = await RequireAccountAsync(cancellationToken).ConfigureAwait(false);
|
|
try
|
|
{
|
|
return await LoadAllUserPlaylistsAsync(account, refresh: true, cancellationToken).ConfigureAwait(false);
|
|
}
|
|
catch (KugouApiException exception) when (exception.AuthenticationFailure)
|
|
{
|
|
await ExpireAccountAsync(cancellationToken).ConfigureAwait(false);
|
|
throw new InvalidOperationException("酷狗登录已失效，请重新扫码登录。", exception);
|
|
}
|
|
}
|
|
|
|
public Task<IReadOnlyList<MusicPlaylist>> GetRecommendedPlaylistsAsync(CancellationToken cancellationToken = default)
|
|
=> RunAccountOperationAsync(() => GetRecommendedPlaylistsCoreAsync(cancellationToken), cancellationToken);
|
|
|
|
private async Task<IReadOnlyList<MusicPlaylist>> GetRecommendedPlaylistsCoreAsync(CancellationToken cancellationToken)
|
|
{
|
|
await EnsureDeviceAsync(cancellationToken).ConfigureAwait(false);
|
|
if (_account is not null) await EnsureAccountCacheAsync(cancellationToken).ConfigureAwait(false);
|
|
var now = DateTimeOffset.UtcNow.ToUnixTimeSeconds().ToString(CultureInfo.InvariantCulture);
|
|
var body = new JsonObject
|
|
{
|
|
["appid"] = KugouApiClient.AppId,
|
|
["mid"] = _api.Device.Mid,
|
|
["clientver"] = KugouApiClient.ClientVersion,
|
|
["platform"] = "android",
|
|
["clienttime"] = now,
|
|
["userid"] = long.TryParse(_account?.UserId, out var userId) ? userId : 0,
|
|
["module_id"] = 1,
|
|
["page"] = 1,
|
|
["pagesize"] = 30,
|
|
["key"] = KugouApiClient.SignParamsKey(now),
|
|
["special_recommend"] = new JsonObject
|
|
{
|
|
["withtag"] = 1,
|
|
["withsong"] = 1,
|
|
["sort"] = 1,
|
|
["ugc"] = 1,
|
|
["is_selected"] = 0,
|
|
["withrecommend"] = 1,
|
|
["area_code"] = 1,
|
|
["categoryid"] = 0
|
|
},
|
|
["req_multi"] = 1,
|
|
["retrun_min"] = 5,
|
|
["return_special_falg"] = 1
|
|
};
|
|
var response = await _api.SendAndroidAsync(
|
|
HttpMethod.Post,
|
|
"/v2/special_recommend",
|
|
null,
|
|
body,
|
|
_account,
|
|
"specialrec.service.kugou.com",
|
|
cancellationToken).ConfigureAwait(false);
|
|
return PlaylistArray(response.Json)
|
|
.Select(node => MapPlaylist(node, accountPlaylist: false))
|
|
.Where(item => !string.IsNullOrWhiteSpace(item.Id))
|
|
.Take(30)
|
|
.ToArray();
|
|
}
|
|
|
|
public async Task<IReadOnlyList<MusicPlaylist>> GetChartsAsync(CancellationToken cancellationToken = default)
|
|
{
|
|
var result = await GetPublicJsonAsync("https://m.kugou.com/rank/list&json=true", cancellationToken).ConfigureAwait(false);
|
|
return KugouApiClient.Array(result["rank"]?["list"])
|
|
.Select(node => new MusicPlaylist(
|
|
Id,
|
|
"rank:" + (KugouApiClient.Text(node, "rankid") ?? string.Empty),
|
|
KugouApiClient.Text(node, "rankname") ?? "酷狗榜单",
|
|
NormalizeImage(KugouApiClient.Text(node, "imgurl") ?? KugouApiClient.Text(node, "img_9") ?? string.Empty),
|
|
KugouApiClient.Integer(node, "songcount"),
|
|
"酷狗音乐"))
|
|
.Where(playlist => !playlist.Id.EndsWith(':'))
|
|
.ToArray();
|
|
}
|
|
|
|
public async Task<IReadOnlyList<MusicSong>> GetDailySongsAsync(CancellationToken cancellationToken = default)
|
|
{
|
|
var account = await RequireAccountAsync(cancellationToken).ConfigureAwait(false);
|
|
try
|
|
{
|
|
var response = await _api.SendAndroidAsync(
|
|
HttpMethod.Post,
|
|
"/everyday_song_recommend",
|
|
null,
|
|
new JsonObject
|
|
{
|
|
["platform"] = "android",
|
|
["userid"] = long.TryParse(account.UserId, out var userId) ? userId : 0
|
|
},
|
|
account,
|
|
"everydayrec.service.kugou.com",
|
|
cancellationToken).ConfigureAwait(false);
|
|
return MusicSongRules.FilterDisplayable(SongArray(response.Json).Select(MapSong)).Take(100).ToArray();
|
|
}
|
|
catch (KugouApiException exception) when (exception.AuthenticationFailure)
|
|
{
|
|
await ExpireAccountAsync(cancellationToken).ConfigureAwait(false);
|
|
throw new InvalidOperationException("酷狗登录已失效，请重新扫码登录。", exception);
|
|
}
|
|
}
|
|
|
|
public Task<IReadOnlyList<MusicSong>> GetPlaylistTracksAsync(string playlistId, int offset = 0, int count = 100, CancellationToken cancellationToken = default)
|
|
=> RunAccountOperationAsync(() => GetPlaylistTracksCoreAsync(playlistId, offset, count, cancellationToken), cancellationToken);
|
|
|
|
private async Task<IReadOnlyList<MusicSong>> GetPlaylistTracksCoreAsync(string playlistId, int offset, int count, CancellationToken cancellationToken)
|
|
{
|
|
var take = Math.Clamp(count, 1, MaximumAccountItems);
|
|
if (playlistId.StartsWith("rank:", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
return await GetRankTracksAsync(playlistId["rank:".Length..], offset, take, cancellationToken).ConfigureAwait(false);
|
|
}
|
|
if (playlistId.StartsWith("list:", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
var listId = ParseLong(playlistId["list:".Length..], "歌单标识无效。");
|
|
return await LoadAccountPlaylistTracksAsync(listId, offset, take, cancellationToken).ConfigureAwait(false);
|
|
}
|
|
if (playlistId.StartsWith("collection:", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
var collectionId = playlistId["collection:".Length..];
|
|
return await LoadCollectionTracksAsync(collectionId, offset, take, cancellationToken).ConfigureAwait(false);
|
|
}
|
|
throw new InvalidOperationException("当前酷狗歌单标识不受支持，请刷新歌单列表后重试。");
|
|
}
|
|
|
|
public Task<IReadOnlyList<MusicSong>> GetArtistSongsAsync(string artistId, int offset = 0, int count = 50, CancellationToken cancellationToken = default)
|
|
=> Task.FromResult<IReadOnlyList<MusicSong>>([]);
|
|
|
|
public Task<MusicStreamResult> ResolveStreamAsync(string songId, MusicPlaybackQuality quality, CancellationToken cancellationToken = default)
|
|
=> RunAccountOperationAsync(() => ResolveStreamCoreAsync(songId, quality, cancellationToken), cancellationToken);
|
|
|
|
private async Task<MusicStreamResult> ResolveStreamCoreAsync(string songId, MusicPlaybackQuality quality, CancellationToken cancellationToken)
|
|
{
|
|
await EnsureDeviceAsync(cancellationToken).ConfigureAwait(false);
|
|
var identity = SplitSongId(songId);
|
|
var start = global::System.Array.FindIndex(QualityOrder, item => item.Quality == quality);
|
|
if (start < 0) start = QualityOrder.Length - 1;
|
|
var metadata = SongDataFor(songId);
|
|
var candidates = await GetPlaybackCandidatesAsync(identity, metadata, start, cancellationToken).ConfigureAwait(false);
|
|
string? lastReason = null;
|
|
foreach (var candidate in candidates)
|
|
{
|
|
var freePartModes = _account is null ? new[] { true } : new[] { false, true };
|
|
foreach (var freePart in freePartModes)
|
|
{
|
|
try
|
|
{
|
|
var response = await _api.SendAndroidAsync(
|
|
HttpMethod.Get,
|
|
"/v5/url",
|
|
new Dictionary<string, string>
|
|
{
|
|
["album_id"] = identity.AlbumId,
|
|
["area_code"] = "1",
|
|
["hash"] = candidate.Hash.ToLowerInvariant(),
|
|
["ssa_flag"] = "is_fromtrack",
|
|
["version"] = "11430",
|
|
["page_id"] = "151369488",
|
|
["quality"] = candidate.Value,
|
|
["album_audio_id"] = metadata?.MixSongId.ToString(CultureInfo.InvariantCulture) ?? "0",
|
|
["behavior"] = "play",
|
|
["pid"] = "2",
|
|
["cmd"] = "26",
|
|
["pidversion"] = "3001",
|
|
["IsFreePart"] = freePart ? "1" : "0",
|
|
["ppage_id"] = "463467626,350369493,788954147",
|
|
["cdnBackup"] = "1",
|
|
["module"] = "",
|
|
["clientver"] = "11430"
|
|
},
|
|
null,
|
|
_account,
|
|
"trackercdn.kugou.com",
|
|
cancellationToken,
|
|
addTrackKey: true).ConfigureAwait(false);
|
|
|
|
foreach (var data in PlaybackResponseNodes(response.Json))
|
|
{
|
|
var extension = KugouApiClient.Text(data, "extName") ?? KugouApiClient.Text(data, "ext_name");
|
|
if (string.Equals(extension, "mp4", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
lastReason = "当前音质返回了视频容器，已尝试较低音质。";
|
|
continue;
|
|
}
|
|
if (!TryGetHttpsPlaybackUri(data, out var streamUri)) continue;
|
|
|
|
var bitrate = FirstInteger(data, "bitRate", "bitrate", "bit_rate");
|
|
if (bitrate <= 0) bitrate = candidate.Bitrate;
|
|
var fullAudio = FirstInteger(data, "is_full_audio", "isFullAudio") == 1;
|
|
var trial = FirstInteger(data, "is_free_part", "isFreePart") == 1 || (freePart && !fullAudio);
|
|
return new MusicStreamResult(
|
|
streamUri,
|
|
true,
|
|
trial,
|
|
candidate.Quality,
|
|
bitrate * 1000L,
|
|
trial ? "提供方仅允许试听片段。" : candidate.Quality == quality ? null : $"已回退到 {candidate.Quality} 音质。");
|
|
}
|
|
lastReason = KugouApiClient.Text(response.Json, "error") ??
|
|
KugouApiClient.Text(response.Json, "msg") ??
|
|
lastReason ??
|
|
"提供方未返回可用的 HTTPS 播放地址。";
|
|
}
|
|
catch (KugouApiException exception) when (!exception.AuthenticationFailure)
|
|
{
|
|
lastReason = exception.Message;
|
|
}
|
|
}
|
|
}
|
|
return new MusicStreamResult(null, false, false, quality, 0,
|
|
lastReason ?? "提供方未返回播放地址，歌曲可能需要登录、会员或受地区限制。");
|
|
}
|
|
|
|
private async Task<IReadOnlyList<KugouPlaybackCandidate>> GetPlaybackCandidatesAsync(
|
|
(string Hash, string AlbumId) identity,
|
|
KugouSongData? metadata,
|
|
int start,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
var fallback = QualityOrder.Skip(start).ToArray();
|
|
var variants = new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase);
|
|
try
|
|
{
|
|
var response = await _api.SendAndroidAsync(
|
|
HttpMethod.Post,
|
|
"/v2/get_res_privilege/lite",
|
|
null,
|
|
new JsonObject
|
|
{
|
|
["appid"] = KugouApiClient.AppId,
|
|
["area_code"] = 1,
|
|
["behavior"] = "play",
|
|
["clientver"] = KugouApiClient.ClientVersion,
|
|
["need_hash_offset"] = 1,
|
|
["relate"] = 1,
|
|
["support_verify"] = 1,
|
|
["resource"] = new JsonArray
|
|
{
|
|
new JsonObject
|
|
{
|
|
["type"] = "audio",
|
|
["page_id"] = 0,
|
|
["hash"] = identity.Hash,
|
|
["album_id"] = metadata?.AlbumId ?? ParseLong(identity.AlbumId, defaultValue: 0)
|
|
}
|
|
},
|
|
["qualities"] = new JsonArray(KugouPlaybackQualities
|
|
.Select(value => (JsonNode?)JsonValue.Create(value))
|
|
.ToArray())
|
|
},
|
|
_account,
|
|
"media.store.kugou.com",
|
|
cancellationToken).ConfigureAwait(false);
|
|
|
|
foreach (var item in KugouApiClient.Array(response.Json["data"]))
|
|
{
|
|
AddPlaybackVariant(item, variants);
|
|
foreach (var related in KugouApiClient.Array(item?["relate_goods"]))
|
|
{
|
|
AddPlaybackVariant(related, variants);
|
|
}
|
|
}
|
|
}
|
|
catch (KugouApiException exception) when (!exception.AuthenticationFailure)
|
|
{
|
|
// The URL endpoint can still resolve free or standard variants when the
|
|
// privilege service is temporarily unavailable.
|
|
}
|
|
|
|
var resolved = fallback
|
|
.Where(item => variants.ContainsKey(item.Value))
|
|
.Select(item => new KugouPlaybackCandidate(item.Quality, item.Value, variants[item.Value], item.Bitrate))
|
|
.ToArray();
|
|
return resolved.Length > 0
|
|
? resolved
|
|
: fallback.Select(item => new KugouPlaybackCandidate(item.Quality, item.Value, identity.Hash, item.Bitrate)).ToArray();
|
|
}
|
|
|
|
private static void AddPlaybackVariant(JsonNode? node, IDictionary<string, string> variants)
|
|
{
|
|
if (node is not JsonObject item) return;
|
|
if (item.ContainsKey("level") && KugouApiClient.Integer(item, "level") == 0) return;
|
|
var quality = KugouApiClient.Text(item, "quality");
|
|
var hash = KugouApiClient.Text(item, "hash");
|
|
if (string.IsNullOrWhiteSpace(quality) || string.IsNullOrWhiteSpace(hash)) return;
|
|
variants.TryAdd(quality, hash);
|
|
}
|
|
|
|
private static IEnumerable<JsonNode> PlaybackResponseNodes(JsonObject response)
|
|
{
|
|
yield return response;
|
|
if (response["data"] is JsonObject data)
|
|
{
|
|
yield return data;
|
|
}
|
|
else if (response["data"] is JsonArray array)
|
|
{
|
|
foreach (var item in array.Where(item => item is not null)) yield return item!;
|
|
}
|
|
}
|
|
|
|
private static bool TryGetHttpsPlaybackUri(JsonNode? node, out Uri? result)
|
|
{
|
|
foreach (var property in new[] { "url", "play_url", "backupUrl", "backup_url", "backupurl" })
|
|
{
|
|
foreach (var address in TextValues(node?[property]))
|
|
{
|
|
if (!Uri.TryCreate(address, UriKind.Absolute, out var uri)) continue;
|
|
if (uri.Scheme == Uri.UriSchemeHttps)
|
|
{
|
|
result = uri;
|
|
return true;
|
|
}
|
|
if (uri.Scheme == Uri.UriSchemeHttp && uri.IsDefaultPort && IsKugouMediaHost(uri.Host))
|
|
{
|
|
var secure = new UriBuilder(uri) { Scheme = Uri.UriSchemeHttps, Port = -1 }.Uri;
|
|
result = secure;
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
result = null;
|
|
return false;
|
|
}
|
|
|
|
private static bool IsKugouMediaHost(string host)
|
|
=> host.EndsWith(".kugou.com", StringComparison.OrdinalIgnoreCase) ||
|
|
string.Equals(host, "kugou.com", StringComparison.OrdinalIgnoreCase);
|
|
|
|
private static IEnumerable<string> TextValues(JsonNode? node)
|
|
{
|
|
if (node is JsonValue value && value.TryGetValue<string>(out var valueText) && !string.IsNullOrWhiteSpace(valueText))
|
|
{
|
|
yield return valueText;
|
|
yield break;
|
|
}
|
|
if (node is not JsonArray array) yield break;
|
|
foreach (var item in array)
|
|
{
|
|
foreach (var itemText in TextValues(item)) yield return itemText;
|
|
}
|
|
}
|
|
|
|
private static int FirstInteger(JsonNode? node, params string[] properties)
|
|
=> properties.Select(property => KugouApiClient.Integer(node, property)).FirstOrDefault(value => value != 0);
|
|
|
|
public async Task<MusicStreamProbe> ProbeStreamAsync(Uri uri, CancellationToken cancellationToken = default)
|
|
{
|
|
using var request = new HttpRequestMessage(HttpMethod.Get, uri);
|
|
request.Headers.Range = new RangeHeaderValue(0, 1);
|
|
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("audio/*"));
|
|
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/octet-stream", 0.8));
|
|
try
|
|
{
|
|
using var response = await _publicClient.SendAsync(request, HttpCompletionOption.ResponseHeadersRead, cancellationToken).ConfigureAwait(false);
|
|
var contentType = response.Content.Headers.ContentType?.MediaType ?? string.Empty;
|
|
var reachable = response.IsSuccessStatusCode &&
|
|
(contentType.StartsWith("audio/", StringComparison.OrdinalIgnoreCase) ||
|
|
string.Equals(contentType, "application/octet-stream", StringComparison.OrdinalIgnoreCase) ||
|
|
string.IsNullOrWhiteSpace(contentType));
|
|
return new MusicStreamProbe(reachable, contentType, (int)response.StatusCode,
|
|
reachable ? null : $"音乐文件服务返回 HTTP {(int)response.StatusCode} 或非音频内容。");
|
|
}
|
|
catch (OperationCanceledException) when (!cancellationToken.IsCancellationRequested)
|
|
{
|
|
return new MusicStreamProbe(false, string.Empty, 0, "音乐文件连接超时。");
|
|
}
|
|
catch (HttpRequestException exception)
|
|
{
|
|
return new MusicStreamProbe(false, string.Empty, (int?)exception.StatusCode ?? 0, "无法访问音乐文件。");
|
|
}
|
|
}
|
|
|
|
public async Task<TimedLyrics> GetLyricsAsync(string songId, CancellationToken cancellationToken = default)
|
|
{
|
|
var identity = SplitSongId(songId);
|
|
if (_localApi is not null)
|
|
{
|
|
try
|
|
{
|
|
var searchResult = await _localApi.SendApiAsync("/search/lyric", new Dictionary<string, string>
|
|
{
|
|
["hash"] = identity.Hash,
|
|
["man"] = "yes"
|
|
}, cancellationToken: cancellationToken).ConfigureAwait(false);
|
|
var localCandidate = KugouApiClient.Array(searchResult["candidates"] ?? searchResult["data"]?["candidates"]).FirstOrDefault();
|
|
var localLyricId = KugouApiClient.Text(localCandidate, "id");
|
|
var localAccessKey = KugouApiClient.Text(localCandidate, "accesskey");
|
|
if (!string.IsNullOrWhiteSpace(localLyricId) && !string.IsNullOrWhiteSpace(localAccessKey))
|
|
{
|
|
var krc = await _localApi.SendApiAsync("/lyric", new Dictionary<string, string>
|
|
{
|
|
["id"] = localLyricId,
|
|
["accesskey"] = localAccessKey,
|
|
["fmt"] = "krc",
|
|
["decode"] = "true"
|
|
}, cancellationToken: cancellationToken).ConfigureAwait(false);
|
|
var decoded = KugouApiClient.Text(krc, "decodeContent") ?? KugouApiClient.Text(krc["data"], "decodeContent");
|
|
if (!string.IsNullOrWhiteSpace(decoded))
|
|
{
|
|
var parsed = MusicLyricsParser.ParseKrc(decoded);
|
|
if (parsed.Lines.Count > 0) return parsed;
|
|
}
|
|
}
|
|
}
|
|
catch (Exception exception) when (exception is not OperationCanceledException)
|
|
{
|
|
// Fall through to the plain LRC compatibility path.
|
|
}
|
|
}
|
|
var search = await GetPublicJsonAsync(
|
|
"https://lyrics.kugou.com/search?ver=1&man=yes&client=pc&hash=" + Uri.EscapeDataString(identity.Hash),
|
|
cancellationToken).ConfigureAwait(false);
|
|
var candidate = KugouApiClient.Array(search["candidates"]).FirstOrDefault();
|
|
var lyricId = KugouApiClient.Text(candidate, "id");
|
|
var accessKey = KugouApiClient.Text(candidate, "accesskey");
|
|
if (string.IsNullOrWhiteSpace(lyricId) || string.IsNullOrWhiteSpace(accessKey)) return new TimedLyrics([], string.Empty, null, null);
|
|
var download = await GetPublicJsonAsync(
|
|
"https://lyrics.kugou.com/download?ver=1&client=pc&fmt=lrc&charset=utf8&id=" +
|
|
Uri.EscapeDataString(lyricId) + "&accesskey=" + Uri.EscapeDataString(accessKey),
|
|
cancellationToken).ConfigureAwait(false);
|
|
var encoded = KugouApiClient.Text(download, "content");
|
|
if (string.IsNullOrWhiteSpace(encoded)) return new TimedLyrics([], string.Empty, null, null);
|
|
try
|
|
{
|
|
return MusicLyricsParser.Parse(Encoding.UTF8.GetString(Convert.FromBase64String(encoded)));
|
|
}
|
|
catch (FormatException)
|
|
{
|
|
return MusicLyricsParser.Parse(encoded);
|
|
}
|
|
}
|
|
|
|
public async Task<MusicMv?> GetMvAsync(string songId, string? mvId = null, CancellationToken cancellationToken = default)
|
|
{
|
|
if (string.IsNullOrWhiteSpace(mvId)) return null;
|
|
var result = await GetPublicJsonAsync(
|
|
"https://m.kugou.com/app/i/mv.php?cmd=100&ismp3=1&ext=mp4&hash=" + Uri.EscapeDataString(mvId),
|
|
cancellationToken).ConfigureAwait(false);
|
|
var variants = (result["mvdata"] as JsonObject)?
|
|
.Select(pair => pair.Value)
|
|
.OfType<JsonObject>()
|
|
.Select(node => new { Bitrate = KugouApiClient.Integer(node, "bitrate"), Address = KugouApiClient.Text(node, "downurl") ?? FirstText(node, "backupdownurl") })
|
|
.OrderByDescending(item => item.Bitrate)
|
|
.ToArray() ?? [];
|
|
var address = variants.Select(item => item.Address).FirstOrDefault(value => Uri.TryCreate(value, UriKind.Absolute, out var candidate) && candidate.Scheme == Uri.UriSchemeHttps);
|
|
var mediaUri = Uri.TryCreate(address, UriKind.Absolute, out var parsed) ? parsed : null;
|
|
var insecure = variants.Any(item => Uri.TryCreate(item.Address, UriKind.Absolute, out var candidate) && candidate.Scheme == Uri.UriSchemeHttp);
|
|
return new MusicMv(
|
|
Id,
|
|
mvId,
|
|
KugouApiClient.Text(result, "songname") ?? "MV",
|
|
KugouApiClient.Text(result, "singer") ?? string.Empty,
|
|
NormalizeImage(KugouApiClient.Text(result, "mvicon") ?? string.Empty),
|
|
TimeSpan.FromMilliseconds(KugouApiClient.Integer(result, "timelength")),
|
|
mediaUri,
|
|
mediaUri is not null,
|
|
mediaUri is null ? insecure ? "服务方当前仅返回非加密 MV 地址，已拒绝加载。" : "提供方未返回可播放的 MV 地址。" : null);
|
|
}
|
|
|
|
public Task<bool?> GetFavoriteStateAsync(MusicSong song, CancellationToken cancellationToken = default)
|
|
=> RunAccountOperationAsync(() => GetFavoriteStateCoreAsync(song, cancellationToken), cancellationToken);
|
|
|
|
private async Task<bool?> GetFavoriteStateCoreAsync(MusicSong song, CancellationToken cancellationToken)
|
|
{
|
|
await RequireAccountAsync(cancellationToken).ConfigureAwait(false);
|
|
await EnsureFavoriteCacheAsync(force: false, cancellationToken).ConfigureAwait(false);
|
|
return _favoriteFiles.ContainsKey(SplitSongId(song.Id).Hash);
|
|
}
|
|
|
|
public Task SetFavoriteAsync(MusicSong song, bool favorite, CancellationToken cancellationToken = default)
|
|
=> RunAccountOperationAsync(() => SetFavoriteCoreAsync(song, favorite, cancellationToken), cancellationToken);
|
|
|
|
private async Task SetFavoriteCoreAsync(MusicSong song, bool favorite, CancellationToken cancellationToken)
|
|
{
|
|
var account = await RequireAccountAsync(cancellationToken).ConfigureAwait(false);
|
|
await EnsureFavoriteCacheAsync(force: !favorite, cancellationToken).ConfigureAwait(false);
|
|
if (_likedPlaylistListId <= 0) throw new InvalidOperationException("未找到酷狗账户的“我喜欢”歌单，已停止收藏操作。");
|
|
var identity = SplitSongId(song.Id);
|
|
if (favorite)
|
|
{
|
|
if (_favoriteFiles.ContainsKey(identity.Hash)) return;
|
|
var metadata = SongDataFor(song.Id);
|
|
var body = new JsonObject
|
|
{
|
|
["userid"] = ParseLong(account.UserId, "酷狗用户标识无效。"),
|
|
["token"] = account.Token,
|
|
["listid"] = _likedPlaylistListId,
|
|
["list_ver"] = 0,
|
|
["type"] = 0,
|
|
["slow_upload"] = 1,
|
|
["scene"] = "false;null",
|
|
["data"] = new JsonArray
|
|
{
|
|
new JsonObject
|
|
{
|
|
["number"] = 1,
|
|
["name"] = song.Name,
|
|
["hash"] = identity.Hash,
|
|
["size"] = 0,
|
|
["sort"] = 0,
|
|
["timelen"] = (long)song.Duration.TotalMilliseconds,
|
|
["bitrate"] = 0,
|
|
["album_id"] = ParseLong(identity.AlbumId, defaultValue: 0),
|
|
["mixsongid"] = metadata?.MixSongId ?? 0
|
|
}
|
|
}
|
|
};
|
|
await _api.SendAndroidAsync(
|
|
HttpMethod.Post,
|
|
"/cloudlist.service/v6/add_song",
|
|
new Dictionary<string, string>
|
|
{
|
|
["last_time"] = DateTimeOffset.UtcNow.ToUnixTimeSeconds().ToString(CultureInfo.InvariantCulture),
|
|
["last_area"] = "gztx"
|
|
},
|
|
body,
|
|
account,
|
|
null,
|
|
cancellationToken).ConfigureAwait(false);
|
|
}
|
|
else
|
|
{
|
|
if (!_favoriteFiles.TryGetValue(identity.Hash, out var fileId)) return;
|
|
await _api.SendAndroidAsync(
|
|
HttpMethod.Post,
|
|
"/v4/delete_songs",
|
|
null,
|
|
new JsonObject
|
|
{
|
|
["listid"] = _likedPlaylistListId,
|
|
["userid"] = ParseLong(account.UserId, "酷狗用户标识无效。"),
|
|
["data"] = new JsonArray { new JsonObject { ["fileid"] = fileId } },
|
|
["type"] = 0,
|
|
["token"] = account.Token,
|
|
["list_ver"] = 0
|
|
},
|
|
account,
|
|
"cloudlist.service.kugou.com",
|
|
cancellationToken).ConfigureAwait(false);
|
|
}
|
|
await EnsureFavoriteCacheAsync(force: true, cancellationToken).ConfigureAwait(false);
|
|
}
|
|
|
|
public Task SetPlaylistSubscribedAsync(MusicPlaylist playlist, bool subscribed, CancellationToken cancellationToken = default)
|
|
=> RunAccountOperationAsync(() => SetPlaylistSubscribedCoreAsync(playlist, subscribed, cancellationToken), cancellationToken);
|
|
|
|
private async Task SetPlaylistSubscribedCoreAsync(MusicPlaylist playlist, bool subscribed, CancellationToken cancellationToken)
|
|
{
|
|
var account = await RequireAccountAsync(cancellationToken).ConfigureAwait(false);
|
|
if (!playlist.CanSubscribe || playlist.ProviderData is not KugouPlaylistData metadata || metadata.Owned)
|
|
{
|
|
throw new InvalidOperationException("该歌单不是可收藏的外部酷狗歌单。");
|
|
}
|
|
await EnsureAccountCacheAsync(cancellationToken).ConfigureAwait(false);
|
|
var sourceKey = SubscriptionKey(metadata);
|
|
if (subscribed)
|
|
{
|
|
if (_subscriptionLists.ContainsKey(sourceKey)) return;
|
|
var response = await _api.SendAndroidAsync(
|
|
HttpMethod.Post,
|
|
"/cloudlist.service/v5/add_list",
|
|
null,
|
|
new JsonObject
|
|
{
|
|
["userid"] = ParseLong(account.UserId, "酷狗用户标识无效。"),
|
|
["token"] = account.Token,
|
|
["total_ver"] = 0,
|
|
["name"] = playlist.Name,
|
|
["type"] = 1,
|
|
["source"] = 1,
|
|
["is_pri"] = 0,
|
|
["list_create_userid"] = metadata.OwnerUserId,
|
|
["list_create_listid"] = metadata.SourceListId,
|
|
["list_create_gid"] = metadata.CollectionId,
|
|
["from_shupinmv"] = 0
|
|
},
|
|
account,
|
|
null,
|
|
cancellationToken).ConfigureAwait(false);
|
|
var createdListId = KugouApiClient.Long(response.Json["data"], "listid");
|
|
if (createdListId <= 0) createdListId = KugouApiClient.Long(response.Json, "listid");
|
|
if (createdListId <= 0) throw new InvalidOperationException("酷狗已接受收藏请求，但未返回账户歌单标识。请刷新“我的歌单”确认结果。");
|
|
try
|
|
{
|
|
var songs = await GetPlaylistTracksAsync(playlist.Id, 0, MaximumAccountItems, cancellationToken).ConfigureAwait(false);
|
|
foreach (var batch in songs.Chunk(50))
|
|
{
|
|
await AddSongsToAccountPlaylistAsync(account, createdListId, batch, cancellationToken).ConfigureAwait(false);
|
|
}
|
|
}
|
|
catch
|
|
{
|
|
try { await _api.DeleteCollectedPlaylistAsync(account, createdListId, cancellationToken).ConfigureAwait(false); } catch { }
|
|
throw;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!_subscriptionLists.TryGetValue(sourceKey, out var localListId) || localListId <= 0)
|
|
{
|
|
throw new InvalidOperationException("找不到该歌单在当前账户中的收藏副本，请刷新“我的歌单”后重试。");
|
|
}
|
|
if (localListId == _likedPlaylistListId) throw new InvalidOperationException("不能通过取消收藏操作删除“我喜欢”歌单。");
|
|
await _api.DeleteCollectedPlaylistAsync(account, localListId, cancellationToken).ConfigureAwait(false);
|
|
}
|
|
InvalidateAccountCaches();
|
|
await EnsureAccountCacheAsync(cancellationToken).ConfigureAwait(false);
|
|
}
|
|
|
|
public void Dispose()
|
|
{
|
|
_publicClient.Dispose();
|
|
_api.Dispose();
|
|
_initialization.Dispose();
|
|
_accountCacheGate.Dispose();
|
|
}
|
|
|
|
private async Task EnsureDeviceAsync(CancellationToken cancellationToken)
|
|
{
|
|
if (_deviceInitialized) return;
|
|
await _initialization.WaitAsync(cancellationToken).ConfigureAwait(false);
|
|
try
|
|
{
|
|
if (!_deviceInitialized) await EnsureDeviceCoreAsync(cancellationToken).ConfigureAwait(false);
|
|
}
|
|
finally
|
|
{
|
|
_initialization.Release();
|
|
}
|
|
}
|
|
|
|
private async Task EnsureDeviceCoreAsync(CancellationToken cancellationToken)
|
|
{
|
|
if (_deviceInitialized) return;
|
|
var stored = await _credentials.LoadAsync(DeviceCredentialKey, cancellationToken).ConfigureAwait(false);
|
|
KugouDeviceCredential? device = null;
|
|
if (!string.IsNullOrWhiteSpace(stored))
|
|
{
|
|
try { device = JsonSerializer.Deserialize<KugouDeviceCredential>(stored, CredentialJsonOptions); } catch (JsonException) { }
|
|
}
|
|
device ??= KugouApiClient.CreateDeviceCredential();
|
|
_api.Device = device;
|
|
await _credentials.SaveAsync(DeviceCredentialKey, JsonSerializer.Serialize(device, CredentialJsonOptions), cancellationToken).ConfigureAwait(false);
|
|
_deviceInitialized = true;
|
|
}
|
|
|
|
private async Task<KugouAccountCredential> RequireAccountAsync(CancellationToken cancellationToken)
|
|
{
|
|
await InitializeAsync(cancellationToken).ConfigureAwait(false);
|
|
if (LoginState.LoggedIn && (LoginState.IsStale || LoginState.Entitlements.Count == 0))
|
|
{
|
|
await RefreshLoginStateAsync(false, cancellationToken).ConfigureAwait(false);
|
|
}
|
|
return _account ?? throw new InvalidOperationException("请先登录酷狗音乐账户。");
|
|
}
|
|
|
|
private async Task<T> RunAccountOperationAsync<T>(Func<Task<T>> operation, CancellationToken cancellationToken)
|
|
{
|
|
try
|
|
{
|
|
return await operation().ConfigureAwait(false);
|
|
}
|
|
catch (KugouApiException exception) when (exception.AuthenticationFailure)
|
|
{
|
|
await ExpireAccountAsync(cancellationToken).ConfigureAwait(false);
|
|
throw new InvalidOperationException("酷狗登录已失效，请重新扫码登录。", exception);
|
|
}
|
|
}
|
|
|
|
private async Task RunAccountOperationAsync(Func<Task> operation, CancellationToken cancellationToken)
|
|
{
|
|
try
|
|
{
|
|
await operation().ConfigureAwait(false);
|
|
}
|
|
catch (KugouApiException exception) when (exception.AuthenticationFailure)
|
|
{
|
|
await ExpireAccountAsync(cancellationToken).ConfigureAwait(false);
|
|
throw new InvalidOperationException("酷狗登录已失效，请重新扫码登录。", exception);
|
|
}
|
|
}
|
|
|
|
private async Task ValidateAccountAsync(KugouAccountCredential account, CancellationToken cancellationToken)
|
|
=> _ = await LoadUserPlaylistPageAsync(account, 1, 1, cancellationToken).ConfigureAwait(false);
|
|
|
|
private async Task CommitAccountAsync(KugouAccountCredential account, bool save, CancellationToken cancellationToken)
|
|
{
|
|
_account = account with { Version = 2 };
|
|
var refreshedState = EnrichLoginState(ToLoginState(_account));
|
|
var entitlementResult = await LoadEntitlementsAsync(_account, cancellationToken).ConfigureAwait(false);
|
|
LoginState = _localApi is null
|
|
? refreshedState
|
|
: entitlementResult.Succeeded
|
|
? refreshedState with { Entitlements = entitlementResult.Grants }
|
|
: refreshedState with { Entitlements = [], IsCached = true, IsStale = true };
|
|
InvalidateAccountCaches();
|
|
if (save)
|
|
{
|
|
await _credentials.SaveAsync(Id, JsonSerializer.Serialize(_account, CredentialJsonOptions), cancellationToken).ConfigureAwait(false);
|
|
}
|
|
await SaveSessionAsync(_account, LoginState, cancellationToken).ConfigureAwait(false);
|
|
}
|
|
|
|
private async Task ClearAccountAsync(CancellationToken cancellationToken)
|
|
{
|
|
_account = null;
|
|
LoginState = new MusicLoginState(false);
|
|
InvalidateAccountCaches();
|
|
await _credentials.ClearAsync(Id, cancellationToken).ConfigureAwait(false);
|
|
if (_sessions is not null) await _sessions.ClearAsync(Id, cancellationToken).ConfigureAwait(false);
|
|
}
|
|
|
|
private async Task ExpireAccountAsync(CancellationToken cancellationToken)
|
|
{
|
|
await ClearAccountAsync(cancellationToken).ConfigureAwait(false);
|
|
_initialized = true;
|
|
}
|
|
|
|
private void InvalidateAccountCaches()
|
|
{
|
|
_accountCacheLoaded = false;
|
|
_favoriteCacheLoaded = false;
|
|
_likedPlaylistListId = 0;
|
|
_favoriteFiles.Clear();
|
|
_subscriptionLists.Clear();
|
|
}
|
|
|
|
private async Task EnsureAccountCacheAsync(CancellationToken cancellationToken)
|
|
{
|
|
if (_accountCacheLoaded || _account is null) return;
|
|
await _accountCacheGate.WaitAsync(cancellationToken).ConfigureAwait(false);
|
|
try
|
|
{
|
|
if (!_accountCacheLoaded)
|
|
{
|
|
_ = await LoadAllUserPlaylistsAsync(_account, refresh: true, cancellationToken).ConfigureAwait(false);
|
|
}
|
|
}
|
|
finally
|
|
{
|
|
_accountCacheGate.Release();
|
|
}
|
|
}
|
|
|
|
private async Task EnsureFavoriteCacheAsync(bool force, CancellationToken cancellationToken)
|
|
{
|
|
if (_favoriteCacheLoaded && !force) return;
|
|
await EnsureAccountCacheAsync(cancellationToken).ConfigureAwait(false);
|
|
if (_likedPlaylistListId <= 0)
|
|
{
|
|
_favoriteCacheLoaded = true;
|
|
return;
|
|
}
|
|
_favoriteFiles.Clear();
|
|
var songs = await LoadAccountPlaylistTracksAsync(_likedPlaylistListId, 0, MaximumAccountItems, cancellationToken).ConfigureAwait(false);
|
|
foreach (var song in songs)
|
|
{
|
|
if (song.ProviderData is KugouSongData { FileId: > 0 } metadata)
|
|
{
|
|
_favoriteFiles[metadata.Hash] = metadata.FileId;
|
|
}
|
|
}
|
|
_favoriteCacheLoaded = true;
|
|
}
|
|
|
|
private async Task<IReadOnlyList<MusicPlaylist>> LoadAllUserPlaylistsAsync(
|
|
KugouAccountCredential account,
|
|
bool refresh,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
if (refresh)
|
|
{
|
|
_likedPlaylistListId = 0;
|
|
_subscriptionLists.Clear();
|
|
}
|
|
var collected = new List<MusicPlaylist>();
|
|
const int pageSize = 100;
|
|
for (var page = 1; collected.Count < MaximumAccountItems; page++)
|
|
{
|
|
var nodes = await LoadUserPlaylistPageAsync(account, page, pageSize, cancellationToken).ConfigureAwait(false);
|
|
if (nodes.Count == 0) break;
|
|
collected.AddRange(nodes.Select(node => MapPlaylist(node, accountPlaylist: true)));
|
|
if (nodes.Count < pageSize) break;
|
|
}
|
|
_accountCacheLoaded = true;
|
|
_favoriteCacheLoaded = false;
|
|
return collected.Take(MaximumAccountItems).ToArray();
|
|
}
|
|
|
|
private async Task<IReadOnlyList<JsonNode>> LoadUserPlaylistPageAsync(
|
|
KugouAccountCredential account,
|
|
int page,
|
|
int pageSize,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
var response = await _api.SendAndroidAsync(
|
|
HttpMethod.Post,
|
|
"/v7/get_all_list",
|
|
new Dictionary<string, string> { ["plat"] = "1" },
|
|
new JsonObject
|
|
{
|
|
["userid"] = ParseLong(account.UserId, "酷狗用户标识无效。"),
|
|
["token"] = account.Token,
|
|
["total_ver"] = 979,
|
|
["type"] = 2,
|
|
["page"] = page,
|
|
["pagesize"] = pageSize
|
|
},
|
|
account,
|
|
"cloudlist.service.kugou.com",
|
|
cancellationToken).ConfigureAwait(false);
|
|
return PlaylistArray(response.Json);
|
|
}
|
|
|
|
private async Task<IReadOnlyList<MusicSong>> LoadAccountPlaylistTracksAsync(
|
|
long listId,
|
|
int offset,
|
|
int count,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
var account = await RequireAccountAsync(cancellationToken).ConfigureAwait(false);
|
|
var pageSize = Math.Min(100, Math.Max(20, count));
|
|
var skip = Math.Max(0, offset);
|
|
var page = skip / pageSize + 1;
|
|
var withinPage = skip % pageSize;
|
|
var collected = new List<MusicSong>(count);
|
|
while (collected.Count < count && collected.Count + skip < MaximumAccountItems)
|
|
{
|
|
var response = await _api.SendAndroidAsync(
|
|
HttpMethod.Post,
|
|
"/v4/get_list_all_file",
|
|
null,
|
|
new JsonObject
|
|
{
|
|
["listid"] = listId,
|
|
["userid"] = ParseLong(account.UserId, "酷狗用户标识无效。"),
|
|
["area_code"] = 1,
|
|
["show_relate_goods"] = 0,
|
|
["pagesize"] = pageSize,
|
|
["allplatform"] = 1,
|
|
["show_cover"] = 1,
|
|
["type"] = 0,
|
|
["token"] = account.Token,
|
|
["page"] = page
|
|
},
|
|
account,
|
|
"cloudlist.service.kugou.com",
|
|
cancellationToken).ConfigureAwait(false);
|
|
var nodes = SongArray(response.Json);
|
|
if (nodes.Count == 0) break;
|
|
collected.AddRange(nodes.Skip(withinPage).Select(MapSong));
|
|
if (nodes.Count < pageSize) break;
|
|
withinPage = 0;
|
|
page++;
|
|
}
|
|
return MusicSongRules.FilterDisplayable(collected).Take(count).ToArray();
|
|
}
|
|
|
|
private async Task<IReadOnlyList<MusicSong>> LoadCollectionTracksAsync(
|
|
string collectionId,
|
|
int offset,
|
|
int count,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
await EnsureDeviceAsync(cancellationToken).ConfigureAwait(false);
|
|
var collected = new List<MusicSong>(count);
|
|
var begin = Math.Max(0, offset);
|
|
while (collected.Count < count && begin < MaximumAccountItems)
|
|
{
|
|
var pageSize = Math.Min(100, count - collected.Count);
|
|
var response = await _api.SendAndroidAsync(
|
|
HttpMethod.Get,
|
|
"/pubsongs/v2/get_other_list_file_nofilt",
|
|
new Dictionary<string, string>
|
|
{
|
|
["area_code"] = "1",
|
|
["begin_idx"] = begin.ToString(CultureInfo.InvariantCulture),
|
|
["plat"] = "1",
|
|
["type"] = "1",
|
|
["mode"] = "1",
|
|
["personal_switch"] = "1",
|
|
["extend_fields"] = "abtags,hot_cmt,popularization",
|
|
["pagesize"] = pageSize.ToString(CultureInfo.InvariantCulture),
|
|
["global_collection_id"] = collectionId
|
|
},
|
|
null,
|
|
_account,
|
|
null,
|
|
cancellationToken).ConfigureAwait(false);
|
|
var nodes = SongArray(response.Json);
|
|
if (nodes.Count == 0) break;
|
|
collected.AddRange(nodes.Select(MapSong));
|
|
if (nodes.Count < pageSize) break;
|
|
begin += nodes.Count;
|
|
}
|
|
return MusicSongRules.FilterDisplayable(collected).Take(count).ToArray();
|
|
}
|
|
|
|
private async Task<IReadOnlyList<MusicSong>> GetRankTracksAsync(
|
|
string rankId,
|
|
int offset,
|
|
int count,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
var collected = new List<MusicSong>(count);
|
|
var page = Math.Max(0, offset) / 20 + 1;
|
|
var withinPage = Math.Max(0, offset) % 20;
|
|
while (collected.Count < count && page <= 25)
|
|
{
|
|
var result = await GetPublicJsonAsync(
|
|
$"https://m.kugou.com/rank/info/?rankid={Uri.EscapeDataString(rankId)}&page={page}&json=true",
|
|
cancellationToken).ConfigureAwait(false);
|
|
var songs = KugouApiClient.Array(result["songs"]?["list"]);
|
|
if (songs.Count == 0) break;
|
|
collected.AddRange(songs.Skip(withinPage).Select(MapSong));
|
|
if (songs.Count < 20) break;
|
|
withinPage = 0;
|
|
page++;
|
|
}
|
|
return MusicSongRules.FilterDisplayable(collected).Take(count).ToArray();
|
|
}
|
|
|
|
private async Task AddSongsToAccountPlaylistAsync(
|
|
KugouAccountCredential account,
|
|
long listId,
|
|
IReadOnlyCollection<MusicSong> songs,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
var resources = new JsonArray();
|
|
foreach (var song in songs)
|
|
{
|
|
var identity = SplitSongId(song.Id);
|
|
var metadata = SongDataFor(song.Id);
|
|
resources.Add(new JsonObject
|
|
{
|
|
["number"] = 1,
|
|
["name"] = song.Name,
|
|
["hash"] = identity.Hash,
|
|
["size"] = 0,
|
|
["sort"] = 0,
|
|
["timelen"] = (long)song.Duration.TotalMilliseconds,
|
|
["bitrate"] = 0,
|
|
["album_id"] = ParseLong(identity.AlbumId, defaultValue: 0),
|
|
["mixsongid"] = metadata?.MixSongId ?? 0
|
|
});
|
|
}
|
|
await _api.SendAndroidAsync(
|
|
HttpMethod.Post,
|
|
"/cloudlist.service/v6/add_song",
|
|
new Dictionary<string, string>
|
|
{
|
|
["last_time"] = DateTimeOffset.UtcNow.ToUnixTimeSeconds().ToString(CultureInfo.InvariantCulture),
|
|
["last_area"] = "gztx"
|
|
},
|
|
new JsonObject
|
|
{
|
|
["userid"] = ParseLong(account.UserId, "酷狗用户标识无效。"),
|
|
["token"] = account.Token,
|
|
["listid"] = listId,
|
|
["list_ver"] = 0,
|
|
["type"] = 0,
|
|
["slow_upload"] = 1,
|
|
["scene"] = "false;null",
|
|
["data"] = resources
|
|
},
|
|
account,
|
|
null,
|
|
cancellationToken).ConfigureAwait(false);
|
|
}
|
|
|
|
private MusicPlaylist MapPlaylist(JsonNode node, bool accountPlaylist)
|
|
{
|
|
var name = KugouApiClient.Text(node, "name") ?? KugouApiClient.Text(node, "specialname") ?? "酷狗歌单";
|
|
var localListId = FirstLong(node, "listid", "list_id");
|
|
var sourceListId = FirstLong(node, "list_create_listid", "specialid", "source_listid");
|
|
var ownerId = FirstLong(node, "list_create_userid", "userid", "author_id");
|
|
var collectionId = KugouApiClient.Text(node, "list_create_gid") ?? KugouApiClient.Text(node, "global_collection_id") ?? string.Empty;
|
|
var confirmedExternalCopy = accountPlaylist &&
|
|
_account is not null &&
|
|
ownerId > 0 &&
|
|
ownerId.ToString(CultureInfo.InvariantCulture) != _account.UserId &&
|
|
(sourceListId > 0 || !string.IsNullOrWhiteSpace(collectionId));
|
|
var owned = accountPlaylist && !confirmedExternalCopy;
|
|
var subscribed = confirmedExternalCopy;
|
|
var id = !string.IsNullOrWhiteSpace(collectionId)
|
|
? "collection:" + collectionId
|
|
: localListId > 0
|
|
? "list:" + localListId.ToString(CultureInfo.InvariantCulture)
|
|
: string.Empty;
|
|
var metadata = new KugouPlaylistData(collectionId, localListId, sourceListId, ownerId, owned);
|
|
if (accountPlaylist)
|
|
{
|
|
if (IsLikedPlaylist(node, name, owned)) _likedPlaylistListId = localListId;
|
|
if (subscribed && localListId > 0) _subscriptionLists[SubscriptionKey(metadata)] = localListId;
|
|
}
|
|
else if (_subscriptionLists.TryGetValue(SubscriptionKey(metadata), out _))
|
|
{
|
|
subscribed = true;
|
|
}
|
|
var playlist = new MusicPlaylist(
|
|
Id,
|
|
id,
|
|
name,
|
|
NormalizeImage(KugouApiClient.Text(node, "pic") ?? KugouApiClient.Text(node, "imgurl") ?? KugouApiClient.Text(node, "image") ?? string.Empty),
|
|
Math.Max(KugouApiClient.Integer(node, "count"), KugouApiClient.Integer(node, "song_count")),
|
|
KugouApiClient.Text(node, "list_create_username") ?? KugouApiClient.Text(node, "author_name") ?? (owned ? LoginState.Nickname : "酷狗音乐"),
|
|
subscribed)
|
|
{
|
|
CanSubscribe = !owned && (localListId > 0 || sourceListId > 0 || !string.IsNullOrWhiteSpace(collectionId)),
|
|
ProviderData = metadata
|
|
};
|
|
if (!string.IsNullOrWhiteSpace(id)) _playlistData[id] = metadata;
|
|
return playlist;
|
|
}
|
|
|
|
private MusicSong MapSong(JsonNode node)
|
|
{
|
|
var hash = KugouApiClient.Text(node, "FileHash") ?? KugouApiClient.Text(node, "hash") ?? KugouApiClient.Text(node, "file_hash") ?? string.Empty;
|
|
var albumId = KugouApiClient.Text(node, "AlbumID") ?? KugouApiClient.Text(node, "album_id") ?? KugouApiClient.Text(node, "albumid") ?? "0";
|
|
var artist = KugouApiClient.Text(node, "SingerName") ?? KugouApiClient.Text(node, "singername") ?? KugouApiClient.Text(node, "h5_author_name") ?? KugouApiClient.Text(node, "author_name") ?? KugouApiClient.Text(node, "author") ?? string.Empty;
|
|
var artistId = KugouApiClient.Text(node, "SingerId") ?? KugouApiClient.Text(node, "singerid") ?? KugouApiClient.Text(KugouApiClient.Array(node["authors"]).FirstOrDefault(), "author_id") ?? artist;
|
|
var duration = FirstLong(node, "Duration", "duration", "timelen", "time_length");
|
|
var durationValue = duration > 10_000 ? TimeSpan.FromMilliseconds(duration) : TimeSpan.FromSeconds(Math.Max(0, duration));
|
|
var metadata = new KugouSongData(
|
|
hash,
|
|
ParseLong(albumId, defaultValue: 0),
|
|
FirstLong(node, "mixsongid", "album_audio_id", "audio_id"),
|
|
FirstLong(node, "fileid", "file_id"));
|
|
var song = new MusicSong(
|
|
Id,
|
|
ComposeSongId(hash, albumId),
|
|
KugouApiClient.Text(node, "SongName") ?? KugouApiClient.Text(node, "songname") ?? KugouApiClient.Text(node, "FileName") ?? KugouApiClient.Text(node, "filename") ?? KugouApiClient.Text(node, "name") ?? string.Empty,
|
|
artist,
|
|
string.IsNullOrWhiteSpace(artist) ? [] : [new MusicArtist(artistId, artist)],
|
|
KugouApiClient.Text(node, "AlbumName") ?? KugouApiClient.Text(node, "album_name") ?? KugouApiClient.Text(node, "remark") ?? string.Empty,
|
|
NormalizeImage(KugouApiClient.Text(node, "Image") ?? KugouApiClient.Text(node?["trans_param"], "union_cover") ?? KugouApiClient.Text(node, "imgurl") ?? KugouApiClient.Text(node, "sizable_cover") ?? string.Empty),
|
|
durationValue,
|
|
Math.Max(KugouApiClient.Integer(node, "PayType"), KugouApiClient.Integer(node, "pay_type")))
|
|
{
|
|
MvId = KugouApiClient.Text(node, "MvHash") ?? KugouApiClient.Text(node, "mvhash") ?? KugouApiClient.Text(KugouApiClient.Array(node?["mvdata"]).FirstOrDefault(), "hash"),
|
|
ProviderData = metadata
|
|
};
|
|
if (!string.IsNullOrWhiteSpace(song.Id)) _songData[song.Id] = metadata;
|
|
return song;
|
|
}
|
|
|
|
private KugouSongData? SongDataFor(string songId)
|
|
=> _songData.TryGetValue(songId, out var value)
|
|
? value
|
|
: new KugouSongData(SplitSongId(songId).Hash, ParseLong(SplitSongId(songId).AlbumId, defaultValue: 0), 0, 0);
|
|
|
|
private async Task<JsonObject> GetPublicJsonAsync(string uri, CancellationToken cancellationToken)
|
|
{
|
|
using var request = new HttpRequestMessage(HttpMethod.Get, uri);
|
|
request.Headers.Accept.Add(new MediaTypeWithQualityHeaderValue("application/json"));
|
|
using var response = await _publicClient.SendAsync(request, HttpCompletionOption.ResponseContentRead, cancellationToken).ConfigureAwait(false);
|
|
var text = await response.Content.ReadAsStringAsync(cancellationToken).ConfigureAwait(false);
|
|
if (!response.IsSuccessStatusCode) throw new HttpRequestException($"酷狗音乐服务返回 HTTP {(int)response.StatusCode}。", null, response.StatusCode);
|
|
return JsonNode.Parse(text) as JsonObject ?? throw new JsonException("酷狗音乐服务返回了无效 JSON。");
|
|
}
|
|
|
|
private static KugouAccountCredential? ParseStoredAccount(string secret, out bool migrated)
|
|
{
|
|
migrated = false;
|
|
try
|
|
{
|
|
var account = JsonSerializer.Deserialize<KugouAccountCredential>(secret, CredentialJsonOptions);
|
|
if (account is not null && !string.IsNullOrWhiteSpace(account.UserId) && !string.IsNullOrWhiteSpace(account.Token)) return account;
|
|
}
|
|
catch (JsonException)
|
|
{
|
|
}
|
|
var cookies = ParseCookie(secret);
|
|
var composite = cookies.GetValueOrDefault("KuGoo");
|
|
var fields = string.IsNullOrWhiteSpace(composite)
|
|
? new Dictionary<string, string>(StringComparer.OrdinalIgnoreCase)
|
|
: ParseAmpersandFields(global::System.Net.WebUtility.UrlDecode(composite));
|
|
var userId = fields.GetValueOrDefault("KugooID") ?? cookies.GetValueOrDefault("KugooID") ?? cookies.GetValueOrDefault("userid") ?? string.Empty;
|
|
var token = fields.GetValueOrDefault("t") ?? cookies.GetValueOrDefault("t") ?? cookies.GetValueOrDefault("token") ?? string.Empty;
|
|
if (string.IsNullOrWhiteSpace(userId) || string.IsNullOrWhiteSpace(token)) return null;
|
|
migrated = true;
|
|
return new KugouAccountCredential(
|
|
2,
|
|
userId,
|
|
token,
|
|
fields.GetValueOrDefault("NickName") ?? fields.GetValueOrDefault("UserName") ?? "酷狗用户",
|
|
NormalizeImage(fields.GetValueOrDefault("Pic") ?? string.Empty),
|
|
fields.GetValueOrDefault("VipType") ?? fields.GetValueOrDefault("vip_type") ?? "none",
|
|
cookies.GetValueOrDefault("vip_token") ?? string.Empty,
|
|
cookies.GetValueOrDefault("t1") ?? string.Empty);
|
|
}
|
|
|
|
private static Dictionary<string, string> ParseCookie(string cookie)
|
|
=> cookie.Split(';', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries)
|
|
.Select(part => part.Split('=', 2, StringSplitOptions.TrimEntries))
|
|
.Where(pair => pair.Length == 2 && !string.IsNullOrWhiteSpace(pair[0]))
|
|
.GroupBy(pair => pair[0], StringComparer.OrdinalIgnoreCase)
|
|
.ToDictionary(group => group.Key, group => group.Last()[1], StringComparer.OrdinalIgnoreCase);
|
|
|
|
private static Dictionary<string, string> ParseAmpersandFields(string value)
|
|
=> value.Split('&', StringSplitOptions.RemoveEmptyEntries | StringSplitOptions.TrimEntries)
|
|
.Select(part => part.Split('=', 2, StringSplitOptions.TrimEntries))
|
|
.Where(pair => pair.Length == 2 && !string.IsNullOrWhiteSpace(pair[0]))
|
|
.GroupBy(pair => pair[0], StringComparer.OrdinalIgnoreCase)
|
|
.ToDictionary(group => group.Key, group => group.Last()[1], StringComparer.OrdinalIgnoreCase);
|
|
|
|
private static IReadOnlyList<JsonNode> PlaylistArray(JsonObject root)
|
|
=> FirstArray(root["data"]?["info"], root["data"]?["special_list"], root["data"]?["list"], root["info"], root["list"]);
|
|
|
|
private static IReadOnlyList<JsonNode> SongArray(JsonObject root)
|
|
=> FirstArray(root["data"]?["song_list"], root["data"]?["songs"], root["data"]?["info"], root["data"]?["list"], root["songs"]?["list"], root["info"], root["list"]);
|
|
|
|
private static IReadOnlyList<JsonNode> FirstArray(params JsonNode?[] candidates)
|
|
=> candidates.Select(KugouApiClient.Array).FirstOrDefault(items => items.Count > 0) ?? [];
|
|
|
|
private static string? FirstText(JsonNode? node, string property)
|
|
=> KugouApiClient.Array(node?[property]).Select(item => item.GetValue<string>()).FirstOrDefault(value => !string.IsNullOrWhiteSpace(value));
|
|
|
|
private static long FirstLong(JsonNode node, params string[] names)
|
|
=> names.Select(name => KugouApiClient.Long(node, name)).FirstOrDefault(value => value != 0);
|
|
|
|
private static string NormalizeImage(string value)
|
|
=> value
|
|
.Replace("http://imge.kugou.com", "https://imge.kugou.com", StringComparison.OrdinalIgnoreCase)
|
|
.Replace("http://imgessl.kugou.com", "https://imgessl.kugou.com", StringComparison.OrdinalIgnoreCase)
|
|
.Replace("{size}", "480", StringComparison.Ordinal);
|
|
|
|
private static string ComposeSongId(string hash, string? albumId)
|
|
=> string.IsNullOrWhiteSpace(albumId) || albumId == "0" ? hash : $"{hash}|{albumId}";
|
|
|
|
private static (string Hash, string AlbumId) SplitSongId(string songId)
|
|
{
|
|
var separator = songId.IndexOf('|');
|
|
return separator < 0 ? (songId, "0") : (songId[..separator], songId[(separator + 1)..]);
|
|
}
|
|
|
|
private static long ParseLong(string value, string error)
|
|
=> long.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) && result > 0
|
|
? result
|
|
: throw new InvalidOperationException(error);
|
|
|
|
private static long ParseLong(string value, long defaultValue)
|
|
=> long.TryParse(value, NumberStyles.Integer, CultureInfo.InvariantCulture, out var result) ? result : defaultValue;
|
|
|
|
private static bool IsLikedPlaylist(JsonNode node, string name, bool owned)
|
|
=> owned && (KugouApiClient.Integer(node, "is_like") == 1 ||
|
|
KugouApiClient.Integer(node, "is_default") == 1 ||
|
|
string.Equals(name.Trim(), "我喜欢", StringComparison.Ordinal));
|
|
|
|
private static string SubscriptionKey(KugouPlaylistData data)
|
|
=> !string.IsNullOrWhiteSpace(data.CollectionId)
|
|
? "gid:" + data.CollectionId
|
|
: $"source:{data.OwnerUserId}:{data.SourceListId}";
|
|
|
|
private static MusicLoginState ToLoginState(KugouAccountCredential account)
|
|
=> new(true, account.UserId, account.Nickname, account.AvatarUrl, account.VipLevel);
|
|
|
|
private async Task SaveSessionAsync(KugouAccountCredential account, MusicLoginState state, CancellationToken cancellationToken)
|
|
{
|
|
if (_sessions is null || !state.LoggedIn) return;
|
|
await _sessions.SaveAsync(new MusicAccountSession(
|
|
DpapiMusicAccountSessionStore.CurrentVersion,
|
|
Id,
|
|
JsonSerializer.Serialize(account, CredentialJsonOptions),
|
|
state,
|
|
DateTimeOffset.UtcNow), cancellationToken).ConfigureAwait(false);
|
|
}
|
|
|
|
private async Task<KugouEntitlementLoadResult> LoadEntitlementsAsync(
|
|
KugouAccountCredential account,
|
|
CancellationToken cancellationToken)
|
|
{
|
|
if (_localApi is null) return new(false, []);
|
|
try
|
|
{
|
|
var cookie = $"token={account.Token};userid={account.UserId}";
|
|
if (!string.IsNullOrWhiteSpace(account.VipLevel)) cookie += $";vip_type={account.VipLevel}";
|
|
if (!string.IsNullOrWhiteSpace(account.VipToken)) cookie += $";vip_token={account.VipToken}";
|
|
if (!string.IsNullOrWhiteSpace(account.T1)) cookie += $";t1={account.T1}";
|
|
var response = await _localApi.SendApiAsync(
|
|
"/user/vip/detail",
|
|
method: HttpMethod.Post,
|
|
body: new JsonObject { ["cookie"] = cookie },
|
|
cancellationToken: cancellationToken).ConfigureAwait(false);
|
|
if (!KugouEntitlementParser.IsSuccessfulResponse(response)) return new(false, []);
|
|
var grants = KugouEntitlementParser.Parse(response);
|
|
return new(true, grants.Count == 0
|
|
? [new MusicEntitlementGrant("none", "酷狗会员", "membership", false)]
|
|
: grants);
|
|
}
|
|
catch (OperationCanceledException) when (cancellationToken.IsCancellationRequested)
|
|
{
|
|
throw;
|
|
}
|
|
catch
|
|
{
|
|
return new(false, []);
|
|
}
|
|
}
|
|
|
|
private static MusicLoginState EnrichLoginState(MusicLoginState state)
|
|
{
|
|
if (!state.LoggedIn) return state;
|
|
var raw = string.IsNullOrWhiteSpace(state.VipLevel) ? "none" : state.VipLevel.Trim();
|
|
var known = raw.ToLowerInvariant() switch
|
|
{
|
|
"1" or "vip" => new MusicEntitlementGrant(raw, "酷狗 VIP", "membership", true),
|
|
"2" or "svip" => new MusicEntitlementGrant(raw, "酷狗 SVIP", "membership", true),
|
|
"music" or "musicpack" => new MusicEntitlementGrant(raw, "音乐包", "music-package", true),
|
|
"none" or "0" => null,
|
|
_ => new MusicEntitlementGrant(raw, raw, "unknown", true)
|
|
};
|
|
return state with
|
|
{
|
|
Entitlements = known is null ? [] : [known],
|
|
RefreshedAt = DateTimeOffset.UtcNow,
|
|
IsCached = false,
|
|
IsStale = false
|
|
};
|
|
}
|
|
|
|
internal static IReadOnlyList<MusicQualityOption> BuildQualityOptions(MusicLoginState state)
|
|
{
|
|
var active = state.Entitlements.Where(IsActiveEntitlement).ToArray();
|
|
var svip = active.Any(IsSvipEntitlement);
|
|
var vip = svip || active.Any(IsVipEntitlement);
|
|
return
|
|
[
|
|
new(MusicPlaybackQuality.Master, "蝰蛇母带", "FLAC", 1000, "酷狗 SVIP", svip ? MusicQualityAvailability.Available : MusicQualityAvailability.RequiresEntitlement, svip ? null : "需要酷狗 SVIP 权益"),
|
|
new(MusicPlaybackQuality.HiRes, "Hi-Res", "FLAC", 900, "酷狗 VIP", vip ? MusicQualityAvailability.Available : MusicQualityAvailability.RequiresEntitlement, vip ? null : "需要酷狗 VIP 权益"),
|
|
new(MusicPlaybackQuality.Lossless, "无损音质", "FLAC", 800, "酷狗 VIP", vip ? MusicQualityAvailability.Available : MusicQualityAvailability.RequiresEntitlement, vip ? null : "需要酷狗 VIP 权益"),
|
|
new(MusicPlaybackQuality.High, "高品音质", "MP3", 320, "", MusicQualityAvailability.Available),
|
|
new(MusicPlaybackQuality.Standard, "标准音质", "MP3", 128, "", MusicQualityAvailability.Available)
|
|
];
|
|
}
|
|
|
|
private static bool IsActiveEntitlement(MusicEntitlementGrant item)
|
|
=> item.Enabled && (item.ExpiresAt is null || item.ExpiresAt > DateTimeOffset.UtcNow);
|
|
|
|
private static bool IsSvipEntitlement(MusicEntitlementGrant item)
|
|
=> item.PlatformCode.Equals("svip", StringComparison.OrdinalIgnoreCase) ||
|
|
item.PlatformCode is "2" or "6";
|
|
|
|
private static bool IsVipEntitlement(MusicEntitlementGrant item)
|
|
=> IsSvipEntitlement(item) ||
|
|
item.PlatformCode.Equals("vip", StringComparison.OrdinalIgnoreCase) ||
|
|
item.PlatformCode.Equals("dvip", StringComparison.OrdinalIgnoreCase) ||
|
|
item.PlatformCode.Equals("qvip", StringComparison.OrdinalIgnoreCase) ||
|
|
item.PlatformCode == "1";
|
|
|
|
private sealed record KugouSongData(string Hash, long AlbumId, long MixSongId, long FileId);
|
|
|
|
private sealed record KugouPlaybackCandidate(MusicPlaybackQuality Quality, string Value, string Hash, int Bitrate);
|
|
|
|
private sealed record KugouPlaylistData(string CollectionId, long LocalListId, long SourceListId, long OwnerUserId, bool Owned);
|
|
}
|