/// <summary>
/// Returns true if the other MediaClass has the same value and attribute values.
/// </summary>
/// <param name="cdsElement">a MediaClass instance; derived classes don't count</param>
/// <returns></returns>
public override bool Equals(object cdsElement)
{
MediaClass other = (MediaClass)cdsElement;
if (this.GetType() == other.GetType())
{
if (this.m_ClassName.Equals(other.m_ClassName))
{
if (this.m_DerivedFrom.Equals(other.m_DerivedFrom))
{
if (this.m_FriendlyName.Equals(other.m_FriendlyName))
{
return(true);
}
}
}
}
return(false);
}
/// <summary>
/// Populates the MediaClasses arraylist.
/// </summary>
private static void GetMediaClasses()
{
lock (MediaClasses.SyncRoot)
{
if (MediaClasses.Count == 0)
{
// Iterate through assemblies
Assembly[] assemblies = AppDomain.CurrentDomain.GetAssemblies();
foreach (Assembly asm in assemblies)
{
// Iterate through class types of each assembly
Type[] types = asm.GetTypes();
foreach (Type type in types)
{
// Only classes derived from MediaBuilder.CoreMetadata
// are considered for defining a media classes.
if (type.IsSubclassOf(typeof(MediaBuilder.CoreMetadata)))
{
// Recurse up the class's base types and derive
// a string that reveals the full media class
// that this type represents.
Stack baseTypes = new Stack();
Type baseType = type;
while (baseType != typeof(MediaBuilder.CoreMetadata))
{
baseTypes.Push(baseType);
baseType = baseType.BaseType;
}
StringBuilder sb = new StringBuilder(baseTypes.Count * 8 + 1);
sb.Append("object.");
while (baseTypes.Count > 0)
{
baseType = (Type)baseTypes.Pop();
sb.Append(baseType.Name);
if (baseTypes.Count > 0)
{
sb.Append(".");
}
}
string mediaClassString = sb.ToString();
// Introspect the type for a friendly name.
FieldInfo fi = type.GetField("CdsFriendlyName", BindingFlags.Instance | BindingFlags.NonPublic | BindingFlags.Public);
string friendly = "";
if (fi != null)
{
ConstructorInfo ci = type.GetConstructor(new Type[0]);
if (ci != null)
{
object obj = ci.Invoke(new Object[0]);
friendly = (string)fi.GetValue(obj);
}
}
// Instantiate a media class and store it in the array
MediaClass newClass = new MediaClass(mediaClassString, friendly);
MediaClassInfo mci = new MediaClassInfo();
mci._Type = type;
mci._Class = newClass;
Sorter.Set(MediaClasses, mci, false); ;
}
}
}
}
}
}
/// <summary>
/// The ability to modify objects directly to a container/item is not available
/// for a public programmer. Each CpMediaItem object is responsible
/// for maintaining its own state.
/// </summary>
/// <param name="propertyName"></param>
/// <param name="val"></param>
public override void SetPropertyValue_MediaClass(string propertyName, MediaClass val)
{
this.CheckRuntimeBindings(new StackTrace());
base.SetPropertyValue_MediaClass(propertyName, val);
}
/// <summary>
/// Must indicate the media class and whether derived media class
/// types should also be included as matches.
/// </summary>
/// <param name="mediaClass"></param>
/// <param name="includeDerived"></param>
public MatchOnClass(MediaClass mediaClass, bool includeDerived)
{
this.m_Class = mediaClass;
this.m_IncludeDerived = includeDerived;
}
/// <summary>
/// Returns true if the StringValue values of both media classes are equal.
/// </summary>
/// <param name="_class"></param>
/// <returns></returns>
public bool FullClassNameMatches(MediaClass _class)
{
return(string.Compare(this.ToString(), _class.ToString(), true) == 0);
}
/// <summary>
/// Returns true, if the item is derived from
/// or is of the specified class.
/// </summary>
/// <param name="derivedFrom">the media class to which to compare to</param>
/// <returns>true indicates an IS-A relationship with the specified media class</returns>
public bool IsA(MediaClass derivedFrom)
{
return(this.ToString().StartsWith(derivedFrom.ToString()));
}
/// <summary>
/// Sets a value in the hashtable
/// </summary>
/// <param name="key">property name</param>
private void SetVal(string key, ICdsElement[] objs)
{
//this.m_Table[key] = objs;
if ((key == T[_DC.title]))
{
this.m_Title = (PropertyString)objs[0];
}
else if ((key == T[_DC.creator]))
{
this.m_Creator = (PropertyString)objs[0];
}
else if ((key == T[_UPNP.Class]))
{
this.m_Class = (MediaClass)objs[0];
}
else
{
Exception error = null;
try
{
this.m_LockTable.AcquireWriterLock(-1);
try
{
_Hashtable.Set(m_Table, key, objs);
}
catch (Exception e)
{
error = e;
}
}
finally
{
this.m_LockTable.ReleaseWriterLock();
}
if (error != null)
{
Exception ne = new Exception("MediaProperties.set_this[string]()", error);
throw ne;
}
}
this.IncrementStateNumber();
}
/// <summary>
/// Metadata often benefits from having strongly typed values, and
/// this method allows a programmer to easily set a CDS entry's property
/// with strongly typed values very easily. A public programmer's ability to modify
/// an object's metadata directly is available only from a device-side programming
/// scenario.
/// </summary>
/// <param name="propertyName">
/// Standard metadata properties can be obtained by using the OpenSource.UPnP.AV.CdsMetadata.CommonPropertyNames enumerator
/// in conjunction with an instantiation of the OpenSource.UPnP.AV.CdsMetadata.Tags class, which returns string representations of common CDS tagnames and attributes.
/// </param>
/// <param name="values">array of MediaClass values that will overwrite all values associated with the specified metadata field</param>
public virtual void SetPropertyValue_MediaClass(string propertyName, MediaClass[] values)
{
ArrayList al = new ArrayList(values.Length);
al.AddRange(values);
this.m_Properties[propertyName] = al;
}
/// <summary>
/// Special ISerializable constructor.
/// Do basic initialization and then serialize from the info object.
/// </summary>
/// <param name="info"></param>
/// <param name="context"></param>
private MediaProperties(SerializationInfo info, System.Runtime.Serialization.StreamingContext context)
{
Init();
this.m_Table = (ArrayList)info.GetValue("m_Table", typeof(ArrayList));
this.m_Title = (PropertyString)info.GetValue("m_Title", typeof(PropertyString));
this.m_Creator = (PropertyString)info.GetValue("m_Creator", typeof(PropertyString));
this.m_Class = (MediaClass)info.GetValue("m_Class", typeof(MediaClass));
this.IsEnabled_OnMetadataChanged = info.GetBoolean("IsEnabled_OnMetadataChanged");
}
/// <summary>
/// <para>
/// This method clears the hashtable values for all properties.
/// </para>
/// <para>
/// Derived classes will have access to this and so will internal classes.
/// Programmers deriving from this object are strongly encouraged to not use
/// this unless they ABSOLUTELY know what they're doing.
/// </para>
/// </summary>
internal void ClearProperties()
{
try
{
this.m_LockTable.AcquireWriterLock(-1);
this.m_Table = new ArrayList(2);
this.m_Title = null;
this.m_Creator = null;
this.m_Class = null;
this.IncrementStateNumber();
}
finally
{
this.m_LockTable.ReleaseWriterLock();
}
}
/// <summary>
/// Updates m_CacheTitle, m_CacheCreator, and m_CacheClass.
/// </summary>
protected void UpdateCache()
{
if (this.m_PropertiesStateNumber != this.m_Properties.StateNumber)
{
// Some have made an argument that the extensive amount of
// error checking is unnecessary given that I ensure that
// the value is proper before setting.
//
// Unfortunately, simply returning list[0].Value has problems.
// A number of applications have been written with the
// expectation that this property will never return null
// or throw an InvalidCast/NullReference exception.
//
// The whole purpose of UpdateCache is to minimize
// the error-checking done for the Title, Creator, and
// Class properties (which are all properties provided
// as a courtesy so programmers don't have to do tedious
// error checking).
//
// Given that the vast majority of
// implementations won't change metadata regularly,
// the caching is actually quite effective.
string title = T[_DC.title];
string creator = T[_DC.creator];
string Class = T[_UPNP.Class];
string[] properties = {title, creator, Class};
Hashtable lists = this.m_Properties.GetValues(properties);
IList list;
this.m_CacheTitle = "";
this.m_CacheCreator = "";
this.m_CacheClass = null;
if (lists != null)
{
list = (IList) lists[title];
if ((list != null) && (list.Count > 0) && (list[0] is CdsMetadata.ICdsElement))
{
this.m_CacheTitle = (string) ((ICdsElement)list[0]).Value;
}
list = (IList) lists[creator];
if ((list != null) && (list.Count > 0) && (list[0] is CdsMetadata.ICdsElement))
{
this.m_CacheCreator = (string) ((ICdsElement)list[0]).Value;
}
list = (IList) lists[Class];
if ((list != null) && (list.Count > 0) && (list[0] is CdsMetadata.MediaClass))
{
this.m_CacheClass = (MediaClass) list[0];
}
}
this.m_PropertiesStateNumber = this.m_Properties.StateNumber;
}
}
/// <summary>
/// Used to validate a media class.
/// </summary>
/// <param name="mclass"></param>
/// <exception cref="Error_BadMetadata">
/// Thrown if the media class is null/invalid.
/// </exception>
protected void ThrowExceptionIfBadClass(MediaClass mclass)
{
if ((mclass == null))
{
throw new Error_BadMetadata("Must specify a media class. Error found on ID='" +this.m_ID+"'");
}
}
/// <summary>
/// Metadata often benefits from having strongly typed values, and
/// this method allows a programmer to easily set a CDS entry's property
/// with strongly typed values very easily. A public programmer's ability to modify
/// an object's metadata directly is available only from a device-side programming
/// scenario.
/// </summary>
/// <param name="propertyName">
/// Standard metadata properties can be obtained by using the OpenSource.UPnP.AV.CdsMetadata.CommonPropertyNames enumerator
/// in conjunction with an instantiation of the OpenSource.UPnP.AV.CdsMetadata.Tags class, which returns string representations of common CDS tagnames and attributes.
/// </param>
/// <param name="val">a single MediaClass value that will overwrite all values associated with the specified metadata field</param>
public virtual void SetPropertyValue_MediaClass(string propertyName, MediaClass val)
{
MediaClass[] values = new MediaClass[1];
values[0] = val;
SetPropertyValue_MediaClass(propertyName, values);
}
/// <summary>
/// Returns true, if the item is derived from
/// or is of the specified class.
/// </summary>
/// <param name="derivedFrom">the media class to which to compare to</param>
/// <returns>true indicates an IS-A relationship with the specified media class</returns>
public bool IsA (MediaClass derivedFrom)
{
return (this.ToString().StartsWith(derivedFrom.ToString()));
}
/// <summary>
/// Throws an exception. CpRootCollectionContainers
/// are not like normal containers because they
/// aggregate root containers. For this reason
/// the ability to modify properties, resources,
/// and metadata is NEVER allowed since
/// there is no actual metadata to retrieve or set.
/// </summary>
/// <param name="propertyName"></param>
/// <param name="val"></param>
public override void SetPropertyValue_MediaClass(string propertyName, MediaClass val)
{
CheckProtection();
}
/// <summary>
/// Returns true if the StringValue values of both media classes are equal.
/// </summary>
/// <param name="_class"></param>
/// <returns></returns>
public bool FullClassNameMatches (MediaClass _class)
{
return (string.Compare(this.ToString(), _class.ToString(), true) == 0);
}
/// <summary>
/// Must indicate the media class and whether derived media class
/// types should also be included as matches.
/// </summary>
/// <param name="mediaClass"></param>
/// <param name="includeDerived"></param>
public MatchOnClass (MediaClass mediaClass, bool includeDerived)
{
this.m_Class = mediaClass;
this.m_IncludeDerived = includeDerived;
}