public MediaFile(string alias, string fileName, MediaFileType fileType)
{
// if opening a media file directly, make a copy of it first, to allow multiple instances
if (!IsTempFile)
{
_tmpFileName = SaveFileToTmpDir(fileName);
}
// if the alias already exists, remove the old MediaFile and replace it with this
if (_mediaFiles.ContainsKey(alias))
{
_mediaFiles[alias].Dispose();
}
// add this new MediaFile to static list
_mediaFiles.Add(alias, this);
Alias = alias;
FileName = fileName;
FileType = fileType;
IsPlaying = false;
IsPaused = false;
Open();
}
private void SetCurrentPlayer(MediaFileType fileType)
{
if (_currentPlaybackManager != null)
{
RemoveEventHandlers();
}
switch (fileType)
{
case MediaFileType.AudioUrl:
case MediaFileType.AudioFile:
_currentPlaybackManager = AudioPlayer;
break;
case MediaFileType.VideoUrl:
case MediaFileType.VideoFile:
_currentPlaybackManager = VideoPlayer;
break;
case MediaFileType.Other:
break;
default:
throw new ArgumentOutOfRangeException();
}
AddEventHandlers();
}
public FileElement(string caption, MediaFileType fileType, fileElementTapHandler handler) : base(caption)
{
Tapped += delegate {
handler(Path, FileType);
};
FileType = fileType;
}
private string OpenFileType(MediaFileType fileType, out EngineResourceFileTypes resFileType)
{
switch (fileType)
{
case MediaFileType.wav:
resFileType = EngineResourceFileTypes.Audio;
return("waveaudio");
case MediaFileType.mid:
case MediaFileType.midi:
resFileType = EngineResourceFileTypes.Audio;
return("sequencer");
case MediaFileType.wma: // audio
case MediaFileType.mp3: // audio
resFileType = EngineResourceFileTypes.Audio;
return("mpegvideo");
case MediaFileType.avi: // video
case MediaFileType.ogg: // video
case MediaFileType.mpg: // video
case MediaFileType.mpeg: // video
case MediaFileType.wmv: // video
case MediaFileType.asx: // video
case MediaFileType.unknown: // assume video
default:
resFileType = EngineResourceFileTypes.Video;
return("mpegvideo");
}
}
public SelectFileForm(MediaFileType mediaFileType)
{
InitializeComponent();
this.listView.FolderName = Service.Sdsite.CurrentDocument.Resources.AbsoluteFilePath;
initFilter();
FileType = mediaFileType;
filePaths = new List <SimpleExIndexXmlElement>();
filePaths.Add(Service.Sdsite.CurrentDocument.Resources);
pathNum++;
listView.MultiSelect = false;
listView.SmallImageList = new ImageList();
listView.SmallImageList.ColorDepth = ColorDepth.Depth32Bit;
backToolStripButton.Image = ResourceService.GetResourceImage("selectResources.prior");
preToolStripButton.Image = ResourceService.GetResourceImage("selectResources.next");
upToolStripButton.Image = ResourceService.GetResourceImage("selectResources.up");
newFolderToolStripButton.Image = ResourceService.GetResourceImage("selectResources.new");
InitListView(Service.Sdsite.CurrentDocument.Resources);
ContextMenuStrip SelectFileMemu = new ContextMenuStrip();
importResourcesMenuItem = new ToolStripMenuItem("导入资源文件");
SelectFileMemu.Items.Add(importResourcesMenuItem);
listView.ContextMenuStrip = SelectFileMemu;
upToolStripButton.Enabled = true;
SelectFileMemu.ItemClicked += new ToolStripItemClickedEventHandler(SelectFileMemu_ItemClicked);
selectFileToolStrip.ItemClicked += new ToolStripItemClickedEventHandler(selectFileToolStrip_ItemClicked);
preToolStripButton.Visible = false;
upToolStripButton.Enabled = false;
}
/// <summary>
/// 根据扩展名得到ITEM类型
/// </summary>
/// <param name="exfile"></param>
/// <returns></returns>
private MediaFileType GetListItemType(string exfile)
{
MediaFileType fileType = MediaFileType.None;
if (String.IsNullOrEmpty(exfile))
{
return(fileType);
}
else if (_strImageType.Contains(exfile.ToLower()))
{
fileType = MediaFileType.Pic;
}
else if (_strFlash.Contains(exfile.ToLower()))
{
fileType = MediaFileType.Flash;
}
else if (_strAuto.Contains(exfile.ToLower()))
{
fileType = MediaFileType.Audio;
}
else if (_strVido.Contains(exfile.ToLower()))
{
fileType = MediaFileType.Video;
}
return(fileType);
}
public MediaBlobData GetBlobRequest(Media media, MediaFileType type)
{
switch (type)
{
case MediaFileType.Original:
return(media.ToBlobDataRequest());
case MediaFileType.WebPreview:
return(new MediaBlobData
{
Type = MediaBlobType.Web,
Filename = $"{media.Id.ToString("N")}.webp"
});
case MediaFileType.VideoGif:
return(new MediaBlobData
{
Type = MediaBlobType.VideoPreview,
Filename = $"{media.Id}.gif"
});
case MediaFileType.Video720:
return(new MediaBlobData
{
Type = MediaBlobType.VideoPreview,
Filename = $"720P_{media.Id}.mp4"
});
default:
throw new ArgumentException($"Unknown type: {type}");
}
}
public async Task Play(string url, MediaFileType fileType)
{
_loadMediaTaskCompletionSource = new TaskCompletionSource <bool>();
try
{
if (_currentMediaSource != null)
{
_currentMediaSource.StateChanged -= MediaSourceOnStateChanged;
_currentMediaSource.OpenOperationCompleted -= MediaSourceOnOpenOperationCompleted;
}
// Todo: sync this with the playback queue
var mediaPlaybackList = new MediaPlaybackList();
_currentMediaSource = await CreateMediaSource(url, fileType);
_currentMediaSource.StateChanged += MediaSourceOnStateChanged;
_currentMediaSource.OpenOperationCompleted += MediaSourceOnOpenOperationCompleted;
var item = new MediaPlaybackItem(_currentMediaSource);
mediaPlaybackList.Items.Add(item);
_player.Source = mediaPlaybackList;
_player.Play();
}
catch (Exception)
{
Debug.WriteLine("Unable to open url: " + url);
}
}
private async Task <MediaSource> CreateMediaSource(string url, MediaFileType fileType)
{
switch (fileType)
{
case MediaFileType.AudioUrl:
case MediaFileType.VideoUrl:
return(MediaSource.CreateFromUri(new Uri(url)));
case MediaFileType.AudioFile:
case MediaFileType.VideoFile:
var du = _player.SystemMediaTransportControls.DisplayUpdater;
var storageFile = await StorageFile.GetFileFromPathAsync(url);
var playbackType = fileType == MediaFileType.AudioFile
? MediaPlaybackType.Music
: MediaPlaybackType.Video;
await du.CopyFromFileAsync(playbackType, storageFile);
du.Update();
return(MediaSource.CreateFromStorageFile(storageFile));
case MediaFileType.Other:
break;
default:
throw new ArgumentOutOfRangeException(nameof(fileType), fileType, null);
}
return(MediaSource.CreateFromUri(new Uri(url)));
}
/// <summary>Saves a media file with metadata </summary>
/// <param name="type">Type of media file to save.</param>
/// <param name="filePath">Full path to a local file.</param>
/// <returns>A task representing the asynchronous save operation.</returns>
public static Task SaveAsync(MediaFileType type, string filePath)
{
if (string.IsNullOrWhiteSpace(filePath) || !File.Exists(filePath))
{
throw new ArgumentException(nameof(filePath));
}
return(PlatformSaveAsync(type, filePath));
}
/// <summary>
/// Create a new SortMediaFile from a FileInfo object
/// </summary>
/// <param name="_file">FileInfo object to drop</param>
public SortMediaFile(FileInfo _file)
{
FullFilePath = _file.FullName;
FileName = _file.Name;
FileSize = _file.Length;
FileCreated = _file.CreationTime;
Classification = MediaClassifications.Unclassified_File;
FileType = MediaFileType.
}
private MediaModel CreateMediaModel(Android.Net.Uri oUri)
{
MediaModel oModel = null;
var oType = CrossCurrentActivity.Current.Activity.ContentResolver.GetType(oUri);
var oPath = GetPathUri(oUri);
if (oPath != null)
{
string sPath = string.Empty;
string sThumpnailPath = string.Empty;
string sFileName = System.IO.Path.GetFileName(oPath);
string sExt = System.IO.Path.GetExtension(oPath) ?? string.Empty;
MediaFileType mediaFileType = MediaFileType.Image;
if (oType.StartsWith(Enum.GetName(typeof(MediaFileType), MediaFileType.Image), StringComparison.CurrentCultureIgnoreCase))
{
var fullImage = ImageHelper.RotateImage(oPath, 1);
sPath = FileService.GetOutputPath(MediaFileType.Image, TempDir, $"{sFileName}{sExt}");
File.WriteAllBytes(sPath, fullImage);
var oThumpnailImg = ImageHelper.RotateImage(oPath, 0.25f);
sThumpnailPath = FileService.GetOutputPath(MediaFileType.Image, TempDir, $"{sFileName}-THUMBNAIL{sExt}");
File.WriteAllBytes(sThumpnailPath, oThumpnailImg);
}
else if (oType.StartsWith(Enum.GetName(typeof(MediaFileType), MediaFileType.Video), StringComparison.CurrentCultureIgnoreCase))
{
sPath = oPath;
var bitmap = ThumbnailUtils.CreateVideoThumbnail(oPath, ThumbnailKind.MiniKind);
sThumpnailPath = FileService.GetOutputPath(MediaFileType.Image, TempDir, $"{sFileName}-THUMBNAIL{sExt}");
var stream = new FileStream(sThumpnailPath, FileMode.Create);
bitmap?.Compress(Bitmap.CompressFormat.Jpeg, 100, stream);
stream.Close();
mediaFileType = MediaFileType.Video;
}
if (!string.IsNullOrEmpty(sPath) && !string.IsNullOrEmpty(sThumpnailPath))
{
oModel = new MediaModel()
{
FilePath = sPath,
MediaType = mediaFileType,
PreviewFile = sThumpnailPath
};
}
}
return(oModel);
}
/// <summary>Saves a media file with metadata </summary>
/// <param name="type">Type of media file to save.</param>
/// <param name="data">A byte array to save to the file.</param>
/// <param name="fileName">The name of the saved file including the extension.</param>
/// <returns>A task representing the asynchronous save operation.</returns>
public static Task SaveAsync(MediaFileType type, byte[] data, string fileName)
{
if (!(data?.Length > 0))
{
throw new ArgumentNullException(nameof(data));
}
CheckFileName(fileName);
return(PlatformSaveAsync(type, data, fileName));
}
/// <summary>Saves a media file with metadata </summary>
/// <param name="type">Type of media file to save.</param>
/// <param name="fileStream">The stream to output the file to.</param>
/// <param name="fileName">The name of the saved file including the extension.</param>
/// <returns>A task representing the asynchronous save operation.</returns>
public static Task SaveAsync(MediaFileType type, Stream fileStream, string fileName)
{
if (fileStream == null)
{
throw new ArgumentNullException(nameof(fileStream));
}
CheckFileName(fileName);
return(PlatformSaveAsync(type, fileStream, fileName));
}
static public string SelectResourceFormat(MediaFileType type, Form owmerForm)
{
string id = SelectResource(type, owmerForm);
if (!string.IsNullOrEmpty(id))
{
return(Utility.Regex.FormatResourceId(id));
}
return(null);
}
public async Task <IActionResult> Get([FromRoute, Required] MediaFileType kind, [FromRoute, Required] int fileId, [FromRoute, Required] string language)
{
var subtitlePath = await _dispatcher.Dispatch(new SubtitlePathQuery(kind, fileId, language));
if (!string.IsNullOrEmpty(subtitlePath))
{
return(PhysicalFile(subtitlePath, "text/vtt"));
}
return(NotFound());
}
MediaFile CreateMediaFileFromUri(Android.Net.Uri uri)
{
MediaFile mediaFile = null;
var type = CrossCurrentActivity.Current.Activity.ContentResolver.GetType(uri);
var path = GetRealPathFromURI(uri);
if (path != null)
{
string fullPath = string.Empty;
string thumbnailImagePath = string.Empty;
var fileName = System.IO.Path.GetFileNameWithoutExtension(path);
var ext = System.IO.Path.GetExtension(path) ?? string.Empty;
MediaFileType mediaFileType = MediaFileType.Image;
var imageTypeName = Enum.GetName(typeof(MediaFileType), MediaFileType.Image).ToLowerInvariant();
var videoTypeName = Enum.GetName(typeof(MediaFileType), MediaFileType.Video).ToLowerInvariant();
if (type.ToLower().StartsWith(imageTypeName, StringComparison.CurrentCultureIgnoreCase))
{
var fullImage = ImageHelpers.RotateImage(path, 1);
var thumbImage = ImageHelpers.RotateImage(path, 0.25f);
fullPath = FileHelper.GetOutputPath(MediaFileType.Image, TemporalDirectoryName, $"{fileName}{ext}");
File.WriteAllBytes(fullPath, fullImage);
thumbnailImagePath = FileHelper.GetOutputPath(MediaFileType.Image, TemporalDirectoryName, $"{fileName}-THUMBNAIL{ext}");
File.WriteAllBytes(thumbnailImagePath, thumbImage);
}
else if (type.ToLowerInvariant().StartsWith(videoTypeName, StringComparison.CurrentCultureIgnoreCase))
{
fullPath = path;
var bitmap = ThumbnailUtils.CreateVideoThumbnail(path, ThumbnailKind.MiniKind);
thumbnailImagePath = FileHelper.GetOutputPath(MediaFileType.Image, TemporalDirectoryName, $"{fileName}-THUMBNAIL{ext}");
var stream = new FileStream(thumbnailImagePath, FileMode.Create);
bitmap?.Compress(Bitmap.CompressFormat.Jpeg, 100, stream);
stream.Close();
mediaFileType = MediaFileType.Video;
}
if (!string.IsNullOrEmpty(fullPath) && !string.IsNullOrEmpty(thumbnailImagePath))
{
mediaFile = new MediaFile()
{
Path = fullPath,
Type = mediaFileType,
PreviewPath = thumbnailImagePath
};
}
}
return(mediaFile);
}
static async Task PlatformSaveAsync(MediaFileType type, string filePath)
{
using var fileUri = new NSUrl(filePath);
await PhotoLibraryPerformChanges(() =>
{
using var request = type == MediaFileType.Video
? PHAssetChangeRequest.FromVideo(fileUri)
: PHAssetChangeRequest.FromImage(fileUri);
});
}
private void handleFileElementTap(string file, MediaFileType fileType)
{
if (fileType == MediaFileType.Movie)
{
onMovieFileSelected(file);
}
else if (fileType == MediaFileType.Image)
{
onImageFileSelected(file);
}
}
public void SetHTMLDesignerInsertMediaData(MediaFileType type, InsertMediaData data)
{
XmlElement element = GetMediaElement(type);
element.SetAttribute("vMargin", data.MediaVMargin.ToString());
element.SetAttribute("scale", data.MediaScale.ToString());
element.SetAttribute("quality", data.MediaQuality.ToString());
element.SetAttribute("hMargin", data.MediaHMargin.ToString());
element.SetAttribute("align", data.MediaAlign.ToString());
this.Save();
}
/// <summary>Convert to MediaFile_Type for IMDI meta data file</summary>
public MediaFileType ToMediaFileType(string sessionDirectoryName)
{
var mediaFile = new MediaFileType();
SetResourceProperties(mediaFile, sessionDirectoryName);
mediaFile.Quality = new QualityType {
Type = VocabularyTypeValueType.ClosedVocabulary, Value = "Unspecified"
};
return(mediaFile);
}
static string SelectResource(MediaFileType type, Form ownerForm)
{
//SelectFileForm dlg = new SelectFileForm(type);
//dlg.BringToFront();
//if (dlg.ShowDialog(ownerForm) == DialogResult.OK)
//{
// return dlg.FileId;
//}
ResourcesManagerForm dlg = new ResourcesManagerForm();
dlg.BringToFront();
dlg.ShowDialog(ownerForm);
return(null);
}
public MediaFile(MediaFile mediaFile, string alias, string fileName, MediaFileType fileType)
{
this.isMutedAll = mediaFile.isMutedAll;
this.isMutedLeft = mediaFile.isMutedLeft;
this.isMutedRight = mediaFile.isMutedRight;
this.allVolume = mediaFile.allVolume;
this.lftVolume = mediaFile.lftVolume;
this.rtVolume = mediaFile.rtVolume;
this.trebVolume = mediaFile.trebVolume;
this.bassVolume = mediaFile.bassVolume;
this.balance = mediaFile.balance;
this.isLooping = mediaFile.isLooping;
// if opening a media file directly, make a copy of it first, to allow multiple instances
if (!IsTempFile)
{
_tmpFileName = SaveFileToTmpDir(fileName);
}
// if the alias already exists, remove the old MediaFile and replace it with this
if (_mediaFiles.ContainsKey(alias))
{
_mediaFiles[alias].Dispose();
}
// add this new MediaFile to static list
_mediaFiles.Add(alias, this);
Alias = alias;
FileName = fileName;
FileType = fileType;
IsPlaying = false;
IsPaused = false;
Open();
// set variables again after Open() to issue MCI commands
MuteAll = isMutedAll;
MuteLeft = isMutedLeft;
MuteRight = isMutedRight;
VolumeAll = allVolume;
VolumeLeft = lftVolume;
VolumeRight = rtVolume;
VolumeTreble = trebVolume;
VolumeBass = bassVolume;
Balance = balance;
Looping = isLooping;
}
/// <summary>Opens media files Picker</summary>
/// <param name="selectionLimit">Maximum count of files to pick. On Android the option just sets multiple pick allowed.</param>
/// <param name="types">Media file types available for picking</param>
/// <returns>Media files selected by a user.</returns>
public static async Task <MediaPickResult> PickAsync(int selectionLimit = 1, params MediaFileType[] types)
{
if (!(types?.Length > 0))
{
types = new MediaFileType[] { MediaFileType.Image, MediaFileType.Video }
}
;
if (selectionLimit < 0)
{
selectionLimit = 1;
}
return(new MediaPickResult(await PlatformPickAsync(selectionLimit, types)));
}
static async Task PlatformSaveAsync(MediaFileType type, byte[] data, string fileName)
{
string filePath = null;
try
{
filePath = GetFilePath(fileName);
await File.WriteAllBytesAsync(filePath, data);
await PlatformSaveAsync(type, filePath);
}
finally
{
DeleteFile(filePath);
}
}
public static string GetOutputPath(MediaFileType type, string name)
{
if (string.IsNullOrWhiteSpace(name))
{
string timestamp = DateTime.Now.ToString("yyyMMdd_HHmmss");
if (type == MediaFileType.Image)
{
name = "IMG_" + timestamp + ".jpg";
}
else
{
name = "VID_" + timestamp + ".mp4";
}
}
return(GetFullPath(GetUniqueName(type, name)));
}
public async Task Play(string url, MediaFileType fileType)
{
try
{
var mediaPlaybackList = new MediaPlaybackList();
var mediaSource = await CreateMediaSource(url, fileType);
var item = new MediaPlaybackItem(mediaSource);
mediaPlaybackList.Items.Add(item);
_player.Source = mediaPlaybackList;
_player.Play();
}
catch (Exception e)
{
MediaFailed?.Invoke(this, new MediaFailedEventArgs("Unable to start playback", e));
}
}
static async Task PlatformSaveAsync(MediaFileType type, Stream fileStream, string fileName)
{
string filePath = null;
try
{
filePath = GetFilePath(fileName);
using var stream = File.Create(filePath);
await fileStream.CopyToAsync(stream);
stream.Close();
await PlatformSaveAsync(type, filePath);
}
finally
{
DeleteFile(filePath);
}
}
public static string GetOutputPath(MediaFileType type, string path, string name)
{
path = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.Personal), path);
Directory.CreateDirectory(path);
if (string.IsNullOrWhiteSpace(name))
{
string timestamp = DateTime.Now.ToString("yyyMMdd_HHmmss");
if (type == MediaFileType.Image)
{
name = "IMG_" + timestamp + ".jpg";
}
else
{
name = "VID_" + timestamp + ".mp4";
}
}
return(Path.Combine(path, GetUniquePath(type, path, name)));
}
public InsertMediaData GetHTMLDesignerInsertMediaData(MediaFileType type)
{
XmlElement element = GetMediaElement(type);
//如果没有属性,则表示是刚创建的元素
if (!element.HasAttributes)
{
return(null);
}
InsertMediaData mediaData = new InsertMediaData();
mediaData.MediaAlign = int.Parse(element.GetAttribute("align"));
mediaData.MediaHMargin = decimal.Parse(element.GetAttribute("hMargin"));
mediaData.MediaQuality = int.Parse(element.GetAttribute("quality"));
mediaData.MediaScale = int.Parse(element.GetAttribute("scale"));
mediaData.MediaVMargin = decimal.Parse(element.GetAttribute("vMargin"));
return(mediaData);
}
RootElement[] GetMediaElements (string rootPath, MediaFileType fileType)
{
var elements = new List<RootElement> ();
if (Directory.Exists (rootPath)) {
foreach ( string directory in Directory.GetDirectories (rootPath)) {
string shortDirName = Path.GetFileName (directory);
var element = new RootElement (shortDirName);
string text = fileType == MediaFileType.Movie ? "Touch file to play" : "Touch file to view";
var fileSection = new Section (text);
element.Add (fileSection);
foreach (string file in Directory.GetFiles (directory)) {
var fileElement = new FileElement (Path.GetFileName (file), fileType, handleFileElementTap);
fileElement.Path = file;
fileSection.Add (fileElement);
}
elements.Add (element);
}
}
return elements.ToArray ();
}
public MediaFile(string alias, string fileName, MediaFileType fileType)
{
// if opening a media file directly, make a copy of it first, to allow multiple instances
if (!IsTempFile)
_tmpFileName = SaveFileToTmpDir(fileName);
// if the alias already exists, remove the old MediaFile and replace it with this
if (_mediaFiles.ContainsKey(alias))
_mediaFiles[alias].Dispose();
// add this new MediaFile to static list
_mediaFiles.Add(alias, this);
Alias = alias;
FileName = fileName;
FileType = fileType;
IsPlaying = false;
IsPaused = false;
Open();
}
public FileElement( string caption, MediaFileType fileType, fileElementTapHandler handler ) : base(caption)
{
this.Tapped += delegate
{
handler( this.Path, FileType );
};
this.FileType = fileType;
}
public async Task Play(string url, MediaFileType fileType)
{
_loadMediaTaskCompletionSource = new TaskCompletionSource<bool>();
try
{
if (_currentMediaSource != null)
{
_currentMediaSource.StateChanged -= MediaSourceOnStateChanged;
_currentMediaSource.OpenOperationCompleted -= MediaSourceOnOpenOperationCompleted;
}
// Todo: sync this with the playback queue
var mediaPlaybackList = new MediaPlaybackList();
_currentMediaSource = await CreateMediaSource(url, fileType);
_currentMediaSource.StateChanged += MediaSourceOnStateChanged;
_currentMediaSource.OpenOperationCompleted += MediaSourceOnOpenOperationCompleted;
var item = new MediaPlaybackItem(_currentMediaSource);
mediaPlaybackList.Items.Add(item);
_player.Source = mediaPlaybackList;
_player.Play();
}
catch (Exception)
{
Debug.WriteLine("Unable to open url: " + url);
}
}
public async Task Play(string url, MediaFileType fileType)
{
await Play(new MediaFile(url, fileType));
}
/// <summary>
/// Creates a new <see cref="MediaFileNodeType"/>
/// </summary>
/// <param name="mediaFileType">The type of <see cref="IMediaFile"/> to return</param>
public MediaFileNodeType(MediaFileType mediaFileType)
: this(mediaFileType, false)
{
}
public MediaFile(string alias, EngineResourceFileIdentifier resId, MediaFileType fileType)
: this(alias, SaveStreamToTmpDir(resId.Data), fileType)
{
IsTempFile = true;
InputStream = resId.Data;
}
public MediaFile(string alias, Stream fileData, MediaFileType fileType)
: this(alias, SaveStreamToTmpDir(fileData), fileType)
{
IsTempFile = true;
InputStream = fileData;
}
private string OpenFileType(MediaFileType fileType, out EngineResourceFileTypes resFileType)
{
switch (fileType)
{
case MediaFileType.wav:
resFileType = EngineResourceFileTypes.Audio;
return "waveaudio";
case MediaFileType.mid:
case MediaFileType.midi:
resFileType = EngineResourceFileTypes.Audio;
return "sequencer";
case MediaFileType.wma: // audio
case MediaFileType.mp3: // audio
resFileType = EngineResourceFileTypes.Audio;
return "mpegvideo";
case MediaFileType.avi: // video
case MediaFileType.ogg: // video
case MediaFileType.mpg: // video
case MediaFileType.mpeg: // video
case MediaFileType.wmv: // video
case MediaFileType.asx: // video
case MediaFileType.unknown: // assume video
default:
resFileType = EngineResourceFileTypes.Video;
return "mpegvideo";
}
}
public MediaFile(MediaFile mediaFile, string alias, string fileName, MediaFileType fileType)
{
this.isMutedAll = mediaFile.isMutedAll;
this.isMutedLeft = mediaFile.isMutedLeft;
this.isMutedRight = mediaFile.isMutedRight;
this.allVolume = mediaFile.allVolume;
this.lftVolume = mediaFile.lftVolume;
this.rtVolume = mediaFile.rtVolume;
this.trebVolume = mediaFile.trebVolume;
this.bassVolume = mediaFile.bassVolume;
this.balance = mediaFile.balance;
this.isLooping = mediaFile.isLooping;
// if opening a media file directly, make a copy of it first, to allow multiple instances
if (!IsTempFile)
_tmpFileName = SaveFileToTmpDir(fileName);
// if the alias already exists, remove the old MediaFile and replace it with this
if (_mediaFiles.ContainsKey(alias))
_mediaFiles[alias].Dispose();
// add this new MediaFile to static list
_mediaFiles.Add(alias, this);
Alias = alias;
FileName = fileName;
FileType = fileType;
IsPlaying = false;
IsPaused = false;
Open();
// set variables again after Open() to issue MCI commands
MuteAll = isMutedAll;
MuteLeft = isMutedLeft;
MuteRight = isMutedRight;
VolumeAll = allVolume;
VolumeLeft = lftVolume;
VolumeRight = rtVolume;
VolumeTreble = trebVolume;
VolumeBass = bassVolume;
Balance = balance;
Looping = isLooping;
}
/// <summary>
/// Creates a new <see cref="MediaFileNodeType"/>
/// </summary>
/// <param name="uniqueInstance">True if the <see cref="IMediaFile"/> returned should be a new unique instance (uncached)</param>
public MediaFileNodeType(MediaFileType mediaFileType, bool uniqueInstance)
: base(mediaFileType.RuntimeType)
{
this.MediaFileType = mediaFileType;
this.UniqueInstance = uniqueInstance;
}
private void handleFileElementTap( string file, MediaFileType fileType )
{
if ( fileType == MediaFileType.Movie )
{
onMovieFileSelected( file );
}
else if ( fileType == MediaFileType.Image )
{
onImageFileSelected( file );
}
}
public MediaFile(string url, MediaFileType type)
{
Url = url;
Type = type;
}
public async Task Play(string url, MediaFileType fileType)
{
try
{
var mediaPlaybackList = new MediaPlaybackList();
var mediaSource = await CreateMediaSource(url, fileType);
var item = new MediaPlaybackItem(mediaSource);
mediaPlaybackList.Items.Add(item);
_player.Source = mediaPlaybackList;
_player.Play();
}
catch (Exception e)
{
MediaFailed?.Invoke(this, new MediaFailedEventArgs("Unable to start playback", e));
}
}
private void SetCurrentPlayer(MediaFileType fileType)
{
if (_currentPlaybackManager != null)
{
RemoveEventHandlers();
}
switch (fileType)
{
case MediaFileType.AudioUrl:
case MediaFileType.AudioFile:
_currentPlaybackManager = AudioPlayer;
break;
case MediaFileType.VideoUrl:
case MediaFileType.VideoFile:
_currentPlaybackManager = VideoPlayer;
break;
case MediaFileType.Other:
break;
default:
throw new ArgumentOutOfRangeException();
}
AddEventHandlers();
}
public async Task Play(string filePath, MediaFileType mediaFileType, string title = null)
{
try
{
_filePath = filePath;
if (_playbackStateSubject.Latest().First() == MediaPlayerStatus.Paused)
{
await Pause();
return;
}
_canPlaySubject.OnNext(true);
await CrossMediaManager.Current.Play(filePath, mediaFileType);
_titleSubject.OnNext(title);
}
catch (Exception e)
{
_canPlaySubject.OnNext(false);
Debug.WriteLine(e);
}
}
private async Task<MediaSource> CreateMediaSource(string url, MediaFileType fileType)
{
switch (fileType)
{
case MediaFileType.AudioUrl:
case MediaFileType.VideoUrl:
return MediaSource.CreateFromUri(new Uri(url));
case MediaFileType.AudioFile:
case MediaFileType.VideoFile:
var du = _player.SystemMediaTransportControls.DisplayUpdater;
var storageFile = await StorageFile.GetFileFromPathAsync(url);
var playbackType = fileType == MediaFileType.AudioFile
? MediaPlaybackType.Music
: MediaPlaybackType.Video;
await du.CopyFromFileAsync(playbackType, storageFile);
du.Update();
return MediaSource.CreateFromStorageFile(storageFile);
case MediaFileType.Other:
break;
default:
throw new ArgumentOutOfRangeException(nameof(fileType), fileType, null);
}
return MediaSource.CreateFromUri(new Uri(url));
}
public MediaFile(string url, MediaFileType type)
{
Url = url;
Type = type;
Metadata = new MediaFileMetadata();
}
