public override bool TrySave(out MediaItem savedMediaItem, out string message)
{
EnsureChildControls();
if (_fileFileUpload.HasFile)
{
try
{
savedMediaItem = _provider.CreateMediaItem(_fileFileUpload.FileContent, _fileFileUpload.FileName, _fileFileUpload.PostedFile.ContentType, _collectionsDropDownList.SelectedValue);
message = "File created successfully";
return true;
}
catch (Exception e)
{
savedMediaItem = null;
message = "An error occured creating the media item: " + e.Message;
return false;
}
}
else
{
savedMediaItem = null;
message = "No file selected";
return false;
}
}
public static void ConvertMediaItemToFile(MediaItem mediaItem, string fileName)
{
Assert.ArgumentNotNull(mediaItem, "mediaItem");
if (mediaItem.InnerItem["file path"].Length > 0)
return;
// Have to use "blob" field in order to workaround an issue with mediaItem.GetStream()
// as it uses mediaItem.FileBased property that returns "true" if at least one version has a file based media asset.
var blobField = mediaItem.InnerItem.Fields["blob"];
Stream stream = blobField.GetBlobStream();
if (stream == null)
{
//Log.Warn(string.Format("Cannot find media data at item '{0}'", mediaItem.MediaPath), typeof(MediaStorageManager));
return;
}
//string fileName = GetFilename(mediaItem, stream);
string relativePath = Sitecore.IO.FileUtil.UnmapPath(fileName);
try
{
SaveToFile(stream, fileName);
stream.Flush();
stream.Close();
}
catch (Exception)
{
//Log.Error(string.Format("Cannot convert BLOB stream of '{0}' media item to '{1}' file", mediaItem.MediaPath, relativePath), ex, typeof(MediaStorageManager));
}
}
public ImageItem(MediaItem mediaItem) : base(mediaItem)
{
MediaItemAspect imageAspect;
if (mediaItem.Aspects.TryGetValue(ImageAspect.ASPECT_ID, out imageAspect))
{
SimpleTitle = Title;
int? width = (int?) imageAspect[ImageAspect.ATTR_WIDTH];
int? height = (int?) imageAspect[ImageAspect.ATTR_HEIGHT];
if (width.HasValue && width.Value > 0 && height.HasValue && height.Value > 0)
{
Width = width;
Height = height;
Size = width + " x " + height;
}
}
MediaItemAspect resourceAspect;
if (mediaItem.Aspects.TryGetValue(ProviderResourceAspect.ASPECT_ID, out resourceAspect))
{
ResourcePath rp = ResourcePath.Deserialize((string) resourceAspect[ProviderResourceAspect.ATTR_RESOURCE_ACCESSOR_PATH]);
string ext = ProviderPathHelper.GetExtension(rp.FileName);
if (ext.Length > 1)
// remove leading '.'
ext = ext.Substring(1);
Extension = ext;
}
MediaItemAspect mediaAspect;
if (mediaItem.Aspects.TryGetValue(MediaAspect.ASPECT_ID, out mediaAspect))
{
MimeType = (string) mediaAspect[MediaAspect.ATTR_MIME_TYPE];
}
}
public static bool ConvertWave2Wma(string waveFilePath, string artist, string title, string genre, int year, out string exceptionMessage)
{
//encode
MediaItem albumItem;
try
{
string jobFilePath = waveFilePath.Replace(".wav", "-job.xej");
StreamReader reader = new StreamReader(Assembly.GetExecutingAssembly().GetManifestResourceStream("AudioConverter.ExpressionEncoderJob.xej"));
File.WriteAllText(jobFilePath, reader.ReadToEnd());
reader.Close();
Job job = Job.LoadJob(jobFilePath);
string presetFilePath = waveFilePath.Replace(".wav", "-presets.xml");
WritePresetFile(presetFilePath, artist, title, genre, year);
job.MediaItems.Clear();
albumItem = new MediaItem(waveFilePath);
job.MediaItems.Add(albumItem);
job.ApplyPreset(Preset.FromFile(presetFilePath));
job.Encode();
exceptionMessage = null;
return true;
}
catch (Exception ex)
{
exceptionMessage = ex.Message;
return false;
}
}
public override bool Process(MediaItem mediaItem, out ContentDirectoryMessaging.MediaItemChangeType changeType)
{
changeType = ContentDirectoryMessaging.MediaItemChangeType.None;
var rl = mediaItem.GetResourceLocator();
using (var ra = rl.CreateAccessor())
{
var rad = ra as IResourceDeletor;
if (rad == null)
return false;
// First try to delete the file from storage.
if (rad.Delete())
{
changeType = ContentDirectoryMessaging.MediaItemChangeType.Deleted;
// If the MediaItem was loaded from ML, remove it there as well.
if (IsManagedByMediaLibrary(mediaItem))
{
IContentDirectory cd = ServiceRegistration.Get<IServerConnectionManager>().ContentDirectory;
if (cd == null)
return true;
cd.DeleteMediaItemOrPath(rl.NativeSystemId, rl.NativeResourcePath, true);
return true;
}
}
}
return false;
}
public static HtmlString RenderParallaxMediaAttributes(this Item item)
{
var targetItem = item.TargetItem(Templates.HasParallaxBackground.Fields.BackgroundMedia);
var targetMedia = new MediaItem(targetItem);
var attributeDictionary = new Dictionary<string, string>();
var mimeType = targetMedia.MimeType.Split('/');
var mediaType = mimeType[0];
var mediaFormat = mimeType[1];
attributeDictionary["type"] = mediaType;
if (mediaType == "video")
attributeDictionary["format"] = mediaFormat;
attributeDictionary[mediaType == "video" ? $"url-{mediaFormat}" : "url"] = item.MediaUrl(Templates.HasParallaxBackground.Fields.BackgroundMedia);
var checkboxField = (Sitecore.Data.Fields.CheckboxField)item.Fields[Templates.HasParallaxBackground.Fields.IsParallaxEnabled];
attributeDictionary["attachment"] = checkboxField.Checked ? "parallax" : "static";
if (checkboxField.Checked)
{
attributeDictionary["parallaxspeed"] = item.Fields[Templates.HasParallaxBackground.Fields.ParallaxSpeed].Value;
}
var attributes = attributeDictionary.Select(x => $"data-multibackground-layer-0-{x.Key}='{x.Value}'").ToList();
attributes.Add("data-multibackground");
return new HtmlString(string.Join(" ", attributes));
}
private static string ConfigureProfile(DlnaForthField dlnaField, MediaItem item, string mediaType)
{
//TODO: much better type resolution
switch(mediaType)
{
case MediaLibraryHelper.MIMETYPE_AUDIO:
dlnaField.ProfileParameter.ProfileName = DlnaProfiles.Mp3;
dlnaField.FlagsParameter.StreamingMode = true;
dlnaField.FlagsParameter.InteractiveMode = false;
dlnaField.FlagsParameter.BackgroundMode = true;
break;
case MediaLibraryHelper.MIMETYPE_VIDEO:
dlnaField.ProfileParameter.ProfileName = DlnaProfiles.MpegPsPal;
dlnaField.FlagsParameter.StreamingMode = true;
dlnaField.FlagsParameter.InteractiveMode = false;
dlnaField.FlagsParameter.BackgroundMode = true;
break;
case MediaLibraryHelper.MIMETYPE_IMAGE:
dlnaField.ProfileParameter.ProfileName = DlnaProfiles.JpegLarge;
dlnaField.FlagsParameter.StreamingMode = false;
dlnaField.FlagsParameter.InteractiveMode = true;
dlnaField.FlagsParameter.BackgroundMode = true;
break;
}
return null;
}
/// <summary>
/// Gets the media URL.
/// </summary>
/// <param name="itemid">The item ID</param>
/// <returns>MediaUrl of item</returns>
public static string GetVideoExtension(this string itemid)
{
if (!string.IsNullOrEmpty(itemid))
{
Guid guidOutput = new Guid();
bool isValid = Guid.TryParse(itemid, out guidOutput);
if (isValid)
{
Item sourceItem = DatabaseUtilities.ContentOrContextDatabase.GetItem(new ID(itemid));
if (sourceItem != null)
{
MediaItem mediaItem = new MediaItem(sourceItem);
return mediaItem.Extension;
}
return itemid;
}
else
{
string[] items = itemid.Split('.');
return items.LastOrDefault();
}
}
return string.Empty;
}
public override int Compare(MediaItem item1, MediaItem item2)
{
MediaItemAspect seriesAspectX;
MediaItemAspect seriesAspectY;
if (item1.Aspects.TryGetValue(SeriesAspect.ASPECT_ID, out seriesAspectX) && item2.Aspects.TryGetValue(SeriesAspect.ASPECT_ID, out seriesAspectY))
{
int seasonX = (int) (seriesAspectX.GetAttributeValue(SeriesAspect.ATTR_SEASON) ?? 0);
int seasonY = (int) (seriesAspectY.GetAttributeValue(SeriesAspect.ATTR_SEASON) ?? 0);
int seasonRes = seasonX.CompareTo(seasonY);
if (seasonRes != 0)
return seasonRes;
IEnumerable<int> episodesX = seriesAspectX.GetCollectionAttribute<int>(SeriesAspect.ATTR_EPISODE);
IEnumerable<int> episodesY = seriesAspectY.GetCollectionAttribute<int>(SeriesAspect.ATTR_EPISODE);
int episodeX = 0;
int episodeY = 0;
if (episodesX != null)
episodeX = episodesX.FirstOrDefault();
if (episodesY != null)
episodeY = episodesY.FirstOrDefault();
int episodeRes = episodeX.CompareTo(episodeY);
if (episodeRes != 0)
return episodeRes;
}
return base.Compare(item1, item2);
}
/// <summary>
/// Gets a media URL.
/// </summary>
/// <param name="item">The media item.</param>
/// <param name="options">The query string.</param>
/// <returns>
/// The media URL.
/// </returns>
public override string GetMediaUrl(MediaItem item, MediaUrlOptions options)
{
Assert.ArgumentNotNull(item, "item");
Assert.ArgumentNotNull(options, "options");
var flag = options.Thumbnail || HasMediaContent(item);
if (!flag && item.InnerItem["path"].Length > 0)
{
if (!options.LowercaseUrls)
return item.InnerItem["path"];
return item.InnerItem["path"].ToLowerInvariant();
}
if (options.UseDefaultIcon && !flag)
{
return !options.LowercaseUrls ? Themes.MapTheme(Settings.DefaultIcon) : Themes.MapTheme(Settings.DefaultIcon).ToLowerInvariant();
}
Assert.IsTrue(Config.MediaPrefixes[0].Length > 0, "media prefixes are not configured properly.");
var str1 = MediaLinkPrefix;
if (options.AbsolutePath)
str1 = options.VirtualFolder + str1;
else if (str1.StartsWith("/", StringComparison.InvariantCulture))
str1 = StringUtil.Mid(str1, 1);
var part2 = MainUtil.EncodePath(str1, '/');
if (options.AlwaysIncludeServerUrl)
part2 = FileUtil.MakePath(string.IsNullOrEmpty(options.MediaLinkServerUrl) ? WebUtil.GetServerUrl() : options.MediaLinkServerUrl, part2, '/');
var str2 = StringUtil.EnsurePrefix('.', StringUtil.GetString(options.RequestExtension, item.Extension, "ashx"));
var str3 = options.ToString();
if (str3.Length > 0)
str2 = str2 + "?" + str3;
const string str4 = "/sitecore/media library/";
var path = item.InnerItem.Paths.Path;
var str5 = MainUtil.EncodePath(!options.UseItemPath || !path.StartsWith(str4, StringComparison.OrdinalIgnoreCase) ? item.ID.ToShortID().ToString() : StringUtil.Mid(path, str4.Length), '/');
var str6 = part2 + str5 + (options.IncludeExtension ? str2 : string.Empty);
return !options.LowercaseUrls ? str6 : str6.ToLowerInvariant();
}
private MediaItem UploadMediaItemToAlbum(MediaItem mediaItem, string albumPath)
{
string relativeUploadUrl = GenerateRelativeUploadUrl( albumPath );
QueryParameterList paramaters = new QueryParameterList();
paramaters.Add( new QueryParameter( _format, "xml" ) );
paramaters.Add( new QueryParameter( _type, mediaItem.Type ) );
if (string.IsNullOrEmpty( mediaItem.Description ) == false)
{
paramaters.Add( new QueryParameter( _description, OAuth.UrlEncode(mediaItem.Description) ) );
}
if (string.IsNullOrEmpty( mediaItem.Title ) == false)
{
paramaters.Add( new QueryParameter( _title, OAuth.UrlEncode(mediaItem.Title) ) );
}
QueryParameterList mediaParamaters = OAuth.GenerateOAuthParamaters( relativeUploadUrl, _uploadMediaMethod, Token, paramaters );
string uploadMediaItemUrl = ApiUrl + relativeUploadUrl + "?format=xml";
XmlResponseMessage uploadMediaItemResponse = GetResponseForUploadMediaItem( uploadMediaItemUrl, mediaItem, mediaParamaters );
MediaItem newMediaItem = new MediaItem( uploadMediaItemResponse.ResponseXml );
_currentUser.MediaList.Add(newMediaItem);
return newMediaItem;
}
protected override String getKey(MediaItem item)
{
String key = "";
if (item is YoutubeVideoItem)
{
YoutubeVideoItem videoItem = item as YoutubeVideoItem;
YoutubeItemMetadata metadata = item.Metadata as YoutubeItemMetadata;
if (metadata.Height >= 2160)
{
key += "4";
}
else if (metadata.Height >= 1080)
{
key += "0";
}
if (videoItem.IsEmbeddedOnly || !videoItem.HasPlayableStreams)
{
key += "1";
}
}
else if (item is YoutubeChannelItem)
{
key += "2";
}
else if (item is YoutubePlaylistItem)
{
key += "3";
}
return key;
}
private static byte[] AutoRotateThumb(MediaItem mediaItem, byte[] textureData)
{
ImageRotation miRotation;
bool flipX;
bool flipY;
if (ImageAspect.GetOrientationMetadata(mediaItem, out miRotation, out flipX, out flipY) && (miRotation != ImageRotation.Rot_0))
{
try
{
using (MemoryStream rotatedStream = new MemoryStream())
using (MemoryStream inputStream = new MemoryStream(textureData))
using (Image bitmap = Image.FromStream(inputStream))
{
if (miRotation == ImageRotation.Rot_180)
bitmap.RotateFlip(RotateFlipType.Rotate180FlipNone);
if (miRotation == ImageRotation.Rot_90)
bitmap.RotateFlip(RotateFlipType.Rotate90FlipNone);
if (miRotation == ImageRotation.Rot_270)
bitmap.RotateFlip(RotateFlipType.Rotate270FlipNone);
bitmap.Save(rotatedStream, ImageFormat.Jpeg);
textureData = rotatedStream.ToArray();
}
}
catch (Exception)
{
}
}
return textureData;
}
/// <summary>
/// Constructs a <see cref="BinaryTextureImageSource"/> for thumbnails of the given size from MediaItems.
/// </summary>
/// <param name="mediaItem">MediaItem to create thumbnail for.</param>
/// <param name="thumbnailSize">Requested thumbnail size.</param>
public static BinaryTextureImageSource CreateThumbnailImageSource(MediaItem mediaItem, int thumbnailSize)
{
Guid id = mediaItem.MediaItemId;
// Local media items don't have an item id
string key = (id == Guid.Empty ? Guid.NewGuid() : id).ToString();
byte[] textureData = null;
// Each resolution is cached separately. If we read cache only and our favourite resolution is not yet in cache,
// we try to find any other existing.
if (thumbnailSize <= 96)
{
if (mediaItem.Aspects.ContainsKey(ThumbnailSmallAspect.ASPECT_ID))
textureData = (byte[]) mediaItem.Aspects[ThumbnailSmallAspect.ASPECT_ID].GetAttributeValue(ThumbnailSmallAspect.ATTR_THUMBNAIL);
if (textureData == null && mediaItem.Aspects.ContainsKey(ThumbnailLargeAspect.ASPECT_ID))
textureData = (byte[]) mediaItem.Aspects[ThumbnailLargeAspect.ASPECT_ID].GetAttributeValue(ThumbnailLargeAspect.ATTR_THUMBNAIL);
}
else
{
if (mediaItem.Aspects.ContainsKey(ThumbnailLargeAspect.ASPECT_ID))
textureData = (byte[]) mediaItem.Aspects[ThumbnailLargeAspect.ASPECT_ID].GetAttributeValue(ThumbnailLargeAspect.ATTR_THUMBNAIL);
if (textureData == null && mediaItem.Aspects.ContainsKey(ThumbnailSmallAspect.ASPECT_ID))
textureData = (byte[]) mediaItem.Aspects[ThumbnailSmallAspect.ASPECT_ID].GetAttributeValue(ThumbnailSmallAspect.ATTR_THUMBNAIL);
}
ImageRotation miRotation;
bool flipX;
bool flipY;
ImageAspect.GetOrientationMetadata(mediaItem, out miRotation, out flipX, out flipY);
RightAngledRotation rotation = RotationTranslator.TranslateToRightAngledRotation(miRotation);
return new BinaryTextureImageSource(textureData, rotation, key);
}
public override string GetMediaUrl(MediaItem item, MediaUrlOptions options)
{
string mediaUrl = base.GetMediaUrl(item, options);
if (string.IsNullOrEmpty(mediaUrl)) return mediaUrl;
int versionNumber = item.InnerItem.Version.Number;
string langIsoCode = item.InnerItem.Language.CultureInfo.TwoLetterISOLanguageName;
string updatedDate = item.InnerItem.Statistics.Updated.ToString("s");
NameValueCollection parameters = new NameValueCollection
{
{"v", versionNumber.ToString()},
{"lang", langIsoCode},
{"modified", updatedDate}
};
if (options.AlwaysIncludeServerUrl)
{
UriBuilder uriBuilder = new UriBuilder(mediaUrl);
NameValueCollection queryString = HttpUtility.ParseQueryString(uriBuilder.Query);
queryString.Add(parameters);
uriBuilder.Query = ToQueryString(queryString);
return uriBuilder.ToString();
}
StringBuilder sb = new StringBuilder(mediaUrl);
string seperator = "?";
if (mediaUrl.Contains(seperator)) seperator = "&";
foreach (string key in parameters.Keys)
{
sb.AppendFormat("{0}{1}={2}", seperator, key, parameters[key]);
seperator = "&";
}
return sb.ToString();
}
private static File GetFromXml(XmlNode node)
{
var mediaId = GetAttribute(node, "mediaid");
var src = GetAttribute(node, "src");
var file = new File
{
MediaId = mediaId,
Source = src
};
if (string.IsNullOrEmpty(file.MediaId))
{
return file;
}
var mediaItemFromMediaId = DatabaseRepository.GetActiveDatabase().GetItem(file.MediaId);
if (mediaItemFromMediaId == null)
{
return file;
}
var mediaItem = new MediaItem(mediaItemFromMediaId);
file.Title = string.IsNullOrEmpty(mediaItem.Title)
? mediaItem.DisplayName
: mediaItem.Title;
file.Extension = mediaItem.Extension;
file.FileSize = mediaItem.Size;
return file;
}
protected override String getKey(MediaItem item)
{
String key = "";
if (item.Metadata != null)
{
if (item.Metadata.IsImported)
{
key += '0';
}
if (!item.Metadata.SupportsXMPMetadata)
{
key += '1';
}
}
if (item.HasTags)
{
key += '2';
}
if (item.HasGeoTag)
{
key += '3';
}
if (item.IsReadOnly)
{
key += '4';
}
return (key);
}
/// <summary>
/// Gets the media URL.
/// </summary>
/// <param name="item">The item.</param>
/// <param name="mediaUrlOptions">The media URL options.</param>
/// <returns></returns>
public override string GetMediaUrl(MediaItem item, MediaUrlOptions mediaUrlOptions)
{
Assert.ArgumentNotNull(item, "item");
Assert.ArgumentNotNull(mediaUrlOptions, "mediaUrlOptions");
//Return the standard image if any of the following conditions are met
if (!IsImage(item) || Context.Database == null || Context.Site.Name == "shell" || !Context.PageMode.IsNormal || !((Item)item).HasChildren)
return base.GetMediaUrl(item, mediaUrlOptions);
double pixelDensity = GetCookiePixelDensity();
if (pixelDensity <= 1)
return base.GetMediaUrl(item, mediaUrlOptions);
//Get the first child of the media item (It should be the retina version of the image)
Item retinaItem = ((Item)item).Children.FirstOrDefault();
//Return the standard image if width and height are not set on the retina media items
if (retinaItem == null || String.IsNullOrEmpty(retinaItem["Width"]) || String.IsNullOrEmpty(retinaItem["Height"]))
return base.GetMediaUrl(item, mediaUrlOptions);
int retinaWidth = System.Convert.ToInt32(retinaItem["Width"]);
int retinaHeight = System.Convert.ToInt32(retinaItem["Height"]);
if (mediaUrlOptions.Width > 0 && mediaUrlOptions.Height > 0
&& retinaWidth >= (mediaUrlOptions.Width * pixelDensity) && retinaHeight >= (mediaUrlOptions.Height * pixelDensity))
{
mediaUrlOptions.Width = System.Convert.ToInt32(mediaUrlOptions.Width * pixelDensity);
mediaUrlOptions.Height = System.Convert.ToInt32(mediaUrlOptions.Height * pixelDensity);
//Return the retina version with width and height parameters adjusted accordingly
return base.GetMediaUrl(retinaItem, mediaUrlOptions);
}
//Return the retina version
return base.GetMediaUrl(retinaItem, mediaUrlOptions);
}
public static void EncodeVideo(FileInfo inputFile, FileInfo outputFile)
{
DirectoryInfo outDir = outputFile.Directory;
if (!outDir.Exists)
{
outDir.Create();
}
MediaItem mediaItem = new MediaItem(inputFile.FullName);
int bitrate = GetBitrate(mediaItem);
using (Job job = new Job())
{
job.OutputDirectory = outDir.FullName;
job.CreateSubfolder = false;
job.MediaItems.Add(mediaItem);
SetProfile(mediaItem);
// We can also use some of the presets. In that case comment the SetProfile line above for something like the one below:
// //H264VimeoSD preset settings: Output Format: MP4. Container: MP4. Video Codec: H.264 - Main.
// //Video size: 640, 480. Video Bitrate: 2500 Kbps. Video Encoding: CBR SinglePass.
// //Audio Codec: AAC. Audio Channels: Stereo. Audio Bitrate: 128 Kbps. Audio Encoding: CBR Single Pass
// job.ApplyPreset(Presets.H264VimeoSD);
job.Encode();
}
if (!outputFile.FullName.Equals(mediaItem.ActualOutputFileFullPath, StringComparison.InvariantCultureIgnoreCase))
{
throw new Exception(String.Format("The output file specified: '{0}' does not match the actual output file '{1}'", outputFile.FullName, mediaItem.ActualOutputFileFullPath));
}
}
/// <summary>
/// Loads selected item parameters into the selector.
/// </summary>
/// <param name="properties">Name-value collection representing item to load</param>
/// <param name="hideLinkText">Indicates if link text textbox shoul be hidden</param>
public void LoadSelectedItem(Hashtable properties, bool hideLinkText)
{
if ((properties != null) && (properties.Count > 0))
{
if (!IsBB)
{
if (hideLinkText)
{
propLinkProperties.LoadItemProperties(properties);
}
else
{
MediaItem mi = new MediaItem();
mi.Url = properties[DialogParameters.LINK_URL].ToString();
if ((properties[DialogParameters.LINK_TEXT] == null) || (String.IsNullOrEmpty(properties[DialogParameters.LINK_TEXT].ToString())))
{
mi.Name = properties[DialogParameters.LINK_NAME].ToString();
}
else
{
mi.Name = properties[DialogParameters.LINK_TEXT].ToString();
}
propLinkProperties.LoadSelectedItems(mi, properties);
}
}
urlSelectElem.LinkTextEnabled = !hideLinkText;
string url = ValidationHelper.GetString(properties[DialogParameters.LINK_URL], "");
urlSelectElem.LinkURL = URLHelper.RemoveProtocol(url);
urlSelectElem.LinkText = ValidationHelper.GetString(properties[DialogParameters.LINK_TEXT], "");
urlSelectElem.LinkProtocol = ValidationHelper.GetString(properties[DialogParameters.LINK_PROTOCOL], "http://");
}
}
/// <summary>
/// We require the command line parameters for the web browser host
/// Util should be an implementation of IBrowserSiteUtil
/// </summary>
/// <param name="mediaItem"></param>
public void Prepare(MediaItem mediaItem)
{
bool useIE = false;
string siteName;
SiteUtilBase util;
if (!MediaItemAspect.TryGetAttribute(mediaItem.Aspects, OnlineVideosAspect.ATTR_SITEUTIL, out siteName) || !OnlineVideoSettings.Instance.SiteUtilsList.TryGetValue(siteName, out util))
{
throw new ArgumentException("Could not determine used site util, can't start playback!");
}
var browserConfig = util as IBrowserSiteUtil;
if (browserConfig != null)
{
_automationType = browserConfig.ConnectorEntityTypeName;
_username = browserConfig.UserName;
_password = browserConfig.Password;
}
var emulationSite = util as IBrowserVersionEmulation;
if (emulationSite != null)
{
_emulationLevel = emulationSite.EmulatedVersion;
useIE = _emulationLevel > 10000;
}
_lastError = string.Empty;
_callback.OnBrowserClosing += _callback_OnBrowserHostClosing;
_callback.OnBrowserKeyPress += _callback_OnBrowserKeyPress;
var processName = useIE ? HOST_PROCESS_NAME_IE : HOST_PROCESS_NAME;
_processPath = Path.Combine(Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location), processName + ".exe");
GetRunningProcess(processName);
}
public List<WpPost> GetPosts(WpImportOptions options)
{
Item mediaInnerItem = _db.GetItem(_mediaItemId);
if (mediaInnerItem == null)
{
Logger.Error(String.Format("Media item for import could not be found (id: {0}, db: {1})", _mediaItemId, _db.Name));
return new List<WpPost>(0);
}
MediaItem mediaItem = new MediaItem(mediaInnerItem);
XmlDocument xmdDoc = new XmlDocument();
var mediaStream = MediaManager.GetMedia(mediaItem).GetStream();
if (mediaStream == null || mediaStream.MimeType != "text/xml")
{
Logger.Error(String.Format("MediaStream for imported item is null or uploaded file has is incorrect format (id: {0}, db: {1})", _mediaItemId, _db.Name));
return new List<WpPost>(0);
}
xmdDoc.Load(mediaStream.Stream);
using (var nodeReader = new XmlNodeReader(xmdDoc))
{
nodeReader.MoveToContent();
var xDocument = XDocument.Load(nodeReader);
var posts = (from item in xDocument.Descendants("item")
select new WpPost(item, options)).ToList();
return posts;
}
}
public IPlayer GetPlayer(MediaItem mediaItem)
{
string mimeType;
string title;
if (!mediaItem.GetPlayData(out mimeType, out title))
return null;
IResourceLocator locator = mediaItem.GetResourceLocator();
if (!ImagePlayer.CanPlay(locator, mimeType))
return null;
ImagePlayer player = new ImagePlayer();
try
{
if (!player.NextItem(mediaItem, StartTime.AtOnce))
{
player.Dispose();
return null;
}
}
catch (Exception e)
{
ServiceRegistration.Get<ILogger>().Warn("ImagePlayerBuilder: Error playing media item '{0}'", e, locator);
player.Dispose();
return null;
}
return player;
}
public static void GenerateThumbnail(FileInfo mediaFile, string thumbnailFilePath, int width, int height)
{
int thumbWidth = width;
int thumbHeight = height;
var video = new MediaItem(mediaFile.FullName);
var videoSize = video.MainMediaFile.VideoStreams[0].VideoSize;
if (videoSize.Width > videoSize.Height)
{
thumbHeight = Decimal.ToInt32(((Decimal)videoSize.Height / videoSize.Width) * thumbWidth);
if (thumbHeight > height)
{
thumbHeight = height;
}
}
else
{
thumbWidth = Decimal.ToInt32(((Decimal)videoSize.Width / videoSize.Height) * thumbHeight);
if (thumbWidth > width)
{
thumbWidth = width;
}
}
using (var bitmap = video.MainMediaFile.GetThumbnail(
new TimeSpan(0, 0, 5),
new System.Drawing.Size(thumbWidth, thumbHeight)))
{
bitmap.Save(thumbnailFilePath,ImageFormat.Jpeg);
}
}
public static bool IsValidVideo(MediaItem mediaItem)
{
if (mediaItem == null)
return false;
string mimeType;
return MediaItemAspect.TryGetAttribute(mediaItem.Aspects, MediaAspect.ATTR_MIME_TYPE, out mimeType) && mimeType.StartsWith("video/");
}
private static Image GetFromXml(XmlNode node)
{
var mediaId = GetAttribute(node, "mediaid");
var src = GetAttribute(node, "src");
var mediaPath = GetAttribute(node, "mediapath");
var alt = GetAttribute(node, "alt");
var width = GetAttribute(node, "width");
var height = GetAttribute(node, "height");
var vspace = GetAttribute(node, "vspace");
var hspace = GetAttribute(node, "hspace");
var image = new Image
{
MediaId = mediaId,
Source = src,
MediaPath = mediaPath,
AlternateText = alt
};
if (!string.IsNullOrEmpty(width))
{
image.Width = int.Parse(width);
}
if (!string.IsNullOrEmpty(height))
{
image.Height = int.Parse(height);
}
if (!string.IsNullOrEmpty(vspace))
{
image.VerticalSpace = int.Parse(vspace);
}
if (!string.IsNullOrEmpty(hspace))
{
image.HorisontalSpace = int.Parse(hspace);
}
if (string.IsNullOrEmpty(image.MediaId))
{
return image;
}
var mediaIdItem = DatabaseRepository.GetActiveDatabase().GetItem(image.MediaId);
if (mediaIdItem == null)
{
return image;
}
var mediaItem = new MediaItem(mediaIdItem);
image.Title = string.IsNullOrEmpty(mediaItem.Title)
? mediaItem.DisplayName
: mediaItem.Title;
image.Extension = mediaItem.Extension;
image.FileSize = mediaItem.Size;
if (string.IsNullOrEmpty(image.AlternateText))
{
image.AlternateText = mediaItem.Alt;
}
return image;
}
public MovieItem(MediaItem mediaItem) : base(mediaItem)
{
MediaItemAspect movieAspect;
if (!mediaItem.Aspects.TryGetValue(MovieAspect.ASPECT_ID, out movieAspect))
return;
MovieName = (string) movieAspect[MovieAspect.ATTR_MOVIE_NAME] ?? string.Empty;
}
/// <summary>
/// Tries to show actions for the given <paramref name="mediaItem"/>. This method can also be called from other models.
/// </summary>
/// <param name="mediaItem">MediaItem</param>
public void ShowMediaItemActions(MediaItem mediaItem)
{
IWorkflowManager workflowManager = ServiceRegistration.Get<IWorkflowManager>();
workflowManager.NavigatePush(Consts.WF_STATE_ID_CHECK_MEDIA_ITEM_ACTION, new NavigationContextConfig
{
AdditionalContextVariables = new Dictionary<string, object> { { KEY_MEDIA_ITEM, mediaItem } }
});
}
public override int Compare(MediaItem x, MediaItem y)
{
DateTime startTimeX;
DateTime startTimeY;
if (!MediaItemAspect.TryGetAttribute(x.Aspects, RecordingAspect.ATTR_STARTTIME, out startTimeX) || !MediaItemAspect.TryGetAttribute(y.Aspects, RecordingAspect.ATTR_STARTTIME, out startTimeY))
return base.Compare(x, y);
return -startTimeX.CompareTo(startTimeY);
}
public override bool Process(MediaItem mediaItem, out ContentDirectoryMessaging.MediaItemChangeType changeType)
{
changeType = ContentDirectoryMessaging.MediaItemChangeType.None;
WorkflowAction action;
if (!ServiceRegistration.Get<IWorkflowManager>().MenuStateActions.TryGetValue(ACTION_ID_ADD_ALL_TO_PLAYLIST, out action))
return false;
action.Execute();
return true;
}
private void StopAudio(MediaItem mediaItem)
{
_audioManager.StopAudio(mediaItem.Id);
}
private bool IsVideoOrAudio(MediaItem mediaItem)
{
return
(mediaItem.MediaType.Classification == MediaClassification.Audio ||
mediaItem.MediaType.Classification == MediaClassification.Video);
}
private void StartSlideshow(MediaItem mediaItem)
{
mediaItem.CurrentSlideshowIndex = 0;
_imageDisplayManager.StartSlideshow(mediaItem.FilePath, mediaItem.Id);
}
/// <summary>
/// Gets a list of <see cref="FanArtImage"/>s for a requested <paramref name="mediaType"/>, <paramref name="fanArtType"/> and <paramref name="name"/>.
/// The name can be: Series name, Actor name, Artist name depending on the <paramref name="mediaType"/>.
/// </summary>
/// <param name="mediaType">Requested FanArtMediaType</param>
/// <param name="fanArtType">Requested FanArtType</param>
/// <param name="name">Requested name of Series, Actor, Artist...</param>
/// <param name="maxWidth">Maximum width for image. <c>0</c> returns image in original size.</param>
/// <param name="maxHeight">Maximum height for image. <c>0</c> returns image in original size.</param>
/// <param name="singleRandom">If <c>true</c> only one random image URI will be returned</param>
/// <param name="result">Result if return code is <c>true</c>.</param>
/// <returns><c>true</c> if at least one match was found.</returns>
public bool TryGetFanArt(string mediaType, string fanArtType, string name, int maxWidth, int maxHeight, bool singleRandom, out IList <IResourceLocator> result)
{
result = null;
Guid mediaItemId;
if (mediaType != FanArtMediaTypes.Undefined)
{
return(false);
}
if (!Guid.TryParse(name, out mediaItemId))
{
return(false);
}
IMediaLibrary mediaLibrary = ServiceRegistration.Get <IMediaLibrary>(false);
if (mediaLibrary == null)
{
return(false);
}
IFilter filter = new MediaItemIdFilter(mediaItemId);
IList <MediaItem> items = null;
List <Guid> necessaryMias = new List <Guid>(NECESSARY_MIAS);
MediaItemQuery mediaQuery = new MediaItemQuery(necessaryMias, filter);
mediaQuery.Limit = 1;
items = mediaLibrary.Search(mediaQuery, false, null, false);
if (items == null || items.Count == 0)
{
return(false);
}
MediaItem mediaItem = items.First();
// Virtual resources won't have any local fanart
if (mediaItem.IsVirtual)
{
return(false);
}
var mediaIteamLocator = mediaItem.GetResourceLocator();
var fanArtPaths = new List <ResourcePath>();
var files = new List <IResourceLocator>();
// File based access
try
{
var mediaItemDirectoryPath = mediaIteamLocator.NativeResourcePath;
using (var directoryRa = new ResourceLocator(mediaIteamLocator.NativeSystemId, mediaItemDirectoryPath).CreateAccessor())
{
var directoryFsra = directoryRa as IFileSystemResourceAccessor;
if (directoryFsra != null)
{
var potentialFanArtFiles = LocalFanartHelper.GetPotentialFanArtFiles(directoryFsra);
if (fanArtType == FanArtTypes.Thumbnail)
{
fanArtPaths.AddRange(
from potentialFanArtFile in potentialFanArtFiles
let potentialFanArtFileNameWithoutExtension = ResourcePathHelper.GetFileNameWithoutExtension(potentialFanArtFile.ToString()).ToLowerInvariant()
where potentialFanArtFileNameWithoutExtension == "folder"
select potentialFanArtFile);
}
if (fanArtType == FanArtTypes.FanArt)
{
fanArtPaths.AddRange(
from potentialFanArtFile in potentialFanArtFiles
let potentialFanArtFileNameWithoutExtension = ResourcePathHelper.GetFileNameWithoutExtension(potentialFanArtFile.ToString()).ToLowerInvariant()
where potentialFanArtFileNameWithoutExtension == "backdrop" || potentialFanArtFileNameWithoutExtension == "fanart"
select potentialFanArtFile);
if (directoryFsra.ResourceExists("ExtraFanArt/"))
{
using (var extraFanArtDirectoryFsra = directoryFsra.GetResource("ExtraFanArt/"))
fanArtPaths.AddRange(LocalFanartHelper.GetPotentialFanArtFiles(extraFanArtDirectoryFsra));
}
}
files.AddRange(fanArtPaths.Select(path => new ResourceLocator(mediaIteamLocator.NativeSystemId, path)));
}
}
}
catch (Exception ex)
{
#if DEBUG
ServiceRegistration.Get <ILogger>().Warn("LocalContainerFanArtProvider: Error while searching fanart of type '{0}' for '{1}'", ex, fanArtType, mediaIteamLocator);
#endif
}
result = files;
return(files.Count > 0);
}
protected bool GetPattern(FanArtConstants.FanArtMediaType mediaType, FanArtConstants.FanArtType fanArtType, Guid mediaItemId, string name, out string[] patterns)
{
patterns = null;
string basePath = null;
if (mediaItemId != Guid.Empty)
{
IMediaLibrary mediaLibrary = ServiceRegistration.Get <IMediaLibrary>(false);
if (mediaLibrary == null)
{
return(false);
}
IFilter filter = new MediaItemIdFilter(mediaItemId);
IList <MediaItem> items = mediaLibrary.Search(new MediaItemQuery(NECESSARY_MIAS, filter), false);
if (items == null || items.Count == 0)
{
return(false);
}
MediaItem mediaItem = items.First();
int movieDbId;
if (MediaItemAspect.TryGetAttribute(mediaItem.Aspects, MovieAspect.ATTR_TMDB_ID, out movieDbId))
{
switch (mediaType)
{
case FanArtConstants.FanArtMediaType.Undefined:
case FanArtConstants.FanArtMediaType.Movie:
basePath = Path.Combine(MovieTheMovieDbMatcher.CACHE_PATH, movieDbId.ToString());
break;
}
}
}
else
{
switch (mediaType)
{
case FanArtConstants.FanArtMediaType.Undefined:
case FanArtConstants.FanArtMediaType.Movie:
int movieDbId;
basePath = !MovieTheMovieDbMatcher.Instance.TryGetMovieDbId(name, out movieDbId) ? null : Path.Combine(MovieTheMovieDbMatcher.CACHE_PATH, movieDbId.ToString());
break;
case FanArtConstants.FanArtMediaType.MovieCollection:
int collectionId;
basePath = !MovieTheMovieDbMatcher.Instance.TryGetCollectionId(name, out collectionId) ? null : Path.Combine(MovieTheMovieDbMatcher.CACHE_PATH, "COLL_" + collectionId);
break;
}
}
if (string.IsNullOrWhiteSpace(basePath))
{
return(false);
}
switch (fanArtType)
{
case FanArtConstants.FanArtType.Thumbnail:
case FanArtConstants.FanArtType.Poster:
patterns = new[] { Path.Combine(basePath, "Posters\\*.jpg") };
return(true);
case FanArtConstants.FanArtType.FanArt:
patterns = new[] { Path.Combine(basePath, "Backdrops\\*.jpg") };
return(true);
}
return(false);
}
/// <summary>
/// Main process method for the InnerBlock
/// </summary>
/// <remarks>
/// - SingleResources are just passed to the next DataflowBlock
/// - If it's not a SingleResource
/// - it finds all the files in the current directory,
/// - in case of a RefreshImport
/// - it deletes all the files in the MediaLibrary that do not exist anymore in the filesystem,
/// - it stores the DateOfLastImport of all the files in the <see cref="PendingImportResourceNewGen"/>
/// </remarks>
/// <param name="importResource"><see cref="PendingImportResourceNewGen"/> to be processed</param>
/// <returns>
/// a HashSet of <see cref="PendingImportResourceNewGen"/>s containing the current <see cref="PendingImportResource"/>
/// after processing as well as <see cref="PendingImportResourceNewGen"/>s for all files in the current directory
/// </returns>
private async Task <IEnumerable <PendingImportResourceNewGen> > ProcessDirectory(PendingImportResourceNewGen importResource)
{
var result = new HashSet <PendingImportResourceNewGen> {
importResource
};
try
{
ICollection <IFileSystemResourceAccessor> files;
ICollection <IFileSystemResourceAccessor> stubFiles = new HashSet <IFileSystemResourceAccessor>();
IDictionary <ResourcePath, DateTime> path2LastImportDate = new Dictionary <ResourcePath, DateTime>();
IDictionary <ResourcePath, Guid> path2MediaItem = new Dictionary <ResourcePath, Guid>();
IEnumerable <MediaItem> mediaItems = null;
if (importResource.IsSingleResource)
{
files = new HashSet <IFileSystemResourceAccessor> {
importResource.ResourceAccessor
};
MediaItem mi = await LoadLocalItem(importResource.PendingResourcePath, PROVIDERRESOURCE_IMPORTER_MIA_ID_ENUMERATION, null).ConfigureAwait(false);
if (mi != null)
{
mediaItems = new List <MediaItem>(new MediaItem[] { mi });
importResource.MediaItemId = mi.MediaItemId;
}
}
else
{
files = FileSystemResourceNavigator.GetFiles(importResource.ResourceAccessor, false, false) ?? new HashSet <IFileSystemResourceAccessor>();
SingleMediaItemAspect directoryAspect;
// ReSharper disable once PossibleInvalidOperationException
// TODO: Rework this
mediaItems = (await Browse(importResource.MediaItemId.Value, PROVIDERRESOURCE_IMPORTER_MIA_ID_ENUMERATION, DIRECTORY_MIA_ID_ENUMERATION).ConfigureAwait(false))
.Where(mi => !MediaItemAspect.TryGetAspect(mi.Aspects, DirectoryAspect.Metadata, out directoryAspect));
}
if (mediaItems != null)
{
foreach (MediaItem mi in mediaItems)
{
//Check metadata and files:
// 1. Last import date is lower than file change date => Refresh needed
// 2. Media item ID is empty => Reimport/import needed
// 3. Media item is dirty => Reimport/import needed
IList <MultipleMediaItemAspect> providerAspects = null;
if (MediaItemAspect.TryGetAspects(mi.Aspects, ProviderResourceAspect.Metadata, out providerAspects))
{
foreach (var pra in providerAspects)
{
bool isStub = pra.GetAttributeValue <int>(ProviderResourceAspect.ATTR_TYPE) == ProviderResourceAspect.TYPE_STUB;
ResourcePath path = ResourcePath.Deserialize(pra.GetAttributeValue <String>(ProviderResourceAspect.ATTR_RESOURCE_ACCESSOR_PATH));
if (!path2LastImportDate.ContainsKey(path) && importResource.PendingResourcePath.IsSameOrParentOf(path))
{
//If last refresh is equal to added date, it has never been through the refresh cycle, so set low last change date
//All media items must be added because the paths are later used to delete no longer existing media items
var lastImportDate = mi.Aspects[ImporterAspect.ASPECT_ID][0].GetAttributeValue <DateTime>(ImporterAspect.ATTR_LAST_IMPORT_DATE);
if (mi.Aspects[ImporterAspect.ASPECT_ID][0].GetAttributeValue <bool>(ImporterAspect.ATTR_DIRTY)) //If it is dirty, refresh is needed
{
path2LastImportDate.Add(path, DateTime.MinValue);
}
else
{
path2LastImportDate.Add(path, lastImportDate);
}
}
if (!importResource.IsSingleResource && !isStub && !path2MediaItem.ContainsKey(path))
{
path2MediaItem.Add(path, mi.MediaItemId);
}
// Stub items need their media item id because the do no have a unique path
// So add them now as long as the needed info is known
if (isStub)
{
IFileSystemResourceAccessor file = null;
try
{
IResourceAccessor ra;
if (path.TryCreateLocalResourceAccessor(out ra))
{
file = ra as IFileSystemResourceAccessor;
}
}
catch { }
// Only add it if it still exists
if (files.Where(f => file != null && f.CanonicalLocalResourcePath == file.CanonicalLocalResourcePath).Any())
{
stubFiles.Add(file);
DateTime dateTime;
PendingImportResourceNewGen pir = new PendingImportResourceNewGen(importResource.ResourceAccessor.CanonicalLocalResourcePath, file, ToString(),
ParentImportJobController, importResource.MediaItemId, mi.MediaItemId, true);
pir.ExistingAspects = mi.Aspects;
if (ImportJobInformation.JobType == ImportJobType.Refresh)
{
if (path2LastImportDate.TryGetValue(pir.PendingResourcePath, out dateTime))
{
pir.DateOfLastImport = dateTime;
}
}
result.Add(pir);
}
}
}
}
}
await DeleteNoLongerExistingFilesFromMediaLibrary(files, path2LastImportDate.Keys).ConfigureAwait(false);
}
//Add new stub items
foreach (var file in files.Where(f => !path2LastImportDate.Keys.Contains(f.CanonicalLocalResourcePath)))
{
if (await IsStubResource(file).ConfigureAwait(false))
{
stubFiles.Add(file);
DateTime dateTime;
var stubAspects = await ExtractStubItems(file).ConfigureAwait(false);
if (stubAspects != null)
{
foreach (var aspects in stubAspects)
{
PendingImportResourceNewGen pir = new PendingImportResourceNewGen(importResource.ResourceAccessor.CanonicalLocalResourcePath, file, ToString(),
ParentImportJobController, importResource.MediaItemId, null, true);
pir.ExistingAspects = aspects;
if (ImportJobInformation.JobType == ImportJobType.Refresh)
{
if (path2LastImportDate.TryGetValue(pir.PendingResourcePath, out dateTime))
{
pir.DateOfLastImport = dateTime;
}
}
result.Add(pir);
}
}
}
}
//Remove stub files from files collection so they don't get added again
foreach (IFileSystemResourceAccessor file in stubFiles)
{
IFileSystemResourceAccessor stub = files.Where(f => f.CanonicalLocalResourcePath == file.CanonicalLocalResourcePath).FirstOrDefault();
if (stub != null)
{
files.Remove(stub);
}
}
//Add importers for files if any
if (!importResource.IsSingleResource)
{
if (ImportJobInformation.JobType == ImportJobType.Import)
{
//Only import new files so only add non existing paths
result.UnionWith(files.Where(f => !path2LastImportDate.Keys.Contains(f.CanonicalLocalResourcePath)).
Select(f => new PendingImportResourceNewGen(importResource.ResourceAccessor.CanonicalLocalResourcePath, f, ToString(), ParentImportJobController, importResource.MediaItemId)));
}
else
{
result.UnionWith(files.Select(f => new PendingImportResourceNewGen(importResource.ResourceAccessor.CanonicalLocalResourcePath, f, ToString(), ParentImportJobController, importResource.MediaItemId,
path2MediaItem.ContainsKey(f.CanonicalLocalResourcePath) ? path2MediaItem[f.CanonicalLocalResourcePath] : (Guid?)null)));
}
}
// If this is a RefreshImport and we found files of the current directory in the MediaLibrary,
// store the DateOfLastImport in the PendingImportResource
if (ImportJobInformation.JobType == ImportJobType.Refresh)
{
DateTime dateTime;
if (path2LastImportDate != null)
{
foreach (var pir in result)
{
if (path2LastImportDate.TryGetValue(pir.PendingResourcePath, out dateTime))
{
pir.DateOfLastImport = dateTime;
}
}
}
}
return(result);
}
catch (TaskCanceledException)
{
return(result);
}
catch (Exception ex)
{
ServiceRegistration.Get <ILogger>().Warn("ImporterWorker.{0}.{1}: Error while processing {2}", ex, ParentImportJobController, ToString(), importResource);
importResource.IsValid = false;
return(result);
}
}
public override bool IsAvailable(MediaItem mediaItem)
{
return(!IsRecording(mediaItem) && IsResourceDeletor(mediaItem));
}
public static MvcHtmlString Media(this HtmlHelper helper, MediaItem media, double aspect, string cssClass = null)
{
return(Media(helper, media, null, aspect, cssClass));
}
public void OnImportsSatisfied()
{
ShellViewModel = new ShellViewModel(MediaFileWatcher.Instance, RegionManager, EventAggregator);
DataContext = ShellViewModel;
this.RegionManager.RegisterViewWithRegion(RegionNames.MainNavigationToolBarRegion, typeof(ImageNavigationItemView));
this.RegionManager.RegisterViewWithRegion(RegionNames.MainNavigationToolBarRegion, typeof(VideoNavigationItemView));
this.RegionManager.RegisterViewWithRegion(RegionNames.MainNavigationToolBarRegion, typeof(MediaFileBrowserNavigationItemView));
this.RegionManager.RegisterViewWithRegion(RegionNames.MainNavigationToolBarRegion, typeof(SettingsNavigationItemView));
EventAggregator.GetEvent <TitleChangedEvent>().Subscribe((title) =>
{
if (!String.IsNullOrEmpty(title))
{
this.Title = "MediaViewer - " + title;
}
else
{
this.Title = "MediaViewer";
}
}, ThreadOption.UIThread);
EventAggregator.GetEvent <ToggleFullScreenEvent>().Subscribe((isFullscreen) =>
{
if (isFullscreen)
{
prevWindowState = WindowState;
WindowState = System.Windows.WindowState.Maximized;
WindowStyle = System.Windows.WindowStyle.None;
toolBarPanel.Visibility = Visibility.Collapsed;
}
else
{
WindowState = prevWindowState;
WindowStyle = System.Windows.WindowStyle.SingleBorderWindow;
toolBarPanel.Visibility = Visibility.Visible;
}
}, ThreadOption.UIThread);
// initialize several settings
ServiceLocator.Current.GetInstance(typeof(DbSettingsViewModel));
ServiceLocator.Current.GetInstance(typeof(AboutViewModel));
try {
String location = App.Args.Count() > 0 ? FileUtils.getProperFilePathCapitalization(App.Args[0]) : "";
if (MediaViewer.Model.Utils.MediaFormatConvert.isImageFile(location))
{
MediaFileWatcher.Instance.Path = FileUtils.getPathWithoutFileName(location);
MediaItem item = MediaItemFactory.create(location);
ShellViewModel.navigateToImageView(item);
}
else if (MediaFormatConvert.isVideoFile(location))
{
MediaFileWatcher.Instance.Path = FileUtils.getPathWithoutFileName(location);
MediaItem item = MediaItemFactory.create(location);
ShellViewModel.navigateToVideoView(item);
}
else
{
ShellViewModel.navigateToMediaFileBrowser();
}
} catch (Exception e) {
Logger.Log.Error("Error in command line argument: " + App.Args[0], e);
ShellViewModel.navigateToMediaFileBrowser();
}
}
public static MvcHtmlString Media(this HtmlHelper helper, MediaItem media, string widthFactor = null, string cssClass = null)
{
return(Media(helper, media, widthFactor, SiteConfiguration.MediaHelper.DefaultMediaAspect, cssClass));
}
protected override ValidatorResult Evaluate()
{
int?maxWords = this.GetIntParam("MaxWords");
int?minWords = this.GetIntParam("MinWords");
int?minWarn = this.GetIntParam("MinWarn");
int?maxWarn = this.GetIntParam("MaxWarn");
if (minWarn == null && maxWarn == null && maxWords == null && minWords == null)
{
this.Text = Translate.Text("No thresholds defined for " + this.Name);
return(ValidatorResult.Warning);
}
if (string.IsNullOrEmpty(this.ControlValidationValue))
{
return(ValidatorResult.Valid);
}
XmlDocument doc = new XmlDocument();
doc.LoadXml(this.ControlValidationValue);
Item folder = Sitecore.Context.ContentDatabase.GetItem(
doc.DocumentElement.Attributes["mediaid"].Value);
if (folder == null || !folder.HasChildren)
{
return(ValidatorResult.Valid);
}
foreach (Item child in folder.Children)
{
MediaItem mediaItem = new MediaItem(child);
using (WordprocessingDocument document = WordprocessingDocument.Open(
mediaItem.GetMediaStream(),
false /*isEditable*/))
{
int words = int.Parse(
document.ExtendedFilePropertiesPart.Properties.Words.Text);
if (minWords != null && words < minWords)
{
this.Text = Translate.Text(
".docx should contain at least {0} words (currently {1}).",
MainUtil.FormatLong(minWords.Value),
MainUtil.FormatLong(words));
return(this.GetMaxValidatorResult());
}
if (maxWords != null && words > maxWords)
{
this.Text = Translate.Text(
".docx should contain less than {0} words (currently {1}).",
MainUtil.FormatLong(maxWords.Value),
MainUtil.FormatLong(words));
return(this.GetMaxValidatorResult());
}
if (minWarn != null && words > minWarn)
{
this.Text = Translate.Text(
".docx contains more than {0} words (currently {1}).",
MainUtil.FormatLong(minWarn.Value),
MainUtil.FormatLong(words));
return(ValidatorResult.Warning);
}
if (maxWarn == null || words < maxWarn)
{
continue;
}
this.Text = Translate.Text(
".docx file contains {0} words; approaching excessive length.",
MainUtil.FormatLong(words));
if (maxWords != null)
{
this.Text += " " + Translate.Text(
".docx cannot contain more than {0} words.",
MainUtil.FormatLong(maxWords.Value));
}
return(ValidatorResult.Warning);
}
}
return(ValidatorResult.Valid);
}
public override async Task <AsyncResult <ContentDirectoryMessaging.MediaItemChangeType> > ProcessAsync(MediaItem mediaItem)
{
// If the MediaItem was loaded from ML, remove it there as well.
if (IsManagedByMediaLibrary(mediaItem))
{
IContentDirectory cd = ServiceRegistration.Get <IServerConnectionManager>().ContentDirectory;
if (cd == null)
{
return(new AsyncResult <ContentDirectoryMessaging.MediaItemChangeType>(false, ContentDirectoryMessaging.MediaItemChangeType.None));
}
MediaItemMatchModel mimm = ServiceRegistration.Get <IWorkflowManager>().GetModel(MediaItemMatchModel.MODEL_ID_MIMATCH) as MediaItemMatchModel;
IEnumerable <MediaItemAspect> aspects = await mimm.OpenSelectMatchDialogAsync(mediaItem).ConfigureAwait(false);
if (aspects != null)
{
await cd.ReimportMediaItemMetadataAsync(mediaItem.MediaItemId, aspects);
//After refresh is completed on server a change message will be fired
return(new AsyncResult <ContentDirectoryMessaging.MediaItemChangeType>(true, ContentDirectoryMessaging.MediaItemChangeType.None));
}
}
return(new AsyncResult <ContentDirectoryMessaging.MediaItemChangeType>(false, ContentDirectoryMessaging.MediaItemChangeType.None));
}
public void SetMediaItem(IResourceLocator locator, string mediaItemTitle, MediaItem mediaItem)
{
_mediaItem = mediaItem;
// free previous opened resource
FilterGraphTools.TryDispose(ref _resourceAccessor);
FilterGraphTools.TryDispose(ref _rot);
_state = PlayerState.Active;
_isPaused = true;
try
{
_resourceLocator = locator;
_mediaItemTitle = mediaItemTitle;
CreateResourceAccessor();
// Create a DirectShow FilterGraph
CreateGraphBuilder();
// Add it in ROT (Running Object Table) for debug purpose, it allows to view the Graph from outside (i.e. graphedit)
_rot = new DsROTEntry(_graphBuilder);
// Add a notification handler (see WndProc)
_instancePtr = Marshal.AllocCoTaskMem(4);
IMediaEventEx mee = _graphBuilder as IMediaEventEx;
if (mee != null)
{
mee.SetNotifyWindow(SkinContext.Form.Handle, WM_GRAPHNOTIFY, _instancePtr);
}
// Create the Allocator / Presenter object
AddPresenter();
ServiceRegistration.Get <ILogger>().Debug("{0}: Adding audio renderer", PlayerTitle);
AddAudioRenderer();
ServiceRegistration.Get <ILogger>().Debug("{0}: Adding preferred codecs", PlayerTitle);
AddPreferredCodecs();
ServiceRegistration.Get <ILogger>().Debug("{0}: Adding source filter", PlayerTitle);
AddSourceFilter();
ServiceRegistration.Get <ILogger>().Debug("{0}: Adding subtitle filter", PlayerTitle);
AddSubtitleFilter(true);
ServiceRegistration.Get <ILogger>().Debug("{0}: Run graph", PlayerTitle);
//This needs to be done here before we check if the evr pins are connected
//since this method gives players the chance to render the last bits of the graph
OnBeforeGraphRunning();
// Now run the graph, i.e. the DVD player needs a running graph before getting informations from dvd filter.
IMediaControl mc = (IMediaControl)_graphBuilder;
int hr = mc.Run();
new HRESULT(hr).Throw();
_initialized = true;
OnGraphRunning();
}
catch (Exception)
{
Shutdown();
throw;
}
}
public override int Compare(MediaItem x, MediaItem y)
{
SingleMediaItemAspect aspectX;
SingleMediaItemAspect aspectY;
// Check audio
if (!MediaItemAspect.TryGetAspect(x.Aspects, AudioAspect.Metadata, out aspectX))
{
aspectX = null;
}
if (!MediaItemAspect.TryGetAspect(y.Aspects, AudioAspect.Metadata, out aspectY))
{
aspectY = null;
}
if (aspectX != null && aspectY != null)
{
// Both are audio items - compare to each other
return(_audioComparer.Compare(x, y));
}
if (aspectX != null || aspectY != null)
{
// One of them is an audio item - order that item first
return(CompareDifferentTypes(aspectX, aspectY));
}
// None of them is an audio item
// Check video
if (!MediaItemAspect.TryGetAspect(x.Aspects, VideoAspect.Metadata, out aspectX))
{
aspectX = null;
}
if (!MediaItemAspect.TryGetAspect(y.Aspects, VideoAspect.Metadata, out aspectY))
{
aspectY = null;
}
if (aspectX != null && aspectY != null)
{
// Both are vido items - compare to each other
return(_videoComparer.Compare(x, y));
}
if (aspectX != null || aspectY != null)
{
// One of them is a video item - order that item first
return(CompareDifferentTypes(aspectX, aspectY));
}
// None of them is a video item
// Check image
if (!MediaItemAspect.TryGetAspect(x.Aspects, ImageAspect.Metadata, out aspectX))
{
aspectX = null;
}
if (!MediaItemAspect.TryGetAspect(y.Aspects, ImageAspect.Metadata, out aspectY))
{
aspectY = null;
}
if (aspectX != null && aspectY != null)
{
// Both are image items - compare to each other
return(_imageComparer.Compare(x, y));
}
if (aspectX != null || aspectY != null)
{
// One of them is an image item - order that item first
return(CompareDifferentTypes(aspectX, aspectY));
}
// None of them is an image item
// Fallback
return(base.Compare(x, y));
}
protected static bool IsRecording(MediaItem mediaItem)
{
return(mediaItem.Aspects.ContainsKey(new Guid("8DB70262-0DCE-4C80-AD03-FB1CDF7E1913") /* RecordingAspect.ASPECT_ID*/));
}
public override object GetGroupByValue(MediaItem item)
{
return(null);
}
/// <summary>
/// Gets a list of <see cref="FanArtImage"/>s for a requested <paramref name="mediaType"/>, <paramref name="fanArtType"/> and <paramref name="name"/>.
/// The name can be: Series name, Actor name, Artist name depending on the <paramref name="mediaType"/>.
/// </summary>
/// <param name="mediaType">Requested FanArtMediaType</param>
/// <param name="fanArtType">Requested FanArtType</param>
/// <param name="name">Requested name of Series, Actor, Artist...</param>
/// <param name="maxWidth">Maximum width for image. <c>0</c> returns image in original size.</param>
/// <param name="maxHeight">Maximum height for image. <c>0</c> returns image in original size.</param>
/// <param name="singleRandom">If <c>true</c> only one random image URI will be returned</param>
/// <param name="result">Result if return code is <c>true</c>.</param>
/// <returns><c>true</c> if at least one match was found.</returns>
public bool TryGetFanArt(string mediaType, string fanArtType, string name, int maxWidth, int maxHeight, bool singleRandom, out IList <IResourceLocator> result)
{
result = null;
if (!VALID_MEDIA_TYPES.Contains(mediaType) || !VALID_FANART_TYPES.Contains(fanArtType))
{
return(false);
}
if (string.IsNullOrWhiteSpace(name))
{
return(false);
}
Guid mediaItemId;
if (Guid.TryParse(name, out mediaItemId) == false)
{
return(false);
}
IFanArtCache fanArtCache = ServiceRegistration.Get <IFanArtCache>();
List <string> fanArtFiles = new List <string>();
fanArtFiles.AddRange(fanArtCache.GetFanArtFiles(mediaItemId, fanArtType));
if (fanArtFiles.Count == 0 && fanArtType == FanArtTypes.Poster)
{
fanArtFiles.AddRange(fanArtCache.GetFanArtFiles(mediaItemId, FanArtTypes.Cover));
}
// Try fallback
if (fanArtFiles.Count == 0 && (mediaType == FanArtMediaTypes.Audio || mediaType == FanArtMediaTypes.Album))
{
IMediaLibrary mediaLibrary = ServiceRegistration.Get <IMediaLibrary>(false);
if (mediaLibrary == null)
{
return(false);
}
IFilter filter = new MediaItemIdFilter(mediaItemId);
IList <MediaItem> items = mediaLibrary.Search(new MediaItemQuery(NECESSARY_MIAS, OPTIONAL_MIAS, filter), false, null, true);
if (items == null || items.Count == 0)
{
return(false);
}
MediaItem mediaItem = items.First();
IList <MultipleMediaItemAspect> relationAspects;
if (mediaType == FanArtMediaTypes.Audio && fanArtType == FanArtTypes.FanArt)
{
//No FanArt exists for Audio so use Artists
if (MediaItemAspect.TryGetAspects(mediaItem.Aspects, RelationshipAspect.Metadata, out relationAspects))
{
//Artist fallback
foreach (MultipleMediaItemAspect relation in relationAspects)
{
if ((Guid?)relation[RelationshipAspect.ATTR_LINKED_ROLE] == PersonAspect.ROLE_ARTIST)
{
fanArtFiles.AddRange(fanArtCache.GetFanArtFiles((Guid)relation[RelationshipAspect.ATTR_LINKED_ID], fanArtType));
if (fanArtFiles.Count > 0)
{
break;
}
}
}
}
}
else if (mediaType == FanArtMediaTypes.Album && fanArtType == FanArtTypes.FanArt)
{
//No FanArt exists for Album so use Artists
if (MediaItemAspect.TryGetAspects(mediaItem.Aspects, RelationshipAspect.Metadata, out relationAspects))
{
//Album artist fallback
foreach (MultipleMediaItemAspect relation in relationAspects)
{
if ((Guid?)relation[RelationshipAspect.ATTR_LINKED_ROLE] == PersonAspect.ROLE_ALBUMARTIST)
{
fanArtFiles.AddRange(fanArtCache.GetFanArtFiles((Guid)relation[RelationshipAspect.ATTR_LINKED_ID], fanArtType));
if (fanArtFiles.Count > 0)
{
break;
}
}
}
}
}
else if (mediaItem.Aspects.ContainsKey(AudioAspect.ASPECT_ID))
{
if (MediaItemAspect.TryGetAspects(mediaItem.Aspects, RelationshipAspect.Metadata, out relationAspects))
{
//Album fallback
foreach (MultipleMediaItemAspect relation in relationAspects)
{
if ((Guid?)relation[RelationshipAspect.ATTR_LINKED_ROLE] == AudioAlbumAspect.ROLE_ALBUM)
{
fanArtFiles.AddRange(fanArtCache.GetFanArtFiles((Guid)relation[RelationshipAspect.ATTR_LINKED_ID], fanArtType));
if (fanArtFiles.Count > 0)
{
break;
}
}
}
}
}
}
List <IResourceLocator> files = new List <IResourceLocator>();
try
{
files.AddRange(fanArtFiles
.Select(fileName => new ResourceLocator(ResourcePath.BuildBaseProviderPath(LocalFsResourceProviderBase.LOCAL_FS_RESOURCE_PROVIDER_ID, fileName)))
);
result = files;
return(result.Count > 0);
}
catch (Exception) { }
return(false);
}
public async Task Play(MediaItem channel)
{
try
{
_opening = true;
var plugin = _core.PluginLoader.GetPlugins <IVlcBinariesPlugin>().FirstOrDefault();
if (plugin == null)
{
throw new Exception("No VLC binaries plugin found");
}
var binariesPath = plugin.GetBinariesPath();
_currentChannel = channel;
IsPlaying = true;
HasSubtitles = false;
IsPlaying = false;
CleanUp();
_cts = new CancellationTokenSource();
var cts = _cts;
await SetupPipe(cts);
if (cts.IsCancellationRequested)
{
return;
}
if (_subProcess != null)
{
HasNextChanged?.Invoke(this, false);
HasPreviousChanged?.Invoke(this, false);
var res = await _subProcess.Pipe.CallAsync("initialize", binariesPath, VlcParameters);
if (cts.IsCancellationRequested)
{
return;
}
//CaptureMousePanel.BringToFront();
if (res == null)
{
OnError(new Exception("Could not initialize"));
CleanUp();
return;
}
res = await _subProcess.Pipe.CallAsync("handle", pictureBox.Handle);
if (cts.IsCancellationRequested)
{
return;
}
if (res == null)
{
OnError(new Exception("Could not set handle"));
CleanUp();
return;
}
await SendToSubProcess("play", channel.GetMRL() + " " + channel.GetExtras());
}
else
{
throw new Exception("Pipe not connected");
}
}
catch (AggregateException ex)
{
if (ex.InnerException is ObjectDisposedException)
{
return;
}
}
catch (Exception ex)
{
OnError(ex);
}
finally
{
}
}
public void SetScreen(int index)
{
mediaItem = DataManager.Instance.MediaData.MediaItems[index];
renderer.material = mediaItem.Material;
}
public DetectFacesArgs(Item item)
{
MediaItem = new MediaItem(item);
}
/// <summary>
/// Gets the correct URL for a media item according to SDN as of SC 6.4
/// </summary>
public static string GetMediaUrl(MediaItem item)
{
Assert.ArgumentNotNull(item, "item");
return(StringUtil.EnsurePrefix('/', MediaManager.GetMediaUrl(item)));
}
public static string PrimaryProviderResourcePath(this MediaItem mediaItem)
{
return(mediaItem.PrimaryProviderResourceAspect().GetAttributeValue <string>(ProviderResourceAspect.ATTR_RESOURCE_ACCESSOR_PATH));
}
private void StopSlideshow(MediaItem mediaItem)
{
_imageDisplayManager.StopSlideshow(mediaItem.Id);
}
public static MultipleMediaItemAspect PrimaryProviderResourceAspect(this MediaItem mediaItem)
{
return(mediaItem.PrimaryResources[mediaItem.ActiveResourceLocatorIndex]);
}
private void StopWeb(MediaItem mediaItem)
{
_webDisplayManager.HideWeb();
}
public static MediaItemAspect GetAspect(this MediaItem mediaItem, MediaItemAspectMetadata aspectMetadata)
{
return(mediaItem[aspectMetadata.AspectId]?.FirstOrDefault());
}
private void ShowImage(MediaItem mediaItem)
{
_imageDisplayManager.ShowSingleImage(mediaItem.FilePath, mediaItem.Id, mediaItem.IsBlankScreen);
}
public override bool Process(MediaItem mediaItem, out ContentDirectoryMessaging.MediaItemChangeType changeType)
{
IContentDirectory cd = ServiceRegistration.Get <IServerConnectionManager>().ContentDirectory;
bool removeFromML = IsManagedByMediaLibrary(mediaItem) && cd != null;
changeType = ContentDirectoryMessaging.MediaItemChangeType.None;
// Support multi-resource media items and secondary resources
IList <MultipleMediaItemAspect> providerAspects;
if (!MediaItemAspect.TryGetAspects(mediaItem.Aspects, ProviderResourceAspect.Metadata, out providerAspects))
{
return(false);
}
foreach (MultipleMediaItemAspect providerAspect in providerAspects)
{
string systemId = (string)providerAspect[ProviderResourceAspect.ATTR_SYSTEM_ID];
string resourceAccessorPath = (string)providerAspect[ProviderResourceAspect.ATTR_RESOURCE_ACCESSOR_PATH];
var rl = new ResourceLocator(systemId, ResourcePath.Deserialize(resourceAccessorPath));
using (var ra = rl.CreateAccessor())
{
var rad = ra as IResourceDeletor;
if (rad == null)
{
return(false);
}
// First try to delete the file from storage.
if (!rad.Delete())
{
return(false);
}
changeType = ContentDirectoryMessaging.MediaItemChangeType.Deleted;
// If the MediaItem was loaded from ML, remove it there as well.
if (removeFromML)
{
cd.DeleteMediaItemOrPath(rl.NativeSystemId, rl.NativeResourcePath, true);
}
}
}
// Check for special cases here:
// 1) Recordings have an additional .xml attached
// 2) Deleting files could lead to empty folders that should be also removed
foreach (DeleteRule rule in _defaultRules.Where(r => r.IsEnabled))
{
if (mediaItem.Aspects.ContainsKey(rule.HasAspectGuid))
{
var tsPath = mediaItem.GetResourceLocator().NativeResourcePath.ToString();
foreach (string otherExtension in rule.DeleteOtherExtensions)
{
string otherFilePath = ProviderPathHelper.ChangeExtension(tsPath, otherExtension);
IResourceAccessor ra;
if (!ResourcePath.Deserialize(otherFilePath).TryCreateLocalResourceAccessor(out ra))
{
continue;
}
// Delete other file. We do not check here for existance of file, the Delete needs to handle this.
using (ra)
{
var rad = ra as IResourceDeletor;
rad?.Delete();
}
}
if (rule.DeleteEmptyFolders)
{
var folderPath = ProviderPathHelper.GetDirectoryName(tsPath);
IResourceAccessor ra;
if (!ResourcePath.Deserialize(folderPath).TryCreateLocalResourceAccessor(out ra))
{
continue;
}
// Delete folder if empty
using (ra)
{
IFileSystemResourceAccessor fsra = ra as IFileSystemResourceAccessor;
if (fsra != null)
{
var isEmpty = fsra.GetFiles().Count == 0 && fsra.GetChildDirectories().Count == 0;
if (isEmpty)
{
var rad = ra as IResourceDeletor;
rad?.Delete();
}
}
}
}
}
}
return(true);
}
public IList <Guid> Execute(IList <string> mediaFiles, ShareLocation shareLocation)
{
NumFiles = mediaFiles.Count;
IServerConnectionManager scm = ServiceRegistration.Get <IServerConnectionManager>();
IContentDirectory cd = scm.ContentDirectory;
string systemId = shareLocation == ShareLocation.Local ? ServiceRegistration.Get <ISystemResolver>().LocalSystemId : scm.HomeServerSystemId;
Guid[] necessaryAudioAspectIds = null;
Guid[] optionalAudioAspectIds = null;
ILogger logger = ServiceRegistration.Get <ILogger>();
IScreenManager screenManager = ServiceRegistration.Get <IScreenManager>();
Guid? dialogId = screenManager.ShowDialog(Consts.DIALOG_IMPORT_PLAYLIST_PROGRESS, (dialogName, dialogInstanceId) => Cancel());
if (!dialogId.HasValue)
{
logger.Warn("ImportPlaylistOperation: Error showing progress dialog");
return(null);
}
Guid? userProfile = null;
IUserManagement userProfileDataManagement = ServiceRegistration.Get <IUserManagement>();
if (userProfileDataManagement != null && userProfileDataManagement.IsValidUser)
{
userProfile = userProfileDataManagement.CurrentUser.ProfileId;
}
IList <Guid> result = new List <Guid>();
NumMatched = 0;
NumProcessed = 0;
NumMatched = 0;
UpdateScreenData();
try
{
foreach (string localMediaFile in mediaFiles)
{
if (IsCancelled)
{
return(null);
}
CheckUpdateScreenData();
MediaItem item = cd.LoadItemAsync(systemId, LocalFsResourceProviderBase.ToResourcePath(localMediaFile),
necessaryAudioAspectIds, optionalAudioAspectIds, userProfile).Result;
NumProcessed++;
if (item == null)
{
logger.Warn("ImportPlaylistOperation: Media item '{0}' was not found in the media library", localMediaFile);
continue;
}
logger.Debug("ImportPlaylistOperation: Matched media item '{0}' in media library", localMediaFile);
NumMatched++;
result.Add(item.MediaItemId);
}
}
catch (Exception e)
{
logger.Warn("ImportPlaylistOperation: Error importing playlist", e);
}
screenManager.CloseDialog(dialogId.Value);
return(result);
}
public AlbumFilterItem(MediaItem mediaItem)
{
MediaItem = mediaItem;
}
