public void Select(ListItem item)
{
if (item == null)
{
return;
}
object actionObj;
object mediaItemObj;
if (!item.AdditionalProperties.TryGetValue(Consts.KEY_MEDIA_ITEM_ACTION, out actionObj) || !item.AdditionalProperties.TryGetValue(Consts.KEY_MEDIA_ITEM, out mediaItemObj))
{
return;
}
IMediaItemAction action = actionObj as IMediaItemAction;
MediaItem mediaItem = mediaItemObj as MediaItem;
if (action == null || mediaItem == null)
{
return;
}
try
{
ContentDirectoryMessaging.MediaItemChangeType changeType;
if (action.Process(mediaItem, out changeType) && changeType != ContentDirectoryMessaging.MediaItemChangeType.None)
{
ContentDirectoryMessaging.SendMediaItemChangedMessage(mediaItem, changeType);
}
}
catch (Exception ex)
{
ServiceRegistration.Get <ILogger>().Error("Error executing MediaItemAction '{0}':", ex, action.GetType());
}
}
void UpdateCurrentlyImportingSharesProgresses(IDictionary <Guid, int> currentlyImportingSharesProgresses)
{
foreach (var progress in currentlyImportingSharesProgresses)
{
ContentDirectoryMessaging.SendShareImportProgressMessage(progress.Key, progress.Value);
}
}
public async Task <bool> MarkAsWatched(MediaItem mediaItem)
{
bool result = false;
SetWatched setWatchedAction = new SetWatched();
if (await setWatchedAction.IsAvailableAsync(mediaItem))
{
try
{
var processResult = await setWatchedAction.ProcessAsync(mediaItem);
if (processResult.Success && processResult.Result != ContentDirectoryMessaging.MediaItemChangeType.None)
{
ContentDirectoryMessaging.SendMediaItemChangedMessage(mediaItem, processResult.Result);
result = true;
}
else
{
GetLogger().Error("FlagMover: Marking media item '{0}' as watched failed:", mediaItem.GetType());
}
}
catch (Exception ex)
{
GetLogger().Error("FlagMover: Exception occurred while marking media item '{0}' as watched. Message: {1}", mediaItem.GetType(), ex.Message);
}
}
else
{
GetLogger().Warn("FlagMover: The SetWatched action is not available for '{0}'. Already marked as watched?", mediaItem.GetType());
}
return(result);
}
public async Task <bool> MarkAsWatched(MediaItem mediaItem)
{
bool result = false;
SetWatched setWatchedAction = new SetWatched();
if (await setWatchedAction.IsAvailableAsync(mediaItem))
{
try
{
var processResult = await setWatchedAction.ProcessAsync(mediaItem);
if (processResult.Success && processResult.Result != ContentDirectoryMessaging.MediaItemChangeType.None)
{
ContentDirectoryMessaging.SendMediaItemChangedMessage(mediaItem, processResult.Result);
GetLogger().Info("Marking media item '{0}' as watched", mediaItem.GetType());
result = true;
}
}
catch (Exception ex)
{
GetLogger().Error("Marking media item '{0}' as watched failed:", mediaItem.GetType(), ex);
result = false;
}
}
return(result);
}
public bool MarkAsWatched(MediaItem mediaItem)
{
bool result = false;
SetWatched setWatchedAction = new SetWatched();
if (setWatchedAction.IsAvailable(mediaItem))
{
try
{
ContentDirectoryMessaging.MediaItemChangeType changeType;
if (setWatchedAction.Process(mediaItem, out changeType) && changeType != ContentDirectoryMessaging.MediaItemChangeType.None)
{
ContentDirectoryMessaging.SendMediaItemChangedMessage(mediaItem, changeType);
result = true;
}
else
{
GetLogger().Error("FlagMover: Marking media item '{0}' as watched failed:", mediaItem.GetType());
}
}
catch (Exception ex)
{
GetLogger().Error("FlagMover: Exception occurred while marking media item '{0}' as watched. Message: {1}", mediaItem.GetType(), ex.Message);
}
}
else
{
GetLogger().Warn("FlagMover: The SetWatched action is not available for '{0}'. Already marked as watched?", mediaItem.GetType());
}
return(result);
}
protected static void NotifyPlayback(MediaItem mediaItem, int playPercentage)
{
ISettingsManager settingsManager = ServiceRegistration.Get <ISettingsManager>();
PlayerManagerSettings settings = settingsManager.Load <PlayerManagerSettings>();
bool watched = playPercentage >= settings.WatchedPlayPercentage;
if (watched)
{
playPercentage = 100;
}
IServerConnectionManager scm = ServiceRegistration.Get <IServerConnectionManager>();
IContentDirectory cd = scm.ContentDirectory;
// Server will update the PlayCount of MediaAspect in ML, this does not affect loaded items.
if (cd != null)
{
cd.NotifyPlayback(mediaItem.MediaItemId, watched);
}
// Update loaded item also, so changes will be visible in GUI without reloading
if (!mediaItem.UserData.ContainsKey(UserDataKeysKnown.KEY_PLAY_PERCENTAGE))
{
mediaItem.UserData.Add(UserDataKeysKnown.KEY_PLAY_PERCENTAGE, "0");
}
mediaItem.UserData[UserDataKeysKnown.KEY_PLAY_PERCENTAGE] = playPercentage.ToString();
IUserManagement userProfileDataManagement = ServiceRegistration.Get <IUserManagement>();
if (userProfileDataManagement.IsValidUser)
{
userProfileDataManagement.UserProfileDataManagement.SetUserMediaItemData(userProfileDataManagement.CurrentUser.ProfileId, mediaItem.MediaItemId,
UserDataKeysKnown.KEY_PLAY_PERCENTAGE, playPercentage.ToString());
}
if (watched)
{
// Update loaded item also, so changes will be visible in GUI without reloading
int currentPlayCount;
if (MediaItemAspect.TryGetAttribute(mediaItem.Aspects, MediaAspect.ATTR_PLAYCOUNT, 0, out currentPlayCount))
{
MediaItemAspect.SetAttribute(mediaItem.Aspects, MediaAspect.ATTR_PLAYCOUNT, ++currentPlayCount);
}
if (!mediaItem.UserData.ContainsKey(UserDataKeysKnown.KEY_PLAY_COUNT))
{
mediaItem.UserData.Add(UserDataKeysKnown.KEY_PLAY_COUNT, "0");
}
currentPlayCount = Convert.ToInt32(mediaItem.UserData[UserDataKeysKnown.KEY_PLAY_COUNT]);
currentPlayCount++;
mediaItem.UserData[UserDataKeysKnown.KEY_PLAY_COUNT] = currentPlayCount.ToString();
if (userProfileDataManagement.IsValidUser)
{
userProfileDataManagement.UserProfileDataManagement.SetUserMediaItemData(userProfileDataManagement.CurrentUser.ProfileId, mediaItem.MediaItemId,
UserDataKeysKnown.KEY_PLAY_COUNT, currentPlayCount.ToString());
}
}
ContentDirectoryMessaging.SendMediaItemChangedMessage(mediaItem, ContentDirectoryMessaging.MediaItemChangeType.Updated);
}
protected static async Task NotifyPlayback(MediaItem mediaItem, int playPercentage, double playDuration)
{
ISettingsManager settingsManager = ServiceRegistration.Get <ISettingsManager>();
PlayerManagerSettings settings = settingsManager.Load <PlayerManagerSettings>();
bool watched = playPercentage >= settings.WatchedPlayPercentage;
if (watched && mediaItem.IsLastPart)
{
playPercentage = 100;
}
else if (watched && !mediaItem.IsLastPart)
{
playPercentage = 50;
}
IServerConnectionManager scm = ServiceRegistration.Get <IServerConnectionManager>();
IContentDirectory cd = scm.ContentDirectory;
if (cd != null)
{
IUserManagement userProfileDataManagement = ServiceRegistration.Get <IUserManagement>();
if (userProfileDataManagement.IsValidUser)
{
bool updatePlayDate = (watched || playDuration >= MINIMUM_WATCHED_SEC || playPercentage >= MINIMUM_WATCHED_PERCENT);
await cd.NotifyUserPlaybackAsync(userProfileDataManagement.CurrentUser.ProfileId, mediaItem.MediaItemId, playPercentage, updatePlayDate);
}
else
{
await cd.NotifyPlaybackAsync(mediaItem.MediaItemId, watched);
}
}
// Update loaded item also, so changes will be visible in GUI without reloading
if (!mediaItem.UserData.ContainsKey(UserDataKeysKnown.KEY_PLAY_PERCENTAGE))
{
mediaItem.UserData.Add(UserDataKeysKnown.KEY_PLAY_PERCENTAGE, "0");
}
mediaItem.UserData[UserDataKeysKnown.KEY_PLAY_PERCENTAGE] = UserDataKeysKnown.GetSortablePlayPercentageString(playPercentage);
if (watched)
{
// Update loaded item also, so changes will be visible in GUI without reloading
int currentPlayCount;
if (MediaItemAspect.TryGetAttribute(mediaItem.Aspects, MediaAspect.ATTR_PLAYCOUNT, 0, out currentPlayCount))
{
MediaItemAspect.SetAttribute(mediaItem.Aspects, MediaAspect.ATTR_PLAYCOUNT, ++currentPlayCount);
}
if (!mediaItem.UserData.ContainsKey(UserDataKeysKnown.KEY_PLAY_COUNT))
{
mediaItem.UserData.Add(UserDataKeysKnown.KEY_PLAY_COUNT, UserDataKeysKnown.GetSortablePlayCountString(0));
}
currentPlayCount = Convert.ToInt32(mediaItem.UserData[UserDataKeysKnown.KEY_PLAY_COUNT]);
currentPlayCount++;
mediaItem.UserData[UserDataKeysKnown.KEY_PLAY_COUNT] = UserDataKeysKnown.GetSortablePlayCountString(currentPlayCount);
}
ContentDirectoryMessaging.SendMediaItemChangedMessage(mediaItem, ContentDirectoryMessaging.MediaItemChangeType.Updated);
}
/// <summary>
/// This method maintains the content directory's last importing shares state and generates the appropriate content directory messages.
/// </summary>
void UpdateCurrentlyImportingShares(ICollection<Guid> currentlyImportingShares)
{
if (currentlyImportingShares == null)
currentlyImportingShares = new List<Guid>();
ICollection<Guid> oldImportingShares = _currentlyImportingSharesProxy;
ICollection<Guid> newImportingShares = currentlyImportingShares;
_currentlyImportingSharesProxy = newImportingShares;
foreach (Guid importingShare in newImportingShares.Where(importingShare => !oldImportingShares.Contains(importingShare)))
ContentDirectoryMessaging.SendShareImportMessage(ContentDirectoryMessaging.MessageType.ShareImportStarted, importingShare);
foreach (Guid oldShare in oldImportingShares.Where(oldShare => !newImportingShares.Contains(oldShare)))
ContentDirectoryMessaging.SendShareImportMessage(ContentDirectoryMessaging.MessageType.ShareImportCompleted, oldShare);
}
protected void InvokeAction(IMediaItemAction action, MediaItem mediaItem)
{
try
{
ContentDirectoryMessaging.MediaItemChangeType changeType;
if (action.Process(mediaItem, out changeType) && changeType != ContentDirectoryMessaging.MediaItemChangeType.None)
{
ContentDirectoryMessaging.SendMediaItemChangedMessage(mediaItem, changeType);
}
}
catch (Exception ex)
{
ServiceRegistration.Get <ILogger>().Error("Error executing MediaItemAction '{0}':", ex, action.GetType());
}
}
private async Task InvokeInternal(IMediaItemAction action, MediaItem mediaItem)
{
try
{
var result = await action.ProcessAsync(mediaItem);
if (result.Success && result.Result != ContentDirectoryMessaging.MediaItemChangeType.None)
{
ContentDirectoryMessaging.SendMediaItemChangedMessage(mediaItem, result.Result);
}
}
catch (Exception ex)
{
ServiceRegistration.Get <ILogger>().Error("Error executing MediaItemAction '{0}':", ex, action.GetType());
}
}
public override async Task <bool> ProcessAsync(ListItem item)
{
IMediaItemListItem mediaItem = item as IMediaItemListItem;
if (mediaItem != null)
{
var result = await _action.ProcessAsync(mediaItem.MediaItem);
if (result.Success)
{
if (result.Result != ContentDirectoryMessaging.MediaItemChangeType.None)
{
ContentDirectoryMessaging.SendMediaItemChangedMessage(mediaItem.MediaItem, result.Result);
}
return(true);
}
}
return(false);
}
private static void NotifyPlayback(MediaItem mediaItem)
{
IServerConnectionManager scm = ServiceRegistration.Get <IServerConnectionManager>();
IContentDirectory cd = scm.ContentDirectory;
// Server will update the PlayCount of MediaAspect in ML, this does not affect loaded items.
if (cd != null)
{
cd.NotifyPlayback(mediaItem.MediaItemId);
}
// Update loaded item also, so changes will be visible in GUI without reloading
int currentPlayCount;
if (MediaItemAspect.TryGetAttribute(mediaItem.Aspects, MediaAspect.ATTR_PLAYCOUNT, 0, out currentPlayCount))
{
MediaItemAspect.SetAttribute(mediaItem.Aspects, MediaAspect.ATTR_PLAYCOUNT, ++currentPlayCount);
ContentDirectoryMessaging.SendMediaItemChangedMessage(mediaItem, ContentDirectoryMessaging.MediaItemChangeType.Updated);
}
}
static void OnRegisteredSharesChangeCounterChanged()
{
ContentDirectoryMessaging.SendRegisteredSharesChangedMessage();
}
static void OnContentDirectoryMIATypeRegistrationsChanged()
{
ContentDirectoryMessaging.SendMIATypesChangedMessage();
}
static void OnContentDirectoryPlaylistsChanged()
{
ContentDirectoryMessaging.SendPlaylistsChangedMessage();
}
