Haify/NowPlayingItemMapper.cpp at main · m199/Haify · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
#include "NowPlayingItem.h"
#include "spotify/SpotifyUri.h"

namespace {

std::string
JsonString(const nlohmann::json& object, const char* key)
{
	if (!object.is_object() || !object.contains(key)
			|| !object[key].is_string()) {
		return "";
	}
	return object[key].get<std::string>();
}


std::string
FirstImageUrl(const nlohmann::json& object)
{
	if (!object.is_object() || !object.contains("images")
			|| !object["images"].is_array() || object["images"].empty()) {
		return "";
	}
	return object["images"][0].value("url", "");
}


void
MapTrackParent(NowPlayingItem& result, const nlohmann::json& item)
{
	if (item.contains("artists") && item["artists"].is_array()
			&& !item["artists"].empty()) {
		const nlohmann::json& artist = item["artists"][0];
		result.displaySubtitle = JsonString(artist, "name");
		result.artistId = JsonString(artist, "id");
	}

	if (!item.contains("album") || !item["album"].is_object())
		return;

	const nlohmann::json& album = item["album"];
	result.albumId = JsonString(album, "id");
	result.imageUrl = FirstImageUrl(album);
	result.parentKind = "album";
	result.parentUri = JsonString(album, "uri");
	if (result.parentUri.empty())
		result.parentUri = SpotifyUriForItemKind(kSpotifyItemAlbum,
			result.albumId);
	result.primaryOpenUri = result.parentUri;
}


void
MapEpisodeParent(NowPlayingItem& result, const nlohmann::json& item)
{
	if (item.contains("audiobook") && item["audiobook"].is_object()) {
		const nlohmann::json& audiobook = item["audiobook"];
		result.audiobookId = JsonString(audiobook, "id");
		result.displaySubtitle = JsonString(audiobook, "name");
		result.parentKind = "audiobook";
		result.parentUri = JsonString(audiobook, "uri");
		if (result.parentUri.empty()) {
			result.parentUri = SpotifyUriForItemKind(kSpotifyItemAudiobook,
				result.audiobookId);
		}
		result.primaryOpenUri = result.parentUri;
		if (result.imageUrl.empty())
			result.imageUrl = FirstImageUrl(audiobook);
		return;
	}

	if (item.contains("show") && item["show"].is_object()) {
		const nlohmann::json& show = item["show"];
		result.showId = JsonString(show, "id");
		result.displaySubtitle = JsonString(show, "name");
		if (result.displaySubtitle.empty())
			result.displaySubtitle = JsonString(show, "publisher");
		result.parentKind = "show";
		result.parentUri = JsonString(show, "uri");
		if (result.parentUri.empty())
			result.parentUri = SpotifyUriForItemKind(kSpotifyItemShow,
				result.showId);
		result.primaryOpenUri = result.parentUri;
		if (result.imageUrl.empty())
			result.imageUrl = FirstImageUrl(show);
	}
}

}


NowPlayingItem
NowPlayingItem::FromSpotifyItem(const nlohmann::json& item,
	const std::string& fallbackType)
{
	NowPlayingItem result;
	if (!item.is_object())
		return result;

	result.displayTitle = JsonString(item, "name");
	result.durationMs = (int32)item.value("duration_ms", 0);
	result.itemUri = JsonString(item, "uri");
	result.itemKind = JsonString(item, "type");
	if (result.itemKind.empty())
		result.itemKind = fallbackType;
	if (result.itemKind.empty()) {
		SpotifyItemKind uriKind = SpotifyItemKindForUri(result.itemUri);
		if (uriKind != kSpotifyItemUnknown)
			result.itemKind = SpotifyItemTypeName(uriKind);
	}
	result.primaryOpenUri = result.itemUri;
	result.imageUrl = FirstImageUrl(item);

	if (result.itemKind == "track")
		MapTrackParent(result, item);
	else if (result.itemKind == "episode" || result.itemKind == "chapter")
		MapEpisodeParent(result, item);

	if (result.primaryOpenUri.empty())
		result.primaryOpenUri = result.parentUri.empty()
			? result.itemUri : result.parentUri;

	return result;
}