void CGUIDialogMediaFilter::InitializeSettings()
{
CGUIDialogSettingsManualBase::InitializeSettings();
if (m_filter == NULL)
return;
Reset(true);
int handledRules = 0;
CSettingCategory *category = AddCategory("filter", -1);
if (category == NULL)
{
CLog::Log(LOGERROR, "CGUIDialogMediaFilter: unable to setup filters");
return;
}
CSettingGroup *group = AddGroup(category);
if (group == NULL)
{
CLog::Log(LOGERROR, "CGUIDialogMediaFilter: unable to setup filters");
return;
}
for (unsigned int index = 0; index < NUM_FILTERS; index++)
{
if (filterList[index].mediaType != m_mediaType)
continue;
Filter filter = filterList[index];
// check the smartplaylist if it contains a matching rule
for (CDatabaseQueryRules::iterator rule = m_filter->m_ruleCombination.m_rules.begin(); rule != m_filter->m_ruleCombination.m_rules.end(); rule++)
{
if ((*rule)->m_field == filter.field)
{
filter.rule = (CSmartPlaylistRule *)rule->get();
handledRules++;
break;
}
}
std::string settingId = StringUtils::Format("filter.%s.%d", filter.mediaType.c_str(), filter.field);
if (filter.controlType == "edit")
{
CVariant data;
if (filter.rule != NULL && filter.rule->m_parameter.size() == 1)
data = filter.rule->m_parameter.at(0);
if (filter.settingType == SettingTypeString)
filter.setting = AddEdit(group, settingId, filter.label, 0, data.asString(), true, false, filter.label, true);
else if (filter.settingType == SettingTypeInteger)
filter.setting = AddEdit(group, settingId, filter.label, 0, static_cast<int>(data.asInteger()), 0, 1, 0, false, static_cast<int>(filter.label), true);
else if (filter.settingType == SettingTypeNumber)
filter.setting = AddEdit(group, settingId, filter.label, 0, data.asFloat(), 0.0f, 1.0f, 0.0f, false, filter.label, true);
}
else if (filter.controlType == "toggle")
{
int value = CHECK_ALL;
if (filter.rule != NULL)
value = filter.rule->m_operator == CDatabaseQueryRule::OPERATOR_TRUE ? CHECK_YES : CHECK_NO;
StaticIntegerSettingOptions entries;
entries.push_back(std::pair<int, int>(CHECK_LABEL_ALL, CHECK_ALL));
entries.push_back(std::pair<int, int>(CHECK_LABEL_NO, CHECK_NO));
entries.push_back(std::pair<int, int>(CHECK_LABEL_YES, CHECK_YES));
filter.setting = AddSpinner(group, settingId, filter.label, 0, value, entries, true);
}
else if (filter.controlType == "list")
{
std::vector<std::string> values;
if (filter.rule != NULL && !filter.rule->m_parameter.empty())
{
values = StringUtils::Split(filter.rule->GetParameter(), DATABASEQUERY_RULE_VALUE_SEPARATOR);
if (values.size() == 1 && values.at(0).empty())
values.erase(values.begin());
}
filter.setting = AddList(group, settingId, filter.label, 0, values, GetStringListOptions, filter.label);
}
else if (filter.controlType == "range")
{
CVariant valueLower, valueUpper;
if (filter.rule != NULL)
{
if (filter.rule->m_parameter.size() == 2)
{
valueLower = filter.rule->m_parameter.at(0);
valueUpper = filter.rule->m_parameter.at(1);
}
else
{
DeleteRule(filter.field);
filter.rule = NULL;
}
}
if (filter.settingType == SettingTypeInteger)
{
int min, interval, max;
GetRange(filter, min, interval, max);
// don't create the filter if there's no real range
if (min == max)
continue;
int iValueLower = valueLower.isNull() ? min : static_cast<int>(valueLower.asInteger());
int iValueUpper = valueUpper.isNull() ? max : static_cast<int>(valueUpper.asInteger());
if (filter.controlFormat == "integer")
filter.setting = AddRange(group, settingId, filter.label, 0, iValueLower, iValueUpper, min, interval, max, -1, 21469, true);
else if (filter.controlFormat == "percentage")
filter.setting = AddPercentageRange(group, settingId, filter.label, 0, iValueLower, iValueUpper, -1, 1, 21469, true);
else if (filter.controlFormat == "date")
filter.setting = AddDateRange(group, settingId, filter.label, 0, iValueLower, iValueUpper, min, interval, max, -1, 21469, true);
else if (filter.controlFormat == "time")
filter.setting = AddTimeRange(group, settingId, filter.label, 0, iValueLower, iValueUpper, min, interval, max, -1, 21469, true);
}
else if (filter.settingType == SettingTypeNumber)
{
float min, interval, max;
GetRange(filter, min, interval, max);
// don't create the filter if there's no real range
if (min == max)
continue;
float fValueLower = valueLower.isNull() ? min : valueLower.asFloat();
float fValueUpper = valueUpper.isNull() ? max : valueUpper.asFloat();
filter.setting = AddRange(group, settingId, filter.label, 0, fValueLower, fValueUpper, min, interval, max, -1, 21469, true);
}
}
else
{
if (filter.rule != NULL)
handledRules--;
CLog::Log(LOGWARNING, "CGUIDialogMediaFilter: filter %d of media type %s with unknown control type '%s'",
filter.field, filter.mediaType.c_str(), filter.controlType.c_str());
continue;
}
if (filter.setting == NULL)
{
if (filter.rule != NULL)
handledRules--;
CLog::Log(LOGWARNING, "CGUIDialogMediaFilter: failed to create filter %d of media type %s with control type '%s'",
filter.field, filter.mediaType.c_str(), filter.controlType.c_str());
continue;
}
m_filters.insert(make_pair(settingId, filter));
}
// make sure that no change in capacity size is needed when adding new rules
// which would copy around the rules and our pointers in the Filter struct
// wouldn't work anymore
m_filter->m_ruleCombination.m_rules.reserve(m_filters.size() + (m_filter->m_ruleCombination.m_rules.size() - handledRules));
}
void CFileItemHandler::FillDetails(ISerializable* info, CFileItemPtr item, const CVariant& fields, CVariant &result)
{
if (info == NULL || fields.size() == 0)
return;
CVariant serialization;
info->Serialize(serialization);
for (unsigned int i = 0; i < fields.size(); i++)
{
CStdString field = fields[i].asString();
if (item)
{
if (item->IsAlbum() && field.Equals("albumlabel"))
field = "label";
if (item->IsAlbum())
{
if (field == "label")
{
result["albumlabel"] = item->GetProperty("album_label");
continue;
}
/* This would break backwards compatibility to JSON-RPC API v4
if (item->HasProperty("album_" + field + "_array"))
{
result[field] = item->GetProperty("album_" + field + "_array");
continue;
}*/
if (item->HasProperty("album_" + field))
{
result[field] = item->GetProperty("album_" + field);
continue;
}
}
/* This would break backwards compatibility to JSON-RPC API v4
if (item->HasProperty("artist_" + field + "_array"))
{
result[field] = item->GetProperty("artist_" + field + "_array");
continue;
}*/
if (item->HasProperty("artist_" + field))
{
result[field] = item->GetProperty("artist_" + field);
continue;
}
if (field == "fanart" && !item->HasPictureInfoTag())
{
CStdString fanart;
if (item->HasProperty("fanart_image"))
fanart = item->GetProperty("fanart_image").asString();
if (fanart.empty())
fanart = item->GetCachedFanart();
if (!fanart.empty())
result["fanart"] = fanart.c_str();
continue;
}
if (item->HasVideoInfoTag() && item->GetVideoContentType() == VIDEODB_CONTENT_TVSHOWS)
{
if (item->GetVideoInfoTag()->m_iSeason < 0 && field == "season")
{
result[field] = (int)item->GetProperty("totalseasons").asInteger();
continue;
}
if (field == "watchedepisodes")
{
result[field] = (int)item->GetProperty("watchedepisodes").asInteger();
continue;
}
}
if (field == "lastmodified" && item->m_dateTime.IsValid())
{
result[field] = item->m_dateTime.GetAsLocalizedDateTime();
continue;
}
}
if (serialization.isMember(field) && (!result.isMember(field) || result[field].empty()))
result[field] = serialization[field];
}
}
JSONRPC_STATUS CPlayerOperations::SetShuffle(const CStdString &method, ITransportLayer *transport, IClient *client, const CVariant ¶meterObject, CVariant &result)
{
CGUIWindowSlideShow *slideshow = NULL;
CVariant shuffle = parameterObject["shuffle"];
switch (GetPlayer(parameterObject["playerid"]))
{
case Video:
case Audio:
{
if (IsPVRChannel())
return FailedToExecute;
int playlistid = GetPlaylist(GetPlayer(parameterObject["playerid"]));
if (g_playlistPlayer.IsShuffled(playlistid))
{
if ((shuffle.isBoolean() && !shuffle.asBoolean()) ||
(shuffle.isString() && shuffle.asString() == "toggle"))
{
CApplicationMessenger::Get().PlayListPlayerShuffle(playlistid, false);
OnPlaylistChanged();
}
}
else
{
if ((shuffle.isBoolean() && shuffle.asBoolean()) ||
(shuffle.isString() && shuffle.asString() == "toggle"))
{
CApplicationMessenger::Get().PlayListPlayerShuffle(playlistid, true);
OnPlaylistChanged();
}
}
break;
}
case Picture:
slideshow = (CGUIWindowSlideShow*)g_windowManager.GetWindow(WINDOW_SLIDESHOW);
if (slideshow == NULL)
return FailedToExecute;
if (slideshow->IsShuffled())
{
if ((shuffle.isBoolean() && !shuffle.asBoolean()) ||
(shuffle.isString() && shuffle.asString() == "toggle"))
return FailedToExecute;
}
else
{
if ((shuffle.isBoolean() && shuffle.asBoolean()) ||
(shuffle.isString() && shuffle.asString() == "toggle"))
slideshow->Shuffle();
}
break;
default:
return FailedToExecute;
}
return ACK;
}
CVariant CDBusUtil::ParseType(DBusMessageIter *itr)
{
CVariant value;
const char * string = NULL;
dbus_int32_t int32 = 0;
dbus_uint32_t uint32 = 0;
dbus_int64_t int64 = 0;
dbus_uint64_t uint64 = 0;
dbus_bool_t boolean = false;
double doublev = 0;
int type = dbus_message_iter_get_arg_type(itr);
switch (type)
{
case DBUS_TYPE_OBJECT_PATH:
case DBUS_TYPE_STRING:
dbus_message_iter_get_basic(itr, &string);
value = string;
break;
case DBUS_TYPE_UINT32:
dbus_message_iter_get_basic(itr, &uint32);
value = (uint64_t)uint32;
break;
case DBUS_TYPE_BYTE:
case DBUS_TYPE_INT32:
dbus_message_iter_get_basic(itr, &int32);
value = (int64_t)int32;
break;
case DBUS_TYPE_UINT64:
dbus_message_iter_get_basic(itr, &uint64);
value = (uint64_t)uint64;
break;
case DBUS_TYPE_INT64:
dbus_message_iter_get_basic(itr, &int64);
value = (int64_t)int64;
break;
case DBUS_TYPE_BOOLEAN:
dbus_message_iter_get_basic(itr, &boolean);
value = (bool)boolean;
break;
case DBUS_TYPE_DOUBLE:
dbus_message_iter_get_basic(itr, &doublev);
value = (double)doublev;
break;
case DBUS_TYPE_ARRAY:
DBusMessageIter array;
dbus_message_iter_recurse(itr, &array);
value = CVariant::VariantTypeArray;
do
{
CVariant item = ParseType(&array);
if (!item.isNull())
value.push_back(item);
} while (dbus_message_iter_next(&array));
break;
}
return value;
}
bool CFileItemHandler::GetField(const std::string &field, const CVariant &info, const CFileItemPtr &item, CVariant &result, bool &fetchedArt, CThumbLoader *thumbLoader /* = NULL */)
{
if (result.isMember(field) && !result[field].empty())
return true;
if (info.isMember(field) && !info[field].isNull())
{
result[field] = info[field];
return true;
}
if (item)
{
if (item->IsAlbum())
{
if (field == "albumlabel")
{
result[field] = item->GetProperty("album_label");
return true;
}
if (item->HasProperty("album_" + field + "_array"))
{
result[field] = item->GetProperty("album_" + field + "_array");
return true;
}
if (item->HasProperty("album_" + field))
{
result[field] = item->GetProperty("album_" + field);
return true;
}
}
if (item->HasProperty("artist_" + field + "_array"))
{
result[field] = item->GetProperty("artist_" + field + "_array");
return true;
}
if (item->HasProperty("artist_" + field))
{
result[field] = item->GetProperty("artist_" + field);
return true;
}
if (field == "art")
{
if (thumbLoader != NULL && item->GetArt().size() <= 0 && !fetchedArt &&
((item->HasVideoInfoTag() && item->GetVideoInfoTag()->m_iDbId > -1) || (item->HasMusicInfoTag() && item->GetMusicInfoTag()->GetDatabaseId() > -1)))
{
thumbLoader->FillLibraryArt(*item);
fetchedArt = true;
}
CGUIListItem::ArtMap artMap = item->GetArt();
CVariant artObj(CVariant::VariantTypeObject);
for (CGUIListItem::ArtMap::const_iterator artIt = artMap.begin(); artIt != artMap.end(); artIt++)
artObj[artIt->first] = CTextureCache::GetWrappedImageURL(artIt->second);
result["art"] = artObj;
return true;
}
if (field == "thumbnail")
{
if (thumbLoader != NULL && !item->HasArt("thumb") && !fetchedArt &&
((item->HasVideoInfoTag() && item->GetVideoInfoTag()->m_iDbId > -1) || (item->HasMusicInfoTag() && item->GetMusicInfoTag()->GetDatabaseId() > -1)))
{
thumbLoader->FillLibraryArt(*item);
fetchedArt = true;
}
else if (item->HasPictureInfoTag() && !item->HasArt("thumb"))
item->SetArt("thumb", CTextureCache::GetWrappedThumbURL(item->GetPath()));
if (item->HasArt("thumb"))
result["thumbnail"] = CTextureCache::GetWrappedImageURL(item->GetArt("thumb"));
else
result["thumbnail"] = "";
return true;
}
if (field == "fanart")
{
if (thumbLoader != NULL && !item->HasArt("fanart") && !fetchedArt &&
((item->HasVideoInfoTag() && item->GetVideoInfoTag()->m_iDbId > -1) || (item->HasMusicInfoTag() && item->GetMusicInfoTag()->GetDatabaseId() > -1)))
{
thumbLoader->FillLibraryArt(*item);
fetchedArt = true;
}
if (item->HasArt("fanart"))
result["fanart"] = CTextureCache::GetWrappedImageURL(item->GetArt("fanart"));
else
result["fanart"] = "";
return true;
}
if (item->HasVideoInfoTag() && item->GetVideoContentType() == VIDEODB_CONTENT_TVSHOWS)
{
if (item->GetVideoInfoTag()->m_iSeason < 0 && field == "season")
{
result[field] = (int)item->GetProperty("totalseasons").asInteger();
return true;
}
if (field == "watchedepisodes")
{
result[field] = (int)item->GetProperty("watchedepisodes").asInteger();
return true;
}
}
if (field == "lastmodified" && item->m_dateTime.IsValid())
{
result[field] = item->m_dateTime.GetAsLocalizedDateTime();
return true;
}
}
return false;
}
inline bool CJSONRPC::IsProperJSONRPC(const CVariant& inputroot)
{
return inputroot.isObject() && inputroot.isMember("jsonrpc") && inputroot["jsonrpc"].isString() && inputroot["jsonrpc"] == CVariant("2.0") && inputroot.isMember("method") && inputroot["method"].isString() && (!inputroot.isMember("params") || inputroot["params"].isArray() || inputroot["params"].isObject());
}
JSONRPC_STATUS CPlayerOperations::Open(const std::string &method, ITransportLayer *transport, IClient *client, const CVariant ¶meterObject, CVariant &result)
{
CVariant options = parameterObject["options"];
CVariant optionShuffled = options["shuffled"];
CVariant optionRepeat = options["repeat"];
CVariant optionResume = options["resume"];
CVariant optionPlayer = options["playercoreid"];
if (parameterObject["item"].isObject() && parameterObject["item"].isMember("playlistid"))
{
int playlistid = (int)parameterObject["item"]["playlistid"].asInteger();
if (playlistid < PLAYLIST_PICTURE)
{
// Apply the "shuffled" option if available
if (optionShuffled.isBoolean())
g_playlistPlayer.SetShuffle(playlistid, optionShuffled.asBoolean(), false);
// Apply the "repeat" option if available
if (!optionRepeat.isNull())
g_playlistPlayer.SetRepeat(playlistid, (REPEAT_STATE)ParseRepeatState(optionRepeat), false);
}
int playlistStartPosition = (int)parameterObject["item"]["position"].asInteger();
switch (playlistid)
{
case PLAYLIST_MUSIC:
case PLAYLIST_VIDEO:
CApplicationMessenger::Get().MediaPlay(playlistid, playlistStartPosition);
OnPlaylistChanged();
break;
case PLAYLIST_PICTURE:
{
std::string firstPicturePath;
if (playlistStartPosition > 0)
{
CGUIWindowSlideShow *slideshow = (CGUIWindowSlideShow*)g_windowManager.GetWindow(WINDOW_SLIDESHOW);
if (slideshow != NULL)
{
CFileItemList list;
slideshow->GetSlideShowContents(list);
if (playlistStartPosition < list.Size())
firstPicturePath = list.Get(playlistStartPosition)->GetPath();
}
}
return StartSlideshow("", false, optionShuffled.isBoolean() && optionShuffled.asBoolean(), firstPicturePath);
break;
}
}
return ACK;
}
else if (parameterObject["item"].isObject() && parameterObject["item"].isMember("path"))
{
bool random = (optionShuffled.isBoolean() && optionShuffled.asBoolean()) ||
(!optionShuffled.isBoolean() && parameterObject["item"]["random"].asBoolean());
return StartSlideshow(parameterObject["item"]["path"].asString(), parameterObject["item"]["recursive"].asBoolean(), random);
}
else if (parameterObject["item"].isObject() && parameterObject["item"].isMember("partymode"))
{
if (g_partyModeManager.IsEnabled())
g_partyModeManager.Disable();
CApplicationMessenger::Get().ExecBuiltIn("playercontrol(partymode(" + parameterObject["item"]["partymode"].asString() + "))");
return ACK;
}
else if (parameterObject["item"].isObject() && parameterObject["item"].isMember("channelid"))
{
if (!g_PVRManager.IsStarted())
return FailedToExecute;
CPVRChannelGroupsContainer *channelGroupContainer = g_PVRChannelGroups;
if (channelGroupContainer == NULL)
return FailedToExecute;
CPVRChannelPtr channel = channelGroupContainer->GetChannelById((int)parameterObject["item"]["channelid"].asInteger());
if (channel == NULL)
return InvalidParams;
if ((g_PVRManager.IsPlayingRadio() && channel->IsRadio()) ||
(g_PVRManager.IsPlayingTV() && !channel->IsRadio()))
g_application.m_pPlayer->SwitchChannel(channel);
else
CApplicationMessenger::Get().MediaPlay(CFileItem(channel));
return ACK;
}
else if (parameterObject["item"].isObject() && parameterObject["item"].isMember("recordingid"))
{
if (!g_PVRManager.IsStarted())
return FailedToExecute;
CPVRRecordings *recordingsContainer = g_PVRRecordings;
if (recordingsContainer == NULL)
return FailedToExecute;
CFileItemPtr fileItem = recordingsContainer->GetById((int)parameterObject["item"]["recordingid"].asInteger());
if (fileItem == NULL)
return InvalidParams;
CApplicationMessenger::Get().MediaPlay(*fileItem);
return ACK;
}
else
{
CFileItemList list;
if (FillFileItemList(parameterObject["item"], list) && list.Size() > 0)
{
bool slideshow = true;
for (int index = 0; index < list.Size(); index++)
{
if (!list[index]->IsPicture())
{
slideshow = false;
break;
}
}
if (slideshow)
{
CGUIWindowSlideShow *slideshow = (CGUIWindowSlideShow*)g_windowManager.GetWindow(WINDOW_SLIDESHOW);
if (!slideshow)
return FailedToExecute;
SendSlideshowAction(ACTION_STOP);
slideshow->Reset();
for (int index = 0; index < list.Size(); index++)
slideshow->Add(list[index].get());
return StartSlideshow("", false, optionShuffled.isBoolean() && optionShuffled.asBoolean());
}
else
{
// Handle the "playerid" option
if (!optionPlayer.isNull())
{
PLAYERCOREID playerId = EPC_NONE;
if (optionPlayer.isInteger())
{
playerId = (PLAYERCOREID)optionPlayer.asInteger();
// check if the there's actually a player with the given player ID
if (CPlayerCoreFactory::Get().GetPlayerConfig(playerId) == NULL)
return InvalidParams;
// check if the player can handle at least the first item in the list
VECPLAYERCORES possiblePlayers;
CPlayerCoreFactory::Get().GetPlayers(*list.Get(0).get(), possiblePlayers);
VECPLAYERCORES::const_iterator matchingPlayer = std::find(possiblePlayers.begin(), possiblePlayers.end(), playerId);
if (matchingPlayer == possiblePlayers.end())
return InvalidParams;
}
else if (!optionPlayer.isString() || optionPlayer.asString().compare("default") != 0)
return InvalidParams;
// set the next player to be used
g_application.m_eForcedNextPlayer = playerId;
}
// Handle "shuffled" option
if (optionShuffled.isBoolean())
list.SetProperty("shuffled", optionShuffled);
// Handle "repeat" option
if (!optionRepeat.isNull())
list.SetProperty("repeat", ParseRepeatState(optionRepeat));
// Handle "resume" option
if (list.Size() == 1)
{
if (optionResume.isBoolean() && optionResume.asBoolean())
list[0]->m_lStartOffset = STARTOFFSET_RESUME;
else if (optionResume.isDouble())
list[0]->SetProperty("StartPercent", optionResume);
else if (optionResume.isObject())
list[0]->m_lStartOffset = (int)(ParseTimeInSeconds(optionResume) * 75.0);
}
CApplicationMessenger::Get().MediaPlay(list);
}
return ACK;
}
else
return InvalidParams;
}
return InvalidParams;
}
void CAnnouncementManager::DoAnnounce(AnnouncementFlag flag, const char *sender, const char *message, CFileItemPtr item, const CVariant &data)
{
if (item == nullptr)
{
DoAnnounce(flag, sender, message, data);
return;
}
// Extract db id of item
CVariant object = data.isNull() || data.isObject() ? data : CVariant::VariantTypeObject;
std::string type;
int id = 0;
if(item->HasPVRChannelInfoTag())
{
const PVR::CPVRChannelPtr channel(item->GetPVRChannelInfoTag());
id = channel->ChannelID();
type = "channel";
object["item"]["title"] = channel->ChannelName();
object["item"]["channeltype"] = channel->IsRadio() ? "radio" : "tv";
if (data.isMember("player") && data["player"].isMember("playerid"))
object["player"]["playerid"] = channel->IsRadio() ? PLAYLIST_MUSIC : PLAYLIST_VIDEO;
}
else if (item->HasVideoInfoTag())
{
id = item->GetVideoInfoTag()->m_iDbId;
// TODO: Can be removed once this is properly handled when starting playback of a file
if (id <= 0 && !item->GetPath().empty() &&
(!item->HasProperty(LOOKUP_PROPERTY) || item->GetProperty(LOOKUP_PROPERTY).asBoolean()))
{
CVideoDatabase videodatabase;
if (videodatabase.Open())
{
std::string path = item->GetPath();
std::string videoInfoTagPath(item->GetVideoInfoTag()->m_strFileNameAndPath);
if (StringUtils::StartsWith(videoInfoTagPath, "removable://"))
path = videoInfoTagPath;
if (videodatabase.LoadVideoInfo(path, *item->GetVideoInfoTag(), VideoDbDetailsNone))
id = item->GetVideoInfoTag()->m_iDbId;
videodatabase.Close();
}
}
if (!item->GetVideoInfoTag()->m_type.empty())
type = item->GetVideoInfoTag()->m_type;
else
CVideoDatabase::VideoContentTypeToString((VIDEODB_CONTENT_TYPE)item->GetVideoContentType(), type);
if (id <= 0)
{
// TODO: Can be removed once this is properly handled when starting playback of a file
item->SetProperty(LOOKUP_PROPERTY, false);
std::string title = item->GetVideoInfoTag()->m_strTitle;
if (title.empty())
title = item->GetLabel();
object["item"]["title"] = title;
switch (item->GetVideoContentType())
{
case VIDEODB_CONTENT_MOVIES:
if (item->GetVideoInfoTag()->m_iYear > 0)
object["item"]["year"] = item->GetVideoInfoTag()->m_iYear;
break;
case VIDEODB_CONTENT_EPISODES:
if (item->GetVideoInfoTag()->m_iEpisode >= 0)
object["item"]["episode"] = item->GetVideoInfoTag()->m_iEpisode;
if (item->GetVideoInfoTag()->m_iSeason >= 0)
object["item"]["season"] = item->GetVideoInfoTag()->m_iSeason;
if (!item->GetVideoInfoTag()->m_strShowTitle.empty())
object["item"]["showtitle"] = item->GetVideoInfoTag()->m_strShowTitle;
break;
case VIDEODB_CONTENT_MUSICVIDEOS:
if (!item->GetVideoInfoTag()->m_strAlbum.empty())
object["item"]["album"] = item->GetVideoInfoTag()->m_strAlbum;
if (!item->GetVideoInfoTag()->m_artist.empty())
object["item"]["artist"] = StringUtils::Join(item->GetVideoInfoTag()->m_artist, " / ");
break;
}
}
}
else if (item->HasMusicInfoTag())
{
id = item->GetMusicInfoTag()->GetDatabaseId();
type = MediaTypeSong;
// TODO: Can be removed once this is properly handled when starting playback of a file
if (id <= 0 && !item->GetPath().empty() &&
(!item->HasProperty(LOOKUP_PROPERTY) || item->GetProperty(LOOKUP_PROPERTY).asBoolean()))
{
CMusicDatabase musicdatabase;
if (musicdatabase.Open())
{
CSong song;
if (musicdatabase.GetSongByFileName(item->GetPath(), song, item->m_lStartOffset))
{
item->GetMusicInfoTag()->SetSong(song);
id = item->GetMusicInfoTag()->GetDatabaseId();
}
musicdatabase.Close();
}
}
if (id <= 0)
{
// TODO: Can be removed once this is properly handled when starting playback of a file
item->SetProperty(LOOKUP_PROPERTY, false);
std::string title = item->GetMusicInfoTag()->GetTitle();
if (title.empty())
title = item->GetLabel();
object["item"]["title"] = title;
if (item->GetMusicInfoTag()->GetTrackNumber() > 0)
object["item"]["track"] = item->GetMusicInfoTag()->GetTrackNumber();
if (!item->GetMusicInfoTag()->GetAlbum().empty())
object["item"]["album"] = item->GetMusicInfoTag()->GetAlbum();
if (!item->GetMusicInfoTag()->GetArtist().empty())
object["item"]["artist"] = item->GetMusicInfoTag()->GetArtist();
}
}
else if (item->IsVideo())
{
// video item but has no video info tag.
type = "movies";
object["item"]["title"] = item->GetLabel();
}
else if (item->HasPictureInfoTag())
{
type = "picture";
object["item"]["file"] = item->GetPath();
}
else
type = "unknown";
object["item"]["type"] = type;
if (id > 0)
object["item"]["id"] = id;
DoAnnounce(flag, sender, message, object);
}
TEST(TestUrlOptions, AddOptions)
{
std::string ref = "foo=bar&key=value";
CUrlOptions urlOptions(ref);
{
CVariant value;
EXPECT_TRUE(urlOptions.GetOption("foo", value));
EXPECT_TRUE(value.isString());
EXPECT_STREQ("bar", value.asString().c_str());
}
{
CVariant value;
EXPECT_TRUE(urlOptions.GetOption("key", value));
EXPECT_TRUE(value.isString());
EXPECT_STREQ("value", value.asString().c_str());
}
ref = "foo=bar&key";
urlOptions.Clear();
urlOptions.AddOptions(ref);
{
CVariant value;
EXPECT_TRUE(urlOptions.GetOption("foo", value));
EXPECT_TRUE(value.isString());
EXPECT_STREQ("bar", value.asString().c_str());
}
{
CVariant value;
EXPECT_TRUE(urlOptions.GetOption("key", value));
EXPECT_TRUE(value.isString());
EXPECT_TRUE(value.empty());
}
}
TEST(TestUrlOptions, AddOption)
{
const char *keyChar = "char";
const char *keyString = "string";
const char *keyEmpty = "empty";
const char *keyInt = "int";
const char *keyFloat = "float";
const char *keyDouble = "double";
const char *keyBool = "bool";
const char *valueChar = "valueChar";
const std::string valueString = "valueString";
const char *valueEmpty = "";
int valueInt = 1;
float valueFloat = 1.0f;
double valueDouble = 1.0;
bool valueBool = true;
CVariant variantValue;
CUrlOptions urlOptions;
urlOptions.AddOption(keyChar, valueChar);
{
CVariant variantValue;
EXPECT_TRUE(urlOptions.GetOption(keyChar, variantValue));
EXPECT_TRUE(variantValue.isString());
EXPECT_STREQ(valueChar, variantValue.asString().c_str());
}
urlOptions.AddOption(keyString, valueString);
{
CVariant variantValue;
EXPECT_TRUE(urlOptions.GetOption(keyString, variantValue));
EXPECT_TRUE(variantValue.isString());
EXPECT_STREQ(valueString.c_str(), variantValue.asString().c_str());
}
urlOptions.AddOption(keyEmpty, valueEmpty);
{
CVariant variantValue;
EXPECT_TRUE(urlOptions.GetOption(keyEmpty, variantValue));
EXPECT_TRUE(variantValue.isString());
EXPECT_STREQ(valueEmpty, variantValue.asString().c_str());
}
urlOptions.AddOption(keyInt, valueInt);
{
CVariant variantValue;
EXPECT_TRUE(urlOptions.GetOption(keyInt, variantValue));
EXPECT_TRUE(variantValue.isInteger());
EXPECT_EQ(valueInt, (int)variantValue.asInteger());
}
urlOptions.AddOption(keyFloat, valueFloat);
{
CVariant variantValue;
EXPECT_TRUE(urlOptions.GetOption(keyFloat, variantValue));
EXPECT_TRUE(variantValue.isDouble());
EXPECT_EQ(valueFloat, variantValue.asFloat());
}
urlOptions.AddOption(keyDouble, valueDouble);
{
CVariant variantValue;
EXPECT_TRUE(urlOptions.GetOption(keyDouble, variantValue));
EXPECT_TRUE(variantValue.isDouble());
EXPECT_EQ(valueDouble, variantValue.asDouble());
}
urlOptions.AddOption(keyBool, valueBool);
{
CVariant variantValue;
EXPECT_TRUE(urlOptions.GetOption(keyBool, variantValue));
EXPECT_TRUE(variantValue.isBoolean());
EXPECT_EQ(valueBool, variantValue.asBoolean());
}
}
JSON_STATUS CFileOperations::GetDirectory(const CStdString &method, ITransportLayer *transport, IClient *client, const CVariant ¶meterObject, CVariant &result)
{
CStdString media = parameterObject["media"].asString();
media = media.ToLower();
CDirectory directory;
CFileItemList items;
CStdString strPath = parameterObject["directory"].asString();
// Check if this directory is part of a source and whether it's locked
VECSOURCES *sources;
bool isSource;
for (unsigned int index = 0; index < SourcesSize; index++)
{
sources = g_settings.GetSourcesFromType(SourceNames[index]);
int sourceIndex = CUtil::GetMatchingSource(strPath, *sources, isSource);
if (sourceIndex >= 0 && sourceIndex < (int)sources->size() && sources->at(sourceIndex).m_iHasLock == 2)
return InvalidParams;
}
CStdStringArray regexps;
CStdString extensions = "";
if (media.Equals("video"))
{
regexps = g_advancedSettings.m_videoExcludeFromListingRegExps;
extensions = g_settings.m_videoExtensions;
}
else if (media.Equals("music"))
{
regexps = g_advancedSettings.m_audioExcludeFromListingRegExps;
extensions = g_settings.m_musicExtensions;
}
else if (media.Equals("pictures"))
{
regexps = g_advancedSettings.m_pictureExcludeFromListingRegExps;
extensions = g_settings.m_pictureExtensions;
}
if (directory.GetDirectory(strPath, items, extensions))
{
CFileItemList filteredDirectories, filteredFiles;
for (unsigned int i = 0; i < (unsigned int)items.Size(); i++)
{
if (CUtil::ExcludeFileOrFolder(items[i]->GetPath(), regexps))
continue;
if (items[i]->IsSmb())
{
CURL url(items[i]->GetPath());
items[i]->SetPath(url.GetWithoutUserDetails());
}
if ((media == "video" && items[i]->HasVideoInfoTag()) ||
(media == "music" && items[i]->HasMusicInfoTag()))
{
if (items[i]->m_bIsFolder)
filteredDirectories.Add(items[i]);
else
filteredFiles.Add(items[i]);
}
else
{
CFileItem fileItem;
if (FillFileItem(items[i], fileItem, media))
{
if (items[i]->m_bIsFolder)
filteredDirectories.Add(CFileItemPtr(new CFileItem(fileItem)));
else
filteredFiles.Add(CFileItemPtr(new CFileItem(fileItem)));
}
else
{
if (items[i]->m_bIsFolder)
filteredDirectories.Add(items[i]);
else
filteredFiles.Add(items[i]);
}
}
}
// Check if the "properties" list exists
// and make sure it contains the "file"
// field
CVariant param = parameterObject;
if (!param.isMember("properties"))
param["properties"] = CVariant(CVariant::VariantTypeArray);
bool hasFileField = false;
for (CVariant::const_iterator_array itr = param["properties"].begin_array(); itr != param["properties"].end_array(); itr++)
{
if (*itr == CVariant("file"))
{
hasFileField = true;
break;
}
}
if (!hasFileField)
param["properties"].append("file");
HandleFileItemList("id", true, "files", filteredDirectories, param, result);
for (unsigned int index = 0; index < result["files"].size(); index++)
{
result["files"][index]["filetype"] = "directory";
}
int count = (int)result["limits"]["total"].asInteger();
HandleFileItemList("id", true, "files", filteredFiles, param, result);
for (unsigned int index = count; index < result["files"].size(); index++)
{
result["files"][index]["filetype"] = "file";
}
count += (int)result["limits"]["total"].asInteger();
result["limits"]["end"] = count;
result["limits"]["total"] = count;
return OK;
}
return InvalidParams;
}
bool CFileOperations::FillFileItemList(const CVariant ¶meterObject, CFileItemList &list)
{
if (parameterObject.isMember("directory"))
{
CStdString media = parameterObject["media"].asString();
media = media.ToLower();
CStdString strPath = parameterObject["directory"].asString();
if (!strPath.empty())
{
CFileItemList items;
CStdString extensions = "";
CStdStringArray regexps;
if (media.Equals("video"))
{
regexps = g_advancedSettings.m_videoExcludeFromListingRegExps;
extensions = g_settings.m_videoExtensions;
}
else if (media.Equals("music"))
{
regexps = g_advancedSettings.m_audioExcludeFromListingRegExps;
extensions = g_settings.m_musicExtensions;
}
else if (media.Equals("pictures"))
{
regexps = g_advancedSettings.m_pictureExcludeFromListingRegExps;
extensions = g_settings.m_pictureExtensions;
}
CDirectory directory;
if (directory.GetDirectory(strPath, items, extensions))
{
items.Sort(SORT_METHOD_FILE, SORT_ORDER_ASC);
CFileItemList filteredDirectories;
for (unsigned int i = 0; i < (unsigned int)items.Size(); i++)
{
if (CUtil::ExcludeFileOrFolder(items[i]->GetPath(), regexps))
continue;
if (items[i]->m_bIsFolder)
filteredDirectories.Add(items[i]);
else if ((media == "video" && items[i]->HasVideoInfoTag()) ||
(media == "music" && items[i]->HasMusicInfoTag()))
list.Add(items[i]);
else
{
CFileItem fileItem;
if (FillFileItem(items[i], fileItem, media))
list.Add(CFileItemPtr(new CFileItem(fileItem)));
else if (media == "files")
list.Add(items[i]);
}
}
if (parameterObject.isMember("recursive") && parameterObject["recursive"].isBoolean())
{
for (int i = 0; i < filteredDirectories.Size(); i++)
{
CVariant val = parameterObject;
val["directory"] = filteredDirectories[i]->GetPath();
FillFileItemList(val, list);
}
}
return true;
}
}
}
return false;
}
JSONRPC_STATUS CAddonsOperations::GetAddons(const std::string &method, ITransportLayer *transport, IClient *client, const CVariant ¶meterObject, CVariant &result)
{
vector<TYPE> addonTypes;
TYPE addonType = TranslateType(parameterObject["type"].asString());
CPluginSource::Content content = CPluginSource::Translate(parameterObject["content"].asString());
CVariant enabled = parameterObject["enabled"];
// ignore the "content" parameter if the type is specified but not a plugin or script
if (addonType != ADDON_UNKNOWN && addonType != ADDON_PLUGIN && addonType != ADDON_SCRIPT)
content = CPluginSource::UNKNOWN;
if (addonType >= ADDON_VIDEO && addonType <= ADDON_EXECUTABLE)
{
addonTypes.push_back(ADDON_PLUGIN);
addonTypes.push_back(ADDON_SCRIPT);
switch (addonType)
{
case ADDON_VIDEO:
content = CPluginSource::VIDEO;
break;
case ADDON_AUDIO:
content = CPluginSource::AUDIO;
break;
case ADDON_IMAGE:
content = CPluginSource::IMAGE;
break;
case ADDON_EXECUTABLE:
content = CPluginSource::EXECUTABLE;
break;
default:
break;
}
}
else
addonTypes.push_back(addonType);
VECADDONS addons;
for (vector<TYPE>::const_iterator typeIt = addonTypes.begin(); typeIt != addonTypes.end(); ++typeIt)
{
VECADDONS typeAddons;
if (*typeIt == ADDON_UNKNOWN)
{
if (!enabled.isBoolean())
{
CAddonMgr::Get().GetAllAddons(typeAddons, false);
CAddonMgr::Get().GetAllAddons(typeAddons, true);
}
else
CAddonMgr::Get().GetAllAddons(typeAddons, enabled.asBoolean());
}
else
{
if (!enabled.isBoolean())
{
CAddonMgr::Get().GetAddons(*typeIt, typeAddons, false);
VECADDONS enabledAddons;
CAddonMgr::Get().GetAddons(*typeIt, enabledAddons, true);
typeAddons.insert(typeAddons.end(), enabledAddons.begin(), enabledAddons.end());
}
else
CAddonMgr::Get().GetAddons(*typeIt, typeAddons, enabled.asBoolean());
}
addons.insert(addons.end(), typeAddons.begin(), typeAddons.end());
}
// remove library addons
for (int index = 0; index < (int)addons.size(); index++)
{
PluginPtr plugin;
if (content != CPluginSource::UNKNOWN)
plugin = boost::dynamic_pointer_cast<CPluginSource>(addons.at(index));
if ((addons.at(index)->Type() <= ADDON_UNKNOWN || addons.at(index)->Type() >= ADDON_MAX) ||
((content != CPluginSource::UNKNOWN && plugin == NULL) || (plugin != NULL && !plugin->Provides(content))))
{
addons.erase(addons.begin() + index);
index--;
}
}
int start, end;
HandleLimits(parameterObject, result, addons.size(), start, end);
CAddonDatabase addondb;
for (int index = start; index < end; index++)
FillDetails(addons.at(index), parameterObject["properties"], result["addons"], addondb, true);
return OK;
}
void CVideoLibrary::UpdateVideoTag(const CVariant ¶meterObject, CVideoInfoTag& details, std::map<std::string, std::string> &artwork, std::set<std::string> &removedArtwork, std::set<std::string> &updatedDetails)
{
if (ParameterNotNull(parameterObject, "title"))
details.SetTitle(parameterObject["title"].asString());
if (ParameterNotNull(parameterObject, "playcount"))
details.SetPlayCount(static_cast<int>(parameterObject["playcount"].asInteger()));
if (ParameterNotNull(parameterObject, "runtime"))
details.SetDuration(static_cast<int>(parameterObject["runtime"].asInteger()));
std::vector<std::string> director(details.m_director);
UpdateVideoTagField(parameterObject, "director", director, updatedDetails);
details.SetDirector(director);
std::vector<std::string> studio(details.m_studio);
UpdateVideoTagField(parameterObject, "studio", studio, updatedDetails);
details.SetStudio(studio);
if (ParameterNotNull(parameterObject, "plot"))
details.SetPlot(parameterObject["plot"].asString());
if (ParameterNotNull(parameterObject, "album"))
details.SetAlbum(parameterObject["album"].asString());
std::vector<std::string> artist(details.m_artist);
UpdateVideoTagField(parameterObject, "artist", artist, updatedDetails);
details.SetArtist(artist);
std::vector<std::string> genre(details.m_genre);
UpdateVideoTagField(parameterObject, "genre", genre, updatedDetails);
details.SetGenre(genre);
if (ParameterNotNull(parameterObject, "track"))
details.m_iTrack = (int)parameterObject["track"].asInteger();
if (ParameterNotNull(parameterObject, "rating"))
{
details.SetRating(parameterObject["rating"].asFloat());
updatedDetails.insert("ratings");
}
if (ParameterNotNull(parameterObject, "votes"))
{
details.SetVotes(StringUtils::ReturnDigits(parameterObject["votes"].asString()));
updatedDetails.insert("ratings"); //Votes and ratings both need updates now, this will trigger those
}
if (ParameterNotNull(parameterObject, "ratings"))
{
CVariant ratings = parameterObject["ratings"];
for (CVariant::const_iterator_map rIt = ratings.begin_map(); rIt != ratings.end_map(); rIt++)
{
if (rIt->second.isObject() && ParameterNotNull(rIt->second, "rating"))
{
const auto& rating = rIt->second;
if (ParameterNotNull(rating, "votes"))
{
details.SetRating(rating["rating"].asFloat(),
static_cast<int>(rating["votes"].asInteger()),
rIt->first,
(ParameterNotNull(rating, "default") && rating["default"].asBoolean()));
}
else
details.SetRating(rating["rating"].asFloat(), rIt->first, (ParameterNotNull(rating, "default") && rating["default"].asBoolean()));
updatedDetails.insert("ratings");
}
else if (rIt->second.isNull())
{
details.RemoveRating(rIt->first);
updatedDetails.insert("ratings");
}
}
}
if (ParameterNotNull(parameterObject, "userrating"))
details.m_iUserRating = static_cast<int>(parameterObject["userrating"].asInteger());
if (ParameterNotNull(parameterObject, "mpaa"))
details.SetMPAARating(parameterObject["mpaa"].asString());
if (ParameterNotNull(parameterObject, "imdbnumber"))
{
details.SetUniqueID(parameterObject["imdbnumber"].asString());
updatedDetails.insert("uniqueid");
}
if (ParameterNotNull(parameterObject, "uniqueid"))
{
CVariant uniqueids = parameterObject["uniqueid"];
for (CVariant::const_iterator_map idIt = uniqueids.begin_map(); idIt != uniqueids.end_map(); idIt++)
{
if (idIt->second.isString() && !idIt->second.asString().empty())
{
details.SetUniqueID(idIt->second.asString(), idIt->first);
updatedDetails.insert("uniqueid");
}
else if (idIt->second.isNull() && idIt->first != details.GetDefaultUniqueID())
{
details.RemoveUniqueID(idIt->first);
updatedDetails.insert("uniqueid");
}
}
}
if (ParameterNotNull(parameterObject, "premiered"))
{
CDateTime premiered;
SetFromDBDate(parameterObject["premiered"], premiered);
details.SetPremiered(premiered);
}
else if (ParameterNotNull(parameterObject, "year"))
details.SetYear((int)parameterObject["year"].asInteger());
if (ParameterNotNull(parameterObject, "lastplayed"))
SetFromDBDateTime(parameterObject["lastplayed"], details.m_lastPlayed);
if (ParameterNotNull(parameterObject, "firstaired"))
SetFromDBDate(parameterObject["firstaired"], details.m_firstAired);
if (ParameterNotNull(parameterObject, "productioncode"))
details.SetProductionCode(parameterObject["productioncode"].asString());
if (ParameterNotNull(parameterObject, "season"))
details.m_iSeason = (int)parameterObject["season"].asInteger();
if (ParameterNotNull(parameterObject, "episode"))
details.m_iEpisode = (int)parameterObject["episode"].asInteger();
if (ParameterNotNull(parameterObject, "originaltitle"))
details.SetOriginalTitle(parameterObject["originaltitle"].asString());
if (ParameterNotNull(parameterObject, "trailer"))
details.SetTrailer(parameterObject["trailer"].asString());
if (ParameterNotNull(parameterObject, "tagline"))
details.SetTagLine(parameterObject["tagline"].asString());
if (ParameterNotNull(parameterObject, "status"))
details.SetStatus(parameterObject["status"].asString());
if (ParameterNotNull(parameterObject, "plotoutline"))
details.SetPlotOutline(parameterObject["plotoutline"].asString());
std::vector<std::string> credits(details.m_writingCredits);
UpdateVideoTagField(parameterObject, "writer", credits, updatedDetails);
details.SetWritingCredits(credits);
std::vector<std::string> country(details.m_country);
UpdateVideoTagField(parameterObject, "country", country, updatedDetails);
details.SetCountry(country);
if (ParameterNotNull(parameterObject, "top250"))
details.m_iTop250 = (int)parameterObject["top250"].asInteger();
if (ParameterNotNull(parameterObject, "sorttitle"))
details.SetSortTitle(parameterObject["sorttitle"].asString());
if (ParameterNotNull(parameterObject, "episodeguide"))
details.SetEpisodeGuide(parameterObject["episodeguide"].asString());
if (ParameterNotNull(parameterObject, "set"))
{
details.SetSet(parameterObject["set"].asString());
updatedDetails.insert("set");
}
std::vector<std::string> showLink(details.m_showLink);
UpdateVideoTagField(parameterObject, "showlink", showLink, updatedDetails);
details.SetShowLink(showLink);
std::vector<std::string> tags(details.m_tags);
UpdateVideoTagField(parameterObject, "tag", tags, updatedDetails);
details.SetTags(tags);
if (ParameterNotNull(parameterObject, "thumbnail"))
{
std::string value = parameterObject["thumbnail"].asString();
artwork["thumb"] = StringUtils::Trim(value);
updatedDetails.insert("art.altered");
}
if (ParameterNotNull(parameterObject, "fanart"))
{
std::string value = parameterObject["fanart"].asString();
artwork["fanart"] = StringUtils::Trim(value);
updatedDetails.insert("art.altered");
}
if (ParameterNotNull(parameterObject, "art"))
{
CVariant art = parameterObject["art"];
for (CVariant::const_iterator_map artIt = art.begin_map(); artIt != art.end_map(); artIt++)
{
if (artIt->second.isString() && !artIt->second.asString().empty())
{
artwork[artIt->first] = CTextureUtils::UnwrapImageURL(artIt->second.asString());
updatedDetails.insert("art.altered");
}
else if (artIt->second.isNull())
{
artwork.erase(artIt->first);
removedArtwork.insert(artIt->first);
}
}
}
if (ParameterNotNull(parameterObject, "dateadded"))
{
SetFromDBDateTime(parameterObject["dateadded"], details.m_dateAdded);
updatedDetails.insert("dateadded");
}
}
JSONRPC_STATUS CPlayerOperations::Open(const CStdString &method, ITransportLayer *transport, IClient *client, const CVariant ¶meterObject, CVariant &result)
{
CVariant optionShuffled = parameterObject["options"]["shuffled"];
CVariant optionRepeat = parameterObject["options"]["repeat"];
CVariant optionResume = parameterObject["options"]["resume"];
if (parameterObject["item"].isObject() && parameterObject["item"].isMember("playlistid"))
{
int playlistid = (int)parameterObject["item"]["playlistid"].asInteger();
if (playlistid < PLAYLIST_PICTURE)
{
// Apply the "shuffled" option if available
if (optionShuffled.isBoolean())
g_playlistPlayer.SetShuffle(playlistid, optionShuffled.asBoolean(), false);
// Apply the "repeat" option if available
if (!optionRepeat.isNull())
g_playlistPlayer.SetRepeat(playlistid, (REPEAT_STATE)ParseRepeatState(optionRepeat), false);
}
switch (playlistid)
{
case PLAYLIST_MUSIC:
case PLAYLIST_VIDEO:
g_application.getApplicationMessenger().MediaPlay(playlistid, (int)parameterObject["item"]["position"].asInteger());
OnPlaylistChanged();
break;
case PLAYLIST_PICTURE:
return StartSlideshow();
break;
}
return ACK;
}
else if (parameterObject["item"].isObject() && parameterObject["item"].isMember("path"))
{
CStdString exec = "slideShow(";
exec += parameterObject["item"]["path"].asString();
if ((optionShuffled.isBoolean() && optionShuffled.asBoolean()) ||
(!optionShuffled.isBoolean() && parameterObject["item"]["random"].asBoolean()))
exec += ", random";
else
exec += ", notrandom";
if (parameterObject["item"]["recursive"].asBoolean())
exec += ", recursive";
exec += ")";
ThreadMessage msg = { TMSG_EXECUTE_BUILT_IN, (DWORD)0, (DWORD)0, exec };
g_application.getApplicationMessenger().SendMessage(msg);
return ACK;
}
else
{
CFileItemList list;
if (FillFileItemList(parameterObject["item"], list) && list.Size() > 0)
{
bool slideshow = true;
for (int index = 0; index < list.Size(); index++)
{
if (!list[index]->IsPicture())
{
slideshow = false;
break;
}
}
if (slideshow)
{
CGUIWindowSlideShow *slideshow = (CGUIWindowSlideShow*)g_windowManager.GetWindow(WINDOW_SLIDESHOW);
if (!slideshow)
return FailedToExecute;
SendSlideshowAction(ACTION_STOP);
slideshow->Reset();
for (int index = 0; index < list.Size(); index++)
slideshow->Add(list[index].get());
if (optionShuffled.isBoolean() && optionShuffled.asBoolean())
slideshow->Shuffle();
return StartSlideshow();
}
else
{
// Handle "shuffled" option
if (optionShuffled.isBoolean())
list.SetProperty("shuffled", optionShuffled);
// Handle "repeat" option
if (!optionRepeat.isNull())
list.SetProperty("repeat", ParseRepeatState(optionRepeat));
// Handle "resume" option
if (list.Size() == 1)
{
if (optionResume.isBoolean() && optionResume.asBoolean())
list[0]->m_lStartOffset = STARTOFFSET_RESUME;
else if (optionResume.isDouble())
list[0]->SetProperty("StartPercent", optionResume);
else if (optionResume.isObject())
list[0]->m_lStartOffset = (int)(ParseTimeInSeconds(optionResume) * 75.0);
}
g_application.getApplicationMessenger().MediaPlay(list);
}
return ACK;
}
else
return InvalidParams;
}
return InvalidParams;
}
int CParamArray::from_stream(int len, uint8_t *buf)
{
int n, i;
int l1, l2, p;
char *str_name;
int pi;
int *arr_len;
CVariant *v;
// name string
str_name = new char[PARAM_ARRAY_ITEM_MAXLEN];
// clear old data
clear();
// stream position index
p = 0;
// stream total length
p += sizeof(int);
// get item number
memcpy(&n, buf+p, sizeof(int));
p += sizeof(int);
// alloc length array
arr_len = new int[n];
// get each item's length
for(i=0; i<n; i++) {
memcpy(&pi, buf+p, sizeof(int));
arr_len[i] = pi;
p += sizeof(int);
}
// for each item
for(i=0; i<n; i++) {
// name length
memcpy(&pi, buf+p, sizeof(int));
l1 = pi;
p += sizeof(int);
// name
memcpy(str_name, buf+p, l1);
p += l1;
// value
l2 = arr_len[i] - sizeof(int) - l1;
v = new CVariant();
v->from_stream(l2, buf+p);
p += l2;
// add name/value to array
na.push_back(str_name);
va.push_back(v);
}
// parse items
parse();
// free temp variables
delete str_name;
delete arr_len;
return 0;
}
bool CGUIDialogSettingsBase::OnMessage(CGUIMessage &message)
{
switch (message.GetMessage())
{
case GUI_MSG_WINDOW_INIT:
{
m_delayedSetting.reset();
if (message.GetParam1() != WINDOW_INVALID)
{ // coming to this window first time (ie not returning back from some other window)
// so we reset our section and control states
m_iCategory = 0;
ResetControlStates();
}
if (AllowResettingSettings())
{
m_resetSetting = new CSettingAction(SETTINGS_RESET_SETTING_ID);
m_resetSetting->SetLabel(10041);
m_resetSetting->SetHelp(10045);
m_resetSetting->SetControl(CreateControl("button"));
}
m_dummyCategory = new CSettingCategory(SETTINGS_EMPTY_CATEGORY_ID);
m_dummyCategory->SetLabel(10046);
m_dummyCategory->SetHelp(10047);
break;
}
case GUI_MSG_WINDOW_DEINIT:
{
// cancel any delayed changes
if (m_delayedSetting != NULL)
{
m_delayedTimer.Stop();
CGUIMessage message(GUI_MSG_UPDATE_ITEM, GetID(), m_delayedSetting->GetID());
OnMessage(message);
}
CGUIDialog::OnMessage(message);
FreeControls();
return true;
}
case GUI_MSG_FOCUSED:
{
CGUIDialog::OnMessage(message);
int focusedControl = GetFocusedControlID();
// cancel any delayed changes
if (m_delayedSetting != NULL && m_delayedSetting->GetID() != focusedControl)
{
m_delayedTimer.Stop();
CGUIMessage message(GUI_MSG_UPDATE_ITEM, GetID(), m_delayedSetting->GetID(), 1); // param1 = 1 for "reset the control if it's invalid"
g_windowManager.SendThreadMessage(message, GetID());
}
// update the value of the previous setting (in case it was invalid)
else if (m_iSetting >= CONTROL_SETTINGS_START_CONTROL && m_iSetting < (int)(CONTROL_SETTINGS_START_CONTROL + m_settingControls.size()))
{
BaseSettingControlPtr control = GetSettingControl(m_iSetting);
if (control != NULL && control->GetSetting() != NULL && !control->IsValid())
{
CGUIMessage message(GUI_MSG_UPDATE_ITEM, GetID(), m_iSetting, 1); // param1 = 1 for "reset the control if it's invalid"
g_windowManager.SendThreadMessage(message, GetID());
}
}
CVariant description;
// check if we have changed the category and need to create new setting controls
if (focusedControl >= CONTROL_SETTINGS_START_BUTTONS && focusedControl < (int)(CONTROL_SETTINGS_START_BUTTONS + m_categories.size()))
{
int categoryIndex = focusedControl - CONTROL_SETTINGS_START_BUTTONS;
const CSettingCategory* category = m_categories.at(categoryIndex);
if (categoryIndex != m_iCategory)
{
if (!category->CanAccess())
{
// unable to go to this category - focus the previous one
SET_CONTROL_FOCUS(CONTROL_SETTINGS_START_BUTTONS + m_iCategory, 0);
return false;
}
m_iCategory = categoryIndex;
CreateSettings();
}
description = category->GetHelp();
}
else if (focusedControl >= CONTROL_SETTINGS_START_CONTROL && focusedControl < (int)(CONTROL_SETTINGS_START_CONTROL + m_settingControls.size()))
{
m_iSetting = focusedControl;
CSetting *setting = GetSettingControl(focusedControl)->GetSetting();
if (setting != NULL)
description = setting->GetHelp();
}
// set the description of the currently focused category/setting
if (description.isInteger() ||
(description.isString() && !description.empty()))
SetDescription(description);
return true;
}
case GUI_MSG_CLICKED:
{
int iControl = message.GetSenderId();
if (iControl == CONTROL_SETTINGS_OKAY_BUTTON)
{
OnOkay();
Close();
return true;
}
if (iControl == CONTROL_SETTINGS_CANCEL_BUTTON)
{
OnCancel();
Close();
return true;
}
BaseSettingControlPtr control = GetSettingControl(iControl);
if (control != NULL)
OnClick(control);
break;
}
case GUI_MSG_UPDATE_ITEM:
{
if (m_delayedSetting != NULL && m_delayedSetting->GetID() == message.GetControlId())
{
// first get the delayed setting and reset its member variable
// to avoid handling the delayed setting twice in case the OnClick()
// performed later causes the window to be deinitialized (e.g. when
// changing the language)
BaseSettingControlPtr delayedSetting = m_delayedSetting;
m_delayedSetting.reset();
// if updating the setting fails and param1 has been specifically set
// we need to call OnSettingChanged() to restore a valid value in the
// setting control
if (!delayedSetting->OnClick() && message.GetParam1() != 0)
OnSettingChanged(delayedSetting->GetSetting());
return true;
}
if (message.GetControlId() >= CONTROL_SETTINGS_START_CONTROL && message.GetControlId() < (int)(CONTROL_SETTINGS_START_CONTROL + m_settingControls.size()))
{
BaseSettingControlPtr settingControl = GetSettingControl(message.GetControlId());
if (settingControl.get() != NULL && settingControl->GetSetting() != NULL)
{
settingControl->Update();
return true;
}
}
break;
}
case GUI_MSG_UPDATE:
{
if (IsActive() && HasID(message.GetSenderId()))
{
int focusedControl = GetFocusedControlID();
CreateSettings();
SET_CONTROL_FOCUS(focusedControl, 0);
}
break;
}
default:
break;
}
return CGUIDialog::OnMessage(message);
}
void CVideoLibrary::UpdateVideoTag(const CVariant ¶meterObject, CVideoInfoTag& details, std::map<std::string, std::string> &artwork)
{
if (ParameterNotNull(parameterObject, "title"))
details.m_strTitle = parameterObject["title"].asString();
if (ParameterNotNull(parameterObject, "playcount"))
details.m_playCount = (int)parameterObject["playcount"].asInteger();
if (ParameterNotNull(parameterObject, "runtime"))
details.m_duration = (int)parameterObject["runtime"].asInteger();
if (ParameterNotNull(parameterObject, "director"))
CopyStringArray(parameterObject["director"], details.m_director);
if (ParameterNotNull(parameterObject, "studio"))
CopyStringArray(parameterObject["studio"], details.m_studio);
if (ParameterNotNull(parameterObject, "year"))
details.m_iYear = (int)parameterObject["year"].asInteger();
if (ParameterNotNull(parameterObject, "plot"))
details.m_strPlot = parameterObject["plot"].asString();
if (ParameterNotNull(parameterObject, "album"))
details.m_strAlbum = parameterObject["album"].asString();
if (ParameterNotNull(parameterObject, "artist"))
CopyStringArray(parameterObject["artist"], details.m_artist);
if (ParameterNotNull(parameterObject, "genre"))
CopyStringArray(parameterObject["genre"], details.m_genre);
if (ParameterNotNull(parameterObject, "track"))
details.m_iTrack = (int)parameterObject["track"].asInteger();
if (ParameterNotNull(parameterObject, "rating"))
details.m_fRating = parameterObject["rating"].asFloat();
if (ParameterNotNull(parameterObject, "mpaa"))
details.m_strMPAARating = parameterObject["mpaa"].asString();
if (ParameterNotNull(parameterObject, "imdbnumber"))
details.m_strIMDBNumber = parameterObject["imdbnumber"].asString();
if (ParameterNotNull(parameterObject, "premiered"))
details.m_premiered.SetFromDBDate(parameterObject["premiered"].asString());
if (ParameterNotNull(parameterObject, "votes"))
details.m_strVotes = parameterObject["votes"].asString();
if (ParameterNotNull(parameterObject, "lastplayed"))
details.m_lastPlayed.SetFromDBDateTime(parameterObject["lastplayed"].asString());
if (ParameterNotNull(parameterObject, "firstaired"))
details.m_firstAired.SetFromDBDateTime(parameterObject["firstaired"].asString());
if (ParameterNotNull(parameterObject, "productioncode"))
details.m_strProductionCode = parameterObject["productioncode"].asString();
if (ParameterNotNull(parameterObject, "season"))
details.m_iSeason = (int)parameterObject["season"].asInteger();
if (ParameterNotNull(parameterObject, "episode"))
details.m_iEpisode = (int)parameterObject["episode"].asInteger();
if (ParameterNotNull(parameterObject, "originaltitle"))
details.m_strOriginalTitle = parameterObject["originaltitle"].asString();
if (ParameterNotNull(parameterObject, "trailer"))
details.m_strTrailer = parameterObject["trailer"].asString();
if (ParameterNotNull(parameterObject, "tagline"))
details.m_strTagLine = parameterObject["tagline"].asString();
if (ParameterNotNull(parameterObject, "plotoutline"))
details.m_strPlotOutline = parameterObject["plotoutline"].asString();
if (ParameterNotNull(parameterObject, "writer"))
CopyStringArray(parameterObject["writer"], details.m_writingCredits);
if (ParameterNotNull(parameterObject, "country"))
CopyStringArray(parameterObject["country"], details.m_country);
if (ParameterNotNull(parameterObject, "top250"))
details.m_iTop250 = (int)parameterObject["top250"].asInteger();
if (ParameterNotNull(parameterObject, "sorttitle"))
details.m_strSortTitle = parameterObject["sorttitle"].asString();
if (ParameterNotNull(parameterObject, "episodeguide"))
details.m_strEpisodeGuide = parameterObject["episodeguide"].asString();
if (ParameterNotNull(parameterObject, "set"))
details.m_strSet = parameterObject["set"].asString();
if (ParameterNotNull(parameterObject, "showlink"))
CopyStringArray(parameterObject["showlink"], details.m_showLink);
if (ParameterNotNull(parameterObject, "thumbnail"))
artwork["thumb"] = parameterObject["thumbnail"].asString();
if (ParameterNotNull(parameterObject, "fanart"))
artwork["fanart"] = parameterObject["fanart"].asString();
if (ParameterNotNull(parameterObject, "tag"))
CopyStringArray(parameterObject["tag"], details.m_tags);
if (ParameterNotNull(parameterObject, "art"))
{
CVariant art = parameterObject["art"];
for (CVariant::const_iterator_map artIt = art.begin_map(); artIt != art.end_map(); artIt++)
{
if (!artIt->second.asString().empty())
artwork[artIt->first] = CTextureCache::UnwrapImageURL(artIt->second.asString());
}
}
}
void CapeOpenCalculator::setSubstanceConstants()
{
// Let the property package calc the constant props
CVariant props;
if(_socket->GetMaterialObject()->getLiquidPhasePossible())
props.MakeArray(COPropsConst::Count, VT_BSTR);
else
props.MakeArray(1, VT_BSTR);
for (int i = 0; i < COPropsConst::Count; i++)
{
if(wcscmp(COPropsConst::At[i], COPropsConst::TCRIT) == 0 || wcscmp(COPropsConst::At[i], COPropsConst::PCRIT) == 0)
{
if(_socket->GetMaterialObject()->getLiquidPhasePossible())
{
props.SetStringAt(i, COPropsConst::At[i]);
}
else
{
warningMessage("CapeOpenCalculator", "Fluid constant \"%S\" is unavailable for %s.",
COPropsConst::At[i], _libraryName.c_str());
}
}
else
{
props.SetStringAt(i, COPropsConst::At[i]);
}
}
CVariant results;
results.MakeArray(COPropsConst::Count * _numCompounds, VT_VARIANT);
_socket->GetConstants(props, results);
// Get the results
for(int i = 0; i < _numCompounds; ++i)
{
FluidConstants fc;
fc.MM = V_R8(&results.GetVariantAt(COPropsConst::MMOL_ID * _numCompounds + i)); // result is expected in kg/mol (SI)!
if(_socket->GetMaterialObject()->getLiquidPhasePossible())
{
fc.Tc = V_R8(&results.GetVariantAt(COPropsConst::TCRIT_ID * _numCompounds + i));
fc.pc = V_R8(&results.GetVariantAt(COPropsConst::PCRIT_ID * _numCompounds + i));
}
this->_fluidConstants.push_back(fc);
}
// set molar mass of material object (mixtures: temporarily set to molar mass of first compound, total/average is calculated in setSubstanceProperties())
_socket->GetMaterialObject()->setMM(_fluidConstants[0].MM);
// TODO: Get the other constants using a flash
/*
this->doFlash(this->_fluidConstants.pc, this->_fluidConstants.Tc,
COPropsOverall::PRESSURE, COPropsOverall::TEMPERATURE,
COFlashTypes::TP);
this->doCalcOverall();
this->getPropOverall(COPropsOverall::DENSITY, this->_fluidConstants.dc);
this->getPropOverall(COPropsOverall::ENTHALPY, this->_fluidConstants.hc);
this->getPropOverall(COPropsOverall::ENTROPY, this->_fluidConstants.sc);
*/
}
JSONRPC_STATUS CJSONRPC::Ping(const CStdString &method, ITransportLayer *transport, IClient *client, const CVariant& parameterObject, CVariant &result)
{
CVariant temp = "pong";
result.swap(temp);
return OK;
}
CapeOpenCalculator::CapeOpenCalculator(const MaterialCalculatorSetup* setupInfo)
: BaseCalculator(setupInfo)
{
// Get the property package name from the library name
string packageName = _libraryName.substr(_libraryName.find(".")+1);
if (packageName.find("StanMix") != string::npos ||
packageName.find("PCP-SAFT") != string::npos ||
packageName.find("TPSI") != string::npos ||
packageName.find("vThermo") != string::npos ||
packageName.find("GasMix") != string::npos ||
packageName.find("IF97") != string::npos ||
packageName.find("RefProp") != string::npos)
{
warningMessage("CapeOpenCalculator", "Calculation of properties under "
"specific phases is not supported by this property "
"package. The returned values will be an average over "
"the present phases.\n");
}
// Get the property package by its name
LPDISPATCH pack;
HRESULT hr = ppm->getPropertyPackage(packageName, &pack);
if (FAILED(hr))
{
errorMessage("CapeOpenCalculator", "Unable to load the specified "
"property package.\nCAPE-OPEN error:\n\t%s",
COUtilities::GetCOErrorAsString(pack, hr).c_str());
return;
}
// The socket handles the property package from here.
_socket = new CapeOpenSocket_1_0(pack);
pack->Release();
// Set the substance on the material object
CVariant compIds;
compIds.MakeArray(_numCompounds, VT_BSTR);
compIds.SetStringAt(0, _bstr_t(setupInfo->compounds));
for(int i = 0; i < _numCompounds; ++i)
{
compIds.SetStringAt(i, _bstr_t(_compounds[i].c_str()));
}
// set component ids of material object
_socket->GetMaterialObject()->setComponentIds(compIds.Value());
// Get the phase ids in order to determine which constants should be available
CVariant phaseNames;
//phaseNames.MakeArray(COPhases1Ph::Count, VT_R8);
_socket->GetSupportedPhases(phaseNames);
_socket->GetMaterialObject()->setVaporPhasePossible(false);
_socket->GetMaterialObject()->setLiquidPhasePossible(false);
_socket->GetMaterialObject()->setSolidPhasePossible(false);
std::wstring error;
if (phaseNames.CheckArray(VT_BSTR, error))
{
// Add the packages to the list.
for (int i = 0; i < phaseNames.GetCount(); ++i)
{
BSTR phaseName = phaseNames.GetStringAt(i);
if(lstrcmpi(phaseName, COPhases1Ph::VAPOR) == 0)
_socket->GetMaterialObject()->setVaporPhasePossible(true);
if(lstrcmpi(phaseName, COPhases1Ph::LIQUID) == 0)
_socket->GetMaterialObject()->setLiquidPhasePossible(true);
if(lstrcmpi(phaseName, COPhases1Ph::SOLID) == 0)
_socket->GetMaterialObject()->setSolidPhasePossible(true);
}
}
// set the fluid constants
this->setSubstanceConstants();
}
JSONRPC_STATUS CPlayerOperations::Open(const CStdString &method, ITransportLayer *transport, IClient *client, const CVariant ¶meterObject, CVariant &result)
{
CVariant optionShuffled = parameterObject["options"]["shuffled"];
CVariant optionRepeat = parameterObject["options"]["repeat"];
CVariant optionResume = parameterObject["options"]["resume"];
if (parameterObject["item"].isObject() && parameterObject["item"].isMember("playlistid"))
{
int playlistid = (int)parameterObject["item"]["playlistid"].asInteger();
if (playlistid < PLAYLIST_PICTURE)
{
// Apply the "shuffled" option if available
if (optionShuffled.isBoolean())
g_playlistPlayer.SetShuffle(playlistid, optionShuffled.asBoolean(), false);
// Apply the "repeat" option if available
if (!optionRepeat.isNull())
g_playlistPlayer.SetRepeat(playlistid, (REPEAT_STATE)ParseRepeatState(optionRepeat), false);
}
switch (playlistid)
{
case PLAYLIST_MUSIC:
case PLAYLIST_VIDEO:
CApplicationMessenger::Get().MediaPlay(playlistid, (int)parameterObject["item"]["position"].asInteger());
OnPlaylistChanged();
break;
case PLAYLIST_PICTURE:
return StartSlideshow("", false, optionShuffled.isBoolean() && optionShuffled.asBoolean());
break;
}
return ACK;
}
else if (parameterObject["item"].isObject() && parameterObject["item"].isMember("path"))
{
bool random = (optionShuffled.isBoolean() && optionShuffled.asBoolean()) ||
(!optionShuffled.isBoolean() && parameterObject["item"]["random"].asBoolean());
return StartSlideshow(parameterObject["item"]["path"].asString(), parameterObject["item"]["recursive"].asBoolean(), random);
}
else if (parameterObject["item"].isObject() && parameterObject["item"].isMember("partymode"))
{
if (g_partyModeManager.IsEnabled())
g_partyModeManager.Disable();
CApplicationMessenger::Get().ExecBuiltIn("playercontrol(partymode(" + parameterObject["item"]["partymode"].asString() + "))");
return ACK;
}
else if (parameterObject["item"].isObject() && parameterObject["item"].isMember("channelid"))
{
if (!g_PVRManager.IsStarted())
return FailedToExecute;
CPVRChannelGroupsContainer *channelGroupContainer = g_PVRChannelGroups;
if (channelGroupContainer == NULL)
return FailedToExecute;
CPVRChannelPtr channel = channelGroupContainer->GetChannelById((int)parameterObject["item"]["channelid"].asInteger());
if (channel == NULL)
return InvalidParams;
CApplicationMessenger::Get().PlayFile(CFileItem(*channel.get()));
return ACK;
}
else
{
CFileItemList list;
if (FillFileItemList(parameterObject["item"], list) && list.Size() > 0)
{
bool slideshow = true;
for (int index = 0; index < list.Size(); index++)
{
if (!list[index]->IsPicture())
{
slideshow = false;
break;
}
}
if (slideshow)
{
CGUIWindowSlideShow *slideshow = (CGUIWindowSlideShow*)g_windowManager.GetWindow(WINDOW_SLIDESHOW);
if (!slideshow)
return FailedToExecute;
SendSlideshowAction(ACTION_STOP);
slideshow->Reset();
for (int index = 0; index < list.Size(); index++)
slideshow->Add(list[index].get());
return StartSlideshow("", false, optionShuffled.isBoolean() && optionShuffled.asBoolean());
}
else
{
// Handle "shuffled" option
if (optionShuffled.isBoolean())
list.SetProperty("shuffled", optionShuffled);
// Handle "repeat" option
if (!optionRepeat.isNull())
list.SetProperty("repeat", ParseRepeatState(optionRepeat));
// Handle "resume" option
if (list.Size() == 1)
{
if (optionResume.isBoolean() && optionResume.asBoolean())
list[0]->m_lStartOffset = STARTOFFSET_RESUME;
else if (optionResume.isDouble())
list[0]->SetProperty("StartPercent", optionResume);
else if (optionResume.isObject())
list[0]->m_lStartOffset = (int)(ParseTimeInSeconds(optionResume) * 75.0);
}
CApplicationMessenger::Get().MediaPlay(list);
}
return ACK;
}
else
return InvalidParams;
}
return InvalidParams;
}
JSONRPC_STATUS CAddonsOperations::ExecuteAddon(const std::string &method, ITransportLayer *transport, IClient *client, const CVariant ¶meterObject, CVariant &result)
{
string id = parameterObject["addonid"].asString();
AddonPtr addon;
if (!CAddonMgr::GetInstance().GetAddon(id, addon) || addon.get() == NULL ||
addon->Type() < ADDON_SKIN || addon->Type() >= ADDON_MAX)
return InvalidParams;
string argv;
CVariant params = parameterObject["params"];
if (params.isObject())
{
for (CVariant::const_iterator_map it = params.begin_map(); it != params.end_map(); it++)
{
if (it != params.begin_map())
argv += ",";
argv += it->first + "=" + it->second.asString();
}
}
else if (params.isArray())
{
for (CVariant::const_iterator_array it = params.begin_array(); it != params.end_array(); it++)
{
if (it != params.begin_array())
argv += ",";
argv += StringUtils::Paramify(it->asString());
}
}
else if (params.isString())
{
if (!params.empty())
argv = StringUtils::Paramify(params.asString());
}
std::string cmd;
if (params.size() == 0)
cmd = StringUtils::Format("RunAddon(%s)", id.c_str());
else
cmd = StringUtils::Format("RunAddon(%s, %s)", id.c_str(), argv.c_str());
if (params["wait"].asBoolean())
CApplicationMessenger::GetInstance().SendMsg(TMSG_EXECUTE_BUILT_IN, -1, -1, nullptr, cmd);
else
CApplicationMessenger::GetInstance().PostMsg(TMSG_EXECUTE_BUILT_IN, -1, -1, nullptr, cmd);
return ACK;
}
JSONRPC_STATUS CPlayerOperations::GetPropertyValue(PlayerType player, const CStdString &property, CVariant &result)
{
if (player == None)
return FailedToExecute;
int playlist = GetPlaylist(player);
if (property.Equals("type"))
{
switch (player)
{
case Video:
result = "video";
break;
case Audio:
result = "audio";
break;
case Picture:
result = "picture";
break;
default:
return FailedToExecute;
}
}
else if (property.Equals("partymode"))
{
switch (player)
{
case Video:
case Audio:
if (IsPVRChannel())
{
result = false;
break;
}
result = g_partyModeManager.IsEnabled();
break;
case Picture:
result = false;
break;
default:
return FailedToExecute;
}
}
else if (property.Equals("speed"))
{
CGUIWindowSlideShow *slideshow = NULL;
switch (player)
{
case Video:
case Audio:
result = g_application.IsPaused() ? 0 : g_application.GetPlaySpeed();
break;
case Picture:
slideshow = (CGUIWindowSlideShow*)g_windowManager.GetWindow(WINDOW_SLIDESHOW);
if (slideshow && slideshow->IsPlaying() && !slideshow->IsPaused())
result = slideshow->GetDirection();
else
result = 0;
break;
default:
return FailedToExecute;
}
}
else if (property.Equals("time"))
{
switch (player)
{
case Video:
case Audio:
{
int ms = 0;
if (!IsPVRChannel())
ms = (int)(g_application.GetTime() * 1000.0);
else
{
EPG::CEpgInfoTag epg;
if (GetCurrentEpg(epg))
ms = epg.Progress() * 1000;
}
MillisecondsToTimeObject(ms, result);
break;
}
case Picture:
MillisecondsToTimeObject(0, result);
break;
default:
return FailedToExecute;
}
}
else if (property.Equals("percentage"))
{
CGUIWindowSlideShow *slideshow = NULL;
switch (player)
{
case Video:
case Audio:
{
if (!IsPVRChannel())
result = g_application.GetPercentage();
else
{
EPG::CEpgInfoTag epg;
if (GetCurrentEpg(epg))
result = epg.ProgressPercentage();
else
result = 0;
}
break;
}
case Picture:
slideshow = (CGUIWindowSlideShow*)g_windowManager.GetWindow(WINDOW_SLIDESHOW);
if (slideshow && slideshow->NumSlides() > 0)
result = (double)slideshow->CurrentSlide() / slideshow->NumSlides();
else
result = 0.0;
break;
default:
return FailedToExecute;
}
}
else if (property.Equals("totaltime"))
{
switch (player)
{
case Video:
case Audio:
{
int ms = 0;
if (!IsPVRChannel())
ms = (int)(g_application.GetTotalTime() * 1000.0);
else
{
EPG::CEpgInfoTag epg;
if (GetCurrentEpg(epg))
ms = epg.GetDuration() * 1000;
}
MillisecondsToTimeObject(ms, result);
break;
}
case Picture:
MillisecondsToTimeObject(0, result);
break;
default:
return FailedToExecute;
}
}
else if (property.Equals("playlistid"))
{
result = playlist;
}
else if (property.Equals("position"))
{
CGUIWindowSlideShow *slideshow = NULL;
switch (player)
{
case Video:
case Audio:
if (!IsPVRChannel() && g_playlistPlayer.GetCurrentPlaylist() == playlist)
result = g_playlistPlayer.GetCurrentSong();
else
result = -1;
break;
case Picture:
slideshow = (CGUIWindowSlideShow*)g_windowManager.GetWindow(WINDOW_SLIDESHOW);
if (slideshow && slideshow->IsPlaying())
result = slideshow->CurrentSlide() - 1;
else
result = -1;
break;
default:
result = -1;
break;
}
}
else if (property.Equals("repeat"))
{
switch (player)
{
case Video:
case Audio:
if (IsPVRChannel())
{
result = "off";
break;
}
switch (g_playlistPlayer.GetRepeat(playlist))
{
case REPEAT_ONE:
result = "one";
break;
case REPEAT_ALL:
result = "all";
break;
default:
result = "off";
break;
}
break;
case Picture:
default:
result = "off";
break;
}
}
else if (property.Equals("shuffled"))
{
CGUIWindowSlideShow *slideshow = NULL;
switch (player)
{
case Video:
case Audio:
if (IsPVRChannel())
{
result = false;
break;
}
result = g_playlistPlayer.IsShuffled(playlist);
break;
case Picture:
slideshow = (CGUIWindowSlideShow*)g_windowManager.GetWindow(WINDOW_SLIDESHOW);
if (slideshow && slideshow->IsPlaying())
result = slideshow->IsShuffled();
else
result = -1;
break;
default:
result = -1;
break;
}
}
else if (property.Equals("canseek"))
{
switch (player)
{
case Video:
case Audio:
if (g_application.m_pPlayer)
result = g_application.m_pPlayer->CanSeek();
else
result = false;
break;
case Picture:
default:
result = false;
break;
}
}
else if (property.Equals("canchangespeed"))
{
switch (player)
{
case Video:
case Audio:
result = !IsPVRChannel();
break;
case Picture:
default:
result = false;
break;
}
}
else if (property.Equals("canmove"))
{
switch (player)
{
case Picture:
result = true;
break;
case Video:
case Audio:
default:
result = false;
break;
}
}
else if (property.Equals("canzoom"))
{
switch (player)
{
case Picture:
result = true;
break;
case Video:
case Audio:
default:
result = false;
break;
}
}
else if (property.Equals("canrotate"))
{
switch (player)
{
case Picture:
result = true;
break;
case Video:
case Audio:
default:
result = false;
break;
}
}
else if (property.Equals("canshuffle"))
{
switch (player)
{
case Video:
case Audio:
case Picture:
result = !IsPVRChannel();
break;
default:
result = false;
break;
}
}
else if (property.Equals("canrepeat"))
{
switch (player)
{
case Video:
case Audio:
result = !IsPVRChannel();
break;
case Picture:
default:
result = false;
break;
}
}
else if (property.Equals("currentaudiostream"))
{
switch (player)
{
case Video:
case Audio:
if (g_application.m_pPlayer)
{
result = CVariant(CVariant::VariantTypeObject);
int index = g_application.m_pPlayer->GetAudioStream();
if (index >= 0)
{
result["index"] = index;
CStdString value;
g_application.m_pPlayer->GetAudioStreamName(index, value);
result["name"] = value;
value.Empty();
g_application.m_pPlayer->GetAudioStreamLanguage(index, value);
result["language"] = value;
}
result["codec"] = g_application.m_pPlayer->GetAudioCodecName();
result["bitrate"] = g_application.m_pPlayer->GetAudioBitrate();
result["channels"] = g_application.m_pPlayer->GetChannels();
}
else
result = CVariant(CVariant::VariantTypeNull);
break;
case Picture:
default:
result = CVariant(CVariant::VariantTypeNull);
break;
}
}
else if (property.Equals("audiostreams"))
{
result = CVariant(CVariant::VariantTypeArray);
switch (player)
{
case Video:
if (g_application.m_pPlayer)
{
for (int index = 0; index < g_application.m_pPlayer->GetAudioStreamCount(); index++)
{
CVariant audioStream(CVariant::VariantTypeObject);
audioStream["index"] = index;
CStdString value;
g_application.m_pPlayer->GetAudioStreamName(index, value);
audioStream["name"] = value;
value.Empty();
g_application.m_pPlayer->GetAudioStreamLanguage(index, value);
audioStream["language"] = value;
result.append(audioStream);
}
}
break;
case Audio:
case Picture:
default:
break;
}
}
else if (property.Equals("subtitleenabled"))
{
switch (player)
{
case Video:
if (g_application.m_pPlayer)
result = g_application.m_pPlayer->GetSubtitleVisible();
break;
case Audio:
case Picture:
default:
result = false;
break;
}
}
else if (property.Equals("currentsubtitle"))
{
switch (player)
{
case Video:
if (g_application.m_pPlayer)
{
result = CVariant(CVariant::VariantTypeObject);
int index = g_application.m_pPlayer->GetSubtitle();
if (index >= 0)
{
result["index"] = index;
CStdString value;
g_application.m_pPlayer->GetSubtitleName(index, value);
result["name"] = value;
value.Empty();
g_application.m_pPlayer->GetSubtitleLanguage(index, value);
result["language"] = value;
}
}
else
result = CVariant(CVariant::VariantTypeNull);
break;
case Audio:
case Picture:
default:
result = CVariant(CVariant::VariantTypeNull);
break;
}
}
else if (property.Equals("subtitles"))
{
result = CVariant(CVariant::VariantTypeArray);
switch (player)
{
case Video:
if (g_application.m_pPlayer)
{
for (int index = 0; index < g_application.m_pPlayer->GetSubtitleCount(); index++)
{
CVariant subtitle(CVariant::VariantTypeObject);
subtitle["index"] = index;
CStdString value;
g_application.m_pPlayer->GetSubtitleName(index, value);
subtitle["name"] = value;
value.Empty();
g_application.m_pPlayer->GetSubtitleLanguage(index, value);
subtitle["language"] = value;
result.append(subtitle);
}
}
break;
case Audio:
case Picture:
default:
break;
}
}
else if (property.Equals("live"))
result = IsPVRChannel();
else
return InvalidParams;
return OK;
}
void CFileItemHandler::HandleFileItem(const char *ID, bool allowFile, const char *resultname, CFileItemPtr item, const CVariant ¶meterObject, const CVariant &validFields, CVariant &result, bool append /* = true */)
{
CVariant object;
bool hasFileField = false;
bool hasThumbnailField = false;
if (item.get())
{
for (unsigned int i = 0; i < validFields.size(); i++)
{
CStdString field = validFields[i].asString();
if (field == "file")
hasFileField = true;
if (field == "thumbnail")
hasThumbnailField = true;
}
if (allowFile && hasFileField)
{
if (item->HasVideoInfoTag() && !item->GetVideoInfoTag()->GetPath().IsEmpty())
object["file"] = item->GetVideoInfoTag()->GetPath().c_str();
if (item->HasMusicInfoTag() && !item->GetMusicInfoTag()->GetURL().IsEmpty())
object["file"] = item->GetMusicInfoTag()->GetURL().c_str();
if (!object.isMember("file"))
object["file"] = item->GetPath().c_str();
}
if (ID)
{
if (item->HasMusicInfoTag() && item->GetMusicInfoTag()->GetDatabaseId() > 0)
object[ID] = (int)item->GetMusicInfoTag()->GetDatabaseId();
else if (item->HasVideoInfoTag() && item->GetVideoInfoTag()->m_iDbId > 0)
object[ID] = item->GetVideoInfoTag()->m_iDbId;
if (stricmp(ID, "id") == 0)
{
if (item->HasMusicInfoTag())
{
if (item->m_bIsFolder && item->IsAlbum())
object["type"] = "album";
else
object["type"] = "song";
}
else if (item->HasVideoInfoTag())
{
switch (item->GetVideoContentType())
{
case VIDEODB_CONTENT_EPISODES:
object["type"] = "episode";
break;
case VIDEODB_CONTENT_MUSICVIDEOS:
object["type"] = "musicvideo";
break;
case VIDEODB_CONTENT_MOVIES:
object["type"] = "movie";
break;
case VIDEODB_CONTENT_TVSHOWS:
object["type"] = "tvshow";
break;
default:
break;
}
}
else if (item->HasPictureInfoTag())
object["type"] = "picture";
if (!object.isMember("type"))
object["type"] = "unknown";
}
}
if (hasThumbnailField)
{
if (item->HasThumbnail())
object["thumbnail"] = CTextureCache::Get().CheckAndCacheImage(item->GetThumbnailImage());
else if (item->HasVideoInfoTag())
{
CStdString strPath, strFileName;
URIUtils::Split(item->GetCachedVideoThumb(), strPath, strFileName);
CStdString cachedThumb = strPath + "auto-" + strFileName;
if (CFile::Exists(cachedThumb))
object["thumbnail"] = cachedThumb;
}
else if (item->HasPictureInfoTag())
{
CStdString thumb = CTextureCache::Get().CheckAndCacheImage(CTextureCache::GetWrappedThumbURL(item->GetPath()));
if (!thumb.empty())
object["thumbnail"] = thumb;
}
if (!object.isMember("thumbnail"))
object["thumbnail"] = "";
}
FillDetails(item.get(), item, validFields, object);
if (item->HasVideoInfoTag())
FillDetails(item->GetVideoInfoTag(), item, validFields, object);
if (item->HasMusicInfoTag())
FillDetails(item->GetMusicInfoTag(), item, validFields, object);
if (item->HasPictureInfoTag())
FillDetails(item->GetPictureInfoTag(), item, validFields, object);
object["label"] = item->GetLabel().c_str();
}
else
object = CVariant(CVariant::VariantTypeNull);
if (resultname)
{
if (append)
result[resultname].append(object);
else
result[resultname] = object;
}
}
void CFileItemHandler::HandleFileItem(const char *ID, bool allowFile, const char *resultname, CFileItemPtr item, const CVariant ¶meterObject, const std::set<std::string> &validFields, CVariant &result, bool append /* = true */, CThumbLoader *thumbLoader /* = NULL */)
{
CVariant object;
std::set<std::string> fields(validFields.begin(), validFields.end());
if (item.get())
{
std::set<std::string>::const_iterator fileField = fields.find("file");
if (fileField != fields.end())
{
if (allowFile)
{
if (item->HasVideoInfoTag() && !item->GetVideoInfoTag()->GetPath().IsEmpty())
object["file"] = item->GetVideoInfoTag()->GetPath().c_str();
if (item->HasMusicInfoTag() && !item->GetMusicInfoTag()->GetURL().IsEmpty())
object["file"] = item->GetMusicInfoTag()->GetURL().c_str();
if (!object.isMember("file"))
object["file"] = item->GetPath().c_str();
}
fields.erase(fileField);
}
if (ID)
{
if (item->HasPVRChannelInfoTag() && item->GetPVRChannelInfoTag()->ChannelID() > 0)
object[ID] = item->GetPVRChannelInfoTag()->ChannelID();
else if (item->HasMusicInfoTag() && item->GetMusicInfoTag()->GetDatabaseId() > 0)
object[ID] = (int)item->GetMusicInfoTag()->GetDatabaseId();
else if (item->HasVideoInfoTag() && item->GetVideoInfoTag()->m_iDbId > 0)
object[ID] = item->GetVideoInfoTag()->m_iDbId;
if (stricmp(ID, "id") == 0)
{
if (item->HasPVRChannelInfoTag())
object["type"] = "channel";
else if (item->HasMusicInfoTag())
{
std::string type = item->GetMusicInfoTag()->GetType();
if (type == "album" || type == "song" || type == "artist")
object["type"] = type;
else
object["type"] = "song";
}
else if (item->HasVideoInfoTag() && !item->GetVideoInfoTag()->m_type.empty())
{
std::string type = item->GetVideoInfoTag()->m_type;
if (type == "movie" || type == "tvshow" || type == "episode" || type == "musicvideo")
object["type"] = type;
}
else if (item->HasPictureInfoTag())
object["type"] = "picture";
if (!object.isMember("type"))
object["type"] = "unknown";
if (fields.find("filetype") != fields.end())
{
if (item->m_bIsFolder)
object["filetype"] = "directory";
else
object["filetype"] = "file";
}
}
}
bool deleteThumbloader = false;
if (thumbLoader == NULL)
{
if (item->HasVideoInfoTag())
thumbLoader = new CVideoThumbLoader();
else if (item->HasMusicInfoTag())
thumbLoader = new CMusicThumbLoader();
if (thumbLoader != NULL)
{
deleteThumbloader = true;
thumbLoader->Initialize();
}
}
if (item->HasPVRChannelInfoTag())
FillDetails(item->GetPVRChannelInfoTag(), item, fields, object, thumbLoader);
if (item->HasVideoInfoTag())
FillDetails(item->GetVideoInfoTag(), item, fields, object, thumbLoader);
if (item->HasMusicInfoTag())
FillDetails(item->GetMusicInfoTag(), item, fields, object, thumbLoader);
if (item->HasPictureInfoTag())
FillDetails(item->GetPictureInfoTag(), item, fields, object, thumbLoader);
FillDetails(item.get(), item, fields, object, thumbLoader);
if (deleteThumbloader)
delete thumbLoader;
object["label"] = item->GetLabel().c_str();
}
else
object = CVariant(CVariant::VariantTypeNull);
if (resultname)
{
if (append)
result[resultname].append(object);
else
result[resultname] = object;
}
}
bool CJSONVariantWriter::InternalWrite(yajl_gen g, const CVariant &value)
{
bool success = false;
switch (value.type())
{
case CVariant::VariantTypeInteger:
#if YAJL_MAJOR == 2
success = yajl_gen_status_ok == yajl_gen_integer(g, (long long int)value.asInteger());
#else
success = yajl_gen_status_ok == yajl_gen_integer(g, (long int)value.asInteger());
#endif
break;
case CVariant::VariantTypeUnsignedInteger:
#if YAJL_MAJOR == 2
success = yajl_gen_status_ok == yajl_gen_integer(g, (long long int)value.asUnsignedInteger());
#else
success = yajl_gen_status_ok == yajl_gen_integer(g, (long int)value.asUnsignedInteger());
#endif
break;
case CVariant::VariantTypeDouble:
success = yajl_gen_status_ok == yajl_gen_double(g, value.asDouble());
break;
case CVariant::VariantTypeBoolean:
success = yajl_gen_status_ok == yajl_gen_bool(g, value.asBoolean() ? 1 : 0);
break;
case CVariant::VariantTypeString:
#if YAJL_MAJOR == 2
success = yajl_gen_status_ok == yajl_gen_string(g, (const unsigned char*)value.c_str(), (size_t)value.size());
#else
success = yajl_gen_status_ok == yajl_gen_string(g, (const unsigned char*)value.c_str(), value.size());
#endif
break;
case CVariant::VariantTypeArray:
success = yajl_gen_status_ok == yajl_gen_array_open(g);
for (CVariant::const_iterator_array itr = value.begin_array(); itr != value.end_array() && success; itr++)
success &= InternalWrite(g, *itr);
if (success)
success = yajl_gen_status_ok == yajl_gen_array_close(g);
break;
case CVariant::VariantTypeObject:
success = yajl_gen_status_ok == yajl_gen_map_open(g);
for (CVariant::const_iterator_map itr = value.begin_map(); itr != value.end_map() && success; itr++)
{
#if YAJL_MAJOR == 2
success &= yajl_gen_status_ok == yajl_gen_string(g, (const unsigned char*)itr->first.c_str(), (size_t)itr->first.length());
#else
success &= yajl_gen_status_ok == yajl_gen_string(g, (const unsigned char*)itr->first.c_str(), itr->first.length());
#endif
if (success)
success &= InternalWrite(g, itr->second);
}
if (success)
success &= yajl_gen_status_ok == yajl_gen_map_close(g);
break;
case CVariant::VariantTypeConstNull:
case CVariant::VariantTypeNull:
default:
success = yajl_gen_status_ok == yajl_gen_null(g);
break;
}
return success;
}
