public override IEnumerable <MetadataProperty> GetPlatforms(GetMetadataFieldArgs args)
{
yield return(new MetadataSpecProperty("pc_windows"));
yield return(new MetadataSpecProperty("Sony PlayStation Vita"));
yield return(new MetadataNameProperty("Microsoft Xbox 360"));
}
public override string GetName(GetMetadataFieldArgs args)
{
if (AvailableFields.Contains(MetadataField.Name))
{
return(gameData.Name);
}
return(base.GetName(args));
}
public override IEnumerable <MetadataProperty> GetPublishers(GetMetadataFieldArgs args)
{
if (AvailableFields.Contains(MetadataField.Publishers))
{
return(gameData.Publishers);
}
return(base.GetPublishers(args));
}
public override MetadataFile GetCoverImage(GetMetadataFieldArgs args)
{
if (AvailableFields.Contains(MetadataField.ReleaseDate))
{
return(gameData.CoverImage);
}
return(base.GetCoverImage(args));
}
public void DownloadPluginData(MetadataPlugin plugin)
{
var res = dialogs.ActivateGlobalProgress((args) =>
{
var provider = plugin.GetMetadataProvider(new MetadataRequestOptions(EditingGame, false));
if (provider != null)
{
try
{
var fieldArgs = new GetMetadataFieldArgs {
CancelToken = args.CancelToken
};
var metadata = new GameMetadata
{
Name = provider.GetName(fieldArgs),
Genres = provider.GetGenres(fieldArgs)?.Where(a => a != null).ToHashSet(),
ReleaseDate = provider.GetReleaseDate(fieldArgs),
Developers = provider.GetDevelopers(fieldArgs)?.Where(a => a != null).ToHashSet(),
Publishers = provider.GetPublishers(fieldArgs)?.Where(a => a != null).ToHashSet(),
Tags = provider.GetTags(fieldArgs)?.Where(a => a != null).ToHashSet(),
Features = provider.GetFeatures(fieldArgs)?.Where(a => a != null).ToHashSet(),
Description = provider.GetDescription(fieldArgs),
Links = provider.GetLinks(fieldArgs)?.Where(a => a != null).ToList(),
CriticScore = provider.GetCriticScore(fieldArgs),
CommunityScore = provider.GetCommunityScore(fieldArgs),
AgeRatings = provider.GetAgeRatings(fieldArgs)?.Where(a => a != null).ToHashSet(),
Series = provider.GetSeries(fieldArgs)?.Where(a => a != null).ToHashSet(),
Regions = provider.GetRegions(fieldArgs)?.Where(a => a != null).ToHashSet(),
Platforms = provider.GetPlatforms(fieldArgs)?.Where(a => a != null).ToHashSet(),
Icon = provider.GetIcon(fieldArgs),
CoverImage = provider.GetCoverImage(fieldArgs),
BackgroundImage = provider.GetBackgroundImage(fieldArgs)
};
Application.Current.Dispatcher.Invoke(() => PreviewGameData(ConvertGameInfo(metadata)));
}
finally
{
provider.Dispose();
}
}
}, new GlobalProgressOptions(LOC.DownloadingLabel)
{
IsIndeterminate = true,
Cancelable = true
});
if (res.Error != null)
{
logger.Error(res.Error, string.Format("Failed to download metadata, {0}, {1}", Game.PluginId, Game.GameId));
dialogs.ShowMessage(
string.Format(resources.GetString("LOCMetadataDownloadError"), res.Error.Message),
resources.GetString("LOCDownloadError"),
MessageBoxButton.OK, MessageBoxImage.Error);
}
}
public Task <IEnumerable <ISearchItem <string> > > GetItemsTask(string query, IReadOnlyList <Candidate> addedItems)
{
if (string.IsNullOrWhiteSpace(query))
{
return(null);
}
var metadataArgs = new GetMetadataFieldArgs();
return(Task.Run(() =>
{
var game = new Game(query);
var gameMetadata = new GameMetadata();
var requestOptions = new MetadataRequestOptions(game, true);
List <ISearchItem <string> > items = new List <ISearchItem <string> >();
using (var provider = metadataPlugin.GetMetadataProvider(requestOptions))
{
var item = new CommandItem();
var fields = provider.AvailableFields;
if (fields.Contains(MetadataField.Icon))
{
gameMetadata.Icon = provider.GetIcon(new GetMetadataFieldArgs());
}
if (fields.Contains(MetadataField.Platform))
{
gameMetadata.Platforms = provider.GetPlatforms(new GetMetadataFieldArgs()).ToHashSet();
}
if (fields.Contains(MetadataField.Genres))
{
gameMetadata.Genres = provider.GetGenres(new GetMetadataFieldArgs()).ToHashSet();
}
if (fields.Contains(MetadataField.Name) && provider.GetName(new GetMetadataFieldArgs()) is string name)
{
gameMetadata.Name = name;
var tempGame = SearchPlugin.Instance.PlayniteApi.Database.ImportGame(gameMetadata);
items.Add(new GameSearchItem(tempGame));
if (SearchPlugin.Instance.PlayniteApi.Database.Games.Remove(tempGame.Id))
{
}
else
{
}
}
}
return items.AsEnumerable();
}, metadataArgs.CancelToken));
}
public override IEnumerable<MetadataProperty> GetTags(GetMetadataFieldArgs args)
{
return metadata.Tags;
}
public override IEnumerable<MetadataProperty> GetPlatforms(GetMetadataFieldArgs args)
{
return metadata.Platforms;
}
public override IEnumerable <MetadataProperty> GetFeatures(GetMetadataFieldArgs args)
{
yield return(new MetadataNameProperty("Test Feature"));
}
public override string GetDescription(GetMetadataFieldArgs args)
{
return metadata.Description;
}
public override int? GetCriticScore(GetMetadataFieldArgs args)
{
return metadata.CriticScore;
}
public override MetadataFile GetCoverImage(GetMetadataFieldArgs args)
{
return metadata.CoverImage;
}
public override int? GetCommunityScore(GetMetadataFieldArgs args)
{
return metadata.CommunityScore;
}
public override MetadataFile GetBackgroundImage(GetMetadataFieldArgs args)
{
return metadata.BackgroundImage;
}
public override IEnumerable<MetadataProperty> GetRegions(GetMetadataFieldArgs args)
{
return metadata.Regions;
}
public override IEnumerable <Link> GetLinks(GetMetadataFieldArgs args)
{
yield return(new Link("Playnite website", "https://playnite.link/"));
yield return(null);
}
public override MetadataFile GetIcon(GetMetadataFieldArgs args)
{
return metadata.Icon;
}
public override IEnumerable <MetadataProperty> GetRegions(GetMetadataFieldArgs args)
{
yield return(new MetadataSpecProperty("newZealand"));
yield return(new MetadataSpecProperty("hongKong"));
}
public override IEnumerable<Link> GetLinks(GetMetadataFieldArgs args)
{
return metadata.Links;
}
// Override additional methods based on supported metadata fields.
public override string GetDescription(GetMetadataFieldArgs args)
{
return(options.GameData.Name + " description");
}
public override string GetName(GetMetadataFieldArgs args)
{
return metadata.Name;
}
public override IEnumerable<MetadataProperty> GetPublishers(GetMetadataFieldArgs args)
{
return metadata.Publishers;
}
public override ReleaseDate? GetReleaseDate(GetMetadataFieldArgs args)
{
return metadata.ReleaseDate;
}
internal GameMetadata ProcessField(
Game game,
MetadataFieldSettings fieldSettings,
MetadataField gameField,
Func <GameMetadata, object> propertySelector,
Dictionary <Guid, GameMetadata> existingStoreData,
Dictionary <Guid, OnDemandMetadataProvider> existingPluginData,
CancellationToken cancelToken)
{
if (fieldSettings.Sources.Any() == false)
{
return(null);
}
var getFieldArgs = new GetMetadataFieldArgs {
CancelToken = cancelToken
};
foreach (var source in fieldSettings.Sources)
{
if (cancelToken.IsCancellationRequested)
{
return(null);
}
try
{
// Skip Store source for manually added games.
if (source == Guid.Empty && game.PluginId == Guid.Empty)
{
continue;
}
// Check if metadata from this source are already downloaded.
if (existingStoreData.ContainsKey(source))
{
if (existingStoreData[source] != null && propertySelector(existingStoreData[source]) != null)
{
return(existingStoreData[source]);
}
else
{
continue;
}
}
// Check if downloader supports this game field.
if (source != Guid.Empty)
{
var downloader = metadataDownloaders.FirstOrDefault(a => a.Id == source);
if (downloader == null)
{
continue;
}
else if (downloader.SupportedFields?.Contains(gameField) != true)
{
continue;
}
}
// Download metadata.
GameMetadata metadata = null;
if (source == Guid.Empty)
{
metadata = ProcessStoreDownload(game);
existingStoreData.Add(source, metadata);
}
else
{
var downloader = metadataDownloaders.FirstOrDefault(a => a.Id == source);
if (downloader == null)
{
continue;
}
OnDemandMetadataProvider provider = null;
if (existingPluginData.ContainsKey(source))
{
provider = existingPluginData[source];
}
else
{
provider = downloader.GetMetadataProvider(new MetadataRequestOptions(game, true));
existingPluginData.Add(source, provider);
}
if (provider == null)
{
continue;
}
if (!provider.AvailableFields.Contains(gameField))
{
continue;
}
metadata = new GameMetadata();
switch (gameField)
{
case MetadataField.Name:
metadata.Name = provider.GetName(getFieldArgs);
break;
case MetadataField.Genres:
metadata.Genres = provider.GetGenres(getFieldArgs)?.Where(a => a != null).ToHashSet();
break;
case MetadataField.ReleaseDate:
metadata.ReleaseDate = provider.GetReleaseDate(getFieldArgs);
break;
case MetadataField.Developers:
metadata.Developers = provider.GetDevelopers(getFieldArgs)?.Where(a => a != null).ToHashSet();
break;
case MetadataField.Publishers:
metadata.Publishers = provider.GetPublishers(getFieldArgs)?.Where(a => a != null).ToHashSet();
break;
case MetadataField.Tags:
metadata.Tags = provider.GetTags(getFieldArgs)?.Where(a => a != null).ToHashSet();
break;
case MetadataField.Description:
metadata.Description = provider.GetDescription(getFieldArgs);
break;
case MetadataField.Links:
metadata.Links = provider.GetLinks(getFieldArgs)?.Where(a => a != null).ToList();
break;
case MetadataField.CriticScore:
metadata.CriticScore = provider.GetCriticScore(getFieldArgs);
break;
case MetadataField.CommunityScore:
metadata.CommunityScore = provider.GetCommunityScore(getFieldArgs);
break;
case MetadataField.Icon:
metadata.Icon = provider.GetIcon(getFieldArgs);
break;
case MetadataField.CoverImage:
metadata.CoverImage = provider.GetCoverImage(getFieldArgs);
break;
case MetadataField.BackgroundImage:
metadata.BackgroundImage = provider.GetBackgroundImage(getFieldArgs);
break;
case MetadataField.Features:
metadata.Features = provider.GetFeatures(getFieldArgs)?.Where(a => a != null).ToHashSet();
break;
case MetadataField.AgeRating:
metadata.AgeRatings = provider.GetAgeRatings(getFieldArgs)?.Where(a => a != null).ToHashSet();
break;
case MetadataField.Region:
metadata.Regions = provider.GetRegions(getFieldArgs)?.Where(a => a != null).ToHashSet();
break;
case MetadataField.Series:
metadata.Series = provider.GetSeries(getFieldArgs)?.Where(a => a != null).ToHashSet();
break;
case MetadataField.Platform:
metadata.Platforms = provider.GetPlatforms(getFieldArgs)?.Where(a => a != null).ToHashSet();
break;
default:
throw new NotImplementedException();
}
}
if (metadata != null && propertySelector(metadata) != null)
{
return(metadata);
}
else
{
continue;
}
}
catch (Exception e) when(!PlayniteEnvironment.ThrowAllErrors)
{
logger.Error(e, $"Failed to process metadata download: {gameField}, {source}");
}
}
return(null);
}
public override IEnumerable<MetadataProperty> GetFeatures(GetMetadataFieldArgs args)
{
return metadata.Features;
}
