/// <summary>
/// Get an extension from a media type. (Eg. audio/mpeg -> mp3).
/// </summary>
/// <param name="mediaType">
/// The media type.
/// </param>
/// <param name="mediaTypeGroup">
/// Restrict to a particular media Type Group.
/// </param>
/// <returns>
/// File extension based on media type.
/// </returns>
public static string GetExtension(string mediaType, MediaTypeGroup mediaTypeGroup)
{
mediaType = CanonicaliseMediaType(mediaType);
string ext;
if (mediaTypeGroup == MediaTypeGroup.Any || mediaTypeGroup == MediaTypeGroup.Unknown)
{
ext = Mapping.Where(m => m.MediaType == mediaType).Select(i => i.Extension).FirstOrDefault();
}
else
{
ext =
Mapping.Where(m => m.MediaType == mediaType && m.Group == mediaTypeGroup).Select(i => i.Extension).
FirstOrDefault();
}
if (string.IsNullOrEmpty(ext))
{
ext = ExtUnknown;
}
ext = CanonicaliseExtension(ext);
return(ext);
}
/// <summary>
/// Get media type from extension (can be dangerous, as file content is not considered).
/// </summary>
/// <param name="extension">
/// File Extension.
/// </param>
/// <param name="mediaTypeGroup">
/// Restrict to a particular media Type Group.
/// </param>
/// <returns>
/// media type based on extension.
/// </returns>
public static string GetMediaType(string extension, MediaTypeGroup mediaTypeGroup)
{
extension = CanonicaliseExtension(extension);
string mediaType;
if (mediaTypeGroup == MediaTypeGroup.Any || mediaTypeGroup == MediaTypeGroup.Unknown)
{
mediaType = Mapping.Where(m => m.Extension == extension).Select(i => i.MediaType).FirstOrDefault();
}
else
{
mediaType =
Mapping.Where(m => m.Extension == extension && m.Group == mediaTypeGroup).Select(i => i.MediaType).
FirstOrDefault();
}
if (string.IsNullOrEmpty(mediaType))
{
mediaType = MediaTypeBin;
}
mediaType = CanonicaliseMediaType(mediaType);
return(mediaType);
}
public MediaType(string extension, string contentType, MediaTypeGroup mediaTypeGroup)
{
_extension = extension;
_contentType = contentType;
_medieTypeClass = mediaTypeGroup;
}
private IPictureService SelectService(MediaTypeGroup mediaGroup)
{
// will select a service to use
if (PictureService == null) return null;
switch (mediaGroup)
{
case MediaTypeGroup.PICTURE:
return PictureService;
case MediaTypeGroup.VIDEO:
return VideoService;
case MediaTypeGroup.AUDIO:
return AudioService;
case MediaTypeGroup.DOCUMENT:
return DocumentService;
case MediaTypeGroup.ALL: // not a valid thing to ask for
default:
return null;
}
}
public string GetFileFilter(MediaTypeGroup mediaGroup)
{
bool first = true;
string filterFormat = "{0} ({1})|{1}";
string unnamedFormat = Localization.XmlBasedResourceManager.GetString("{0} files");
string extFormat = "*.{0}";
StringBuilder sb = new StringBuilder();
if (mediaGroup == MediaTypeGroup.ALL)
{
MediaTypeGroup[] groups = {
MediaTypeGroup.PICTURE,
MediaTypeGroup.VIDEO,
MediaTypeGroup.AUDIO,
MediaTypeGroup.DOCUMENT
};
Dictionary<MediaTypeGroup, string> descriptions = new Dictionary<MediaTypeGroup,string>(4);
descriptions.Add(MediaTypeGroup.PICTURE, Localization.XmlBasedResourceManager.GetString("Pictures"));
descriptions.Add(MediaTypeGroup.VIDEO, Localization.XmlBasedResourceManager.GetString("Videos"));
descriptions.Add(MediaTypeGroup.AUDIO, Localization.XmlBasedResourceManager.GetString("Audio Files"));
descriptions.Add(MediaTypeGroup.DOCUMENT, Localization.XmlBasedResourceManager.GetString("Other Documents"));
// Aggregate file types for each MediaTypeGroup
foreach (MediaTypeGroup group in groups)
{
StringBuilder groupExtensions = new StringBuilder();
IPictureService srv = SelectService(group);
first = true;
if (srv != null)
foreach (MediaType r in srv.FileTypes)
if (r.MediaGroup == group)
{
if (first)
first = false;
else
groupExtensions.Append(",");
groupExtensions.Append(string.Format(extFormat, r.Extension));
}
if (groupExtensions.Length > 0)
{
if (sb.Length > 0)
sb.Append("|");
sb.Append(string.Format(filterFormat, descriptions[group], groupExtensions.ToString()));
}
}
// Now get individual file types
foreach (MediaTypeGroup group in groups)
{
string filter = GetFileFilter(group);
if (sb.Length > 0 && !string.IsNullOrEmpty(filter))
sb.Append("|");
sb.Append(filter);
}
return sb.ToString();
}
else
{
IPictureService Service = SelectService(mediaGroup);
if (Service == null) return string.Empty;
foreach (MediaType type in Service.FileTypes)
{
if (type.MediaGroup != mediaGroup)
{
continue;
}
if (first)
first = false;
else
sb.Append("|");
sb.Append(string.Format(filterFormat, string.Format(unnamedFormat, type.Extension), string.Format(extFormat, type.Extension)));
}
return sb.ToString();
}
}
public bool CanUpload(MediaTypeGroup mediaGroup)
{
return (SelectService(mediaGroup) != null);
}
public string FileFilter(MediaTypeGroup mediaGroup)
{
bool first = true;
string filterFormat = "{0} files (*.{0})|*.{0}";
StringBuilder sb = new StringBuilder();
foreach (MediaType type in API_FILETYPES)
{
if (type.MediaGroup != mediaGroup && mediaGroup != MediaTypeGroup.ALL)
{
continue;
}
if (first)
{
first = false;
}
else
{
sb.Append("|");
}
sb.Append(string.Format(filterFormat, type.Extension));
}
return sb.ToString();
}
/// <summary>
/// Check if a media type is recognised.
/// </summary>
/// <param name="mediaType">
/// The media type.
/// </param>
/// <param name="mediaTypeGroup">
/// Restrict to a particular media Type Group.
/// </param>
/// <returns>
/// True if media type is recognised, otherwise false.
/// </returns>
public static bool IsMediaTypeRecognised(string mediaType, MediaTypeGroup mediaTypeGroup)
{
var ext = GetExtension(mediaType, mediaTypeGroup);
return(ext != ExtUnknown);
}
/// <summary>
/// Check if a File extension is recognised.
/// </summary>
/// <param name="extension">
/// The extension.
/// </param>
/// <param name="mediaTypeGroup">
/// Restrict to a particular media Type Group.
/// </param>
/// <returns>
/// True if file extension is recognised, otherwise false.
/// </returns>
public static bool IsFileExtRecognised(string extension, MediaTypeGroup mediaTypeGroup)
{
var mediaType = GetMediaType(extension, mediaTypeGroup);
return(mediaType != MediaTypeBin);
}
/// <summary>
/// Use a imageId to retrieve and save a thumbnail to the device.
/// </summary>
/// <param name="imageId">Id for the image</param>
/// <returns></returns>
private string RetrievePicture(string imageId, MediaTypeGroup type)
{
try
{
string url = "";
if (type == MediaTypeGroup.VIDEO)
{
url = string.Format("http://vid.pikchur.com/vid_{0}_l.jpg", imageId);
}
else
{
url = string.Format("http://img.pikchur.com/pic_{0}_l.jpg", imageId);
}
HttpWebRequest myRequest = WebRequestFactory.CreateHttpRequest(url);
myRequest.Method = "GET";
String pictureFileName = String.Empty;
using (HttpWebResponse response = (HttpWebResponse)myRequest.GetResponse())
{
using (Stream dataStream = response.GetResponseStream())
{
int totalSize = 0;
int totalResponseSize = (int)response.ContentLength;
byte[] readBuffer = new byte[PT_READ_BUFFER_SIZE];
pictureFileName = GetPicturePath(imageId);
int responseSize = dataStream.Read(readBuffer, 0, PT_READ_BUFFER_SIZE);
totalSize = responseSize;
OnDownloadPart(new PictureServiceEventArgs(responseSize, totalSize, totalResponseSize));
while (responseSize > 0)
{
SavePicture(pictureFileName, readBuffer, responseSize);
try
{
totalSize += responseSize;
responseSize = dataStream.Read(readBuffer, 0, PT_READ_BUFFER_SIZE);
OnDownloadPart(new PictureServiceEventArgs(responseSize, totalSize, totalResponseSize));
}
catch
{
responseSize = 0;
}
System.Threading.Thread.Sleep(100);
}
dataStream.Close();
}
response.Close();
}
return pictureFileName;
}
catch (Exception)
{
OnErrorOccured(new PictureServiceEventArgs(PictureServiceErrorLevel.Failed, string.Empty, API_ERROR_DOWNLOAD));
return string.Empty;
}
}
