internal static void ParseWurflFiles(Provider devices)
{
// Parse the wurfl files.
ParseWurflFiles(
devices,
Manager.WurflFilePath,
Manager.CapabilitiesWhiteList,
Manager.WurflPatchFiles);
}
/// <summary>
/// Creates an instance of DeviceInfo.
/// </summary>
/// <param name="userAgent">User agent string used to identify this device.</param>
/// <param name="deviceId">A unique Identifier of the device.</param>
/// <param name="devices">A reference to the complete index of devices.</param>
internal DeviceInfo(
Provider devices,
string deviceId,
string userAgent)
{
Init(devices, deviceId, userAgent);
}
private void Init(
Provider devices,
string deviceId,
string userAgent)
{
if (userAgent == null)
throw new ArgumentNullException("userAgent");
_userAgent = UserAgentParser.Parse(userAgent);
Init(devices, deviceId);
}
private void Init(
Provider devices,
string deviceId)
{
if (string.IsNullOrEmpty(deviceId))
throw new ArgumentNullException("deviceId");
if (devices == null)
throw new ArgumentNullException("devices");
_devices = devices;
_deviceId = deviceId;
_deviceCapabilities = new Collection();
}
/// <summary>
/// Creates an instance of DeviceInfo.
/// </summary>
/// <param name="deviceId">A unique Identifier of the device.</param>
/// <param name="devices">A reference to the complete index of devices.</param>
internal DeviceInfo(
Provider devices,
string deviceId)
{
Init(devices, deviceId);
}
/// <summary>
/// Creates an instance of DeviceInfo.
/// </summary>
/// <param name="userAgent">User agent string used to identify this device.</param>
/// <param name="deviceId">A unique Identifier of the device.</param>
/// <param name="devices">A reference to the complete index of devices.</param>
/// <param name="fallbackDevice">The fallback device to use for this device if any.</param>
internal DeviceInfo(
Provider devices,
string deviceId,
string userAgent,
DeviceInfo fallbackDevice)
{
if (fallbackDevice == null)
throw new ArgumentNullException("fallbackDevice");
Init(devices, deviceId, userAgent);
_fallbackDevice = fallbackDevice;
}
/// <summary>
/// Parses the wurfl file into a instance of WurflFile.
/// </summary>
/// <param name="devices">Instance of Devices to store data.</param>
/// <param name="wurflFilePath">Wurfl file path.</param>
/// <param name="capabilitiesWhiteList">List of capabilities to be used. If none, all capabilities will be loaded into the memory.</param>
/// <param name="wurflPatchFiles">Null, string or array of strings representing the wurfl patch files
/// which must be applied against the main file.</param>
/// <returns>Returns an instance of WurflFile.
/// <remarks>If none file is found a null value will be returned.</remarks>
/// </returns>
/// <exception cref="System.IO.FileNotFoundException">Thrown if the parameter <paramref name="wurflFilePath"/>
/// referes to a file that does not exists.</exception>
/// <exception cref="System.ArgumentNullException">Thrown if the parameter <paramref name="wurflFilePath"/>
/// is an empty string or a null value.</exception>
private static void ParseWurflFiles(
Provider devices,
string wurflFilePath,
StringCollection capabilitiesWhiteList,
params string[] wurflPatchFiles)
{
if (string.IsNullOrEmpty(wurflFilePath))
throw new ArgumentNullException("wurflFilePath");
if (!File.Exists(wurflFilePath))
throw new FileNotFoundException(Constants.WurflFileNotFound, wurflFilePath);
// Load white listed capabilities
if (capabilitiesWhiteList != null)
{
_loadOnlyCapabilitiesWhiteListed = capabilitiesWhiteList.Count > 0;
#if VER4
foreach (string capability in
capabilitiesWhiteList.Cast<string>().Where(capability => !_capabilitiesWhiteListed.Contains(capability)))
{
_capabilitiesWhiteListed.Add(capability);
}
#elif VER2
foreach (string capability in capabilitiesWhiteList)
if (!_capabilitiesWhiteListed.Contains(capability))
_capabilitiesWhiteListed.Add(capability);
#endif
}
StringCollection wurflFilePaths = new StringCollection();
wurflFilePaths.Add(wurflFilePath);
wurflFilePaths.AddRange(wurflPatchFiles);
ParseWurflFiles(devices, wurflFilePaths, File.GetCreationTimeUtc(wurflFilePath));
}
/// <summary>
/// Parses the wurfl file into a instance of Devices.
/// </summary>
/// <param name="devices">Instance of Devices to store data.</param>
/// <param name="wurflFilePath">Wurfl file path.</param>
/// <param name="wurflPatchFiles">Null, string or array of strings representing the wurfl patch files
/// which must be applied against the main file.</param>
/// <returns>Returns an instance of Devices.
/// <remarks>If none file is found a null value will be returned.</remarks>
/// </returns>
/// <exception cref="System.IO.FileNotFoundException">Thrown if the parameter <paramref name="wurflFilePath"/>
/// referes to a file that does not exists.</exception>
/// <exception cref="System.ArgumentNullException">Thrown if the parameter <paramref name="wurflFilePath"/>
/// is an empty string or a null value.</exception>
private static void ParseWurflFiles(
Provider devices,
string wurflFilePath,
params string[] wurflPatchFiles)
{
ParseWurflFiles(
devices,
wurflFilePath,
null,
wurflPatchFiles);
}
/// <summary>
/// Parses the Wurfl files and updates the devices object with data found.
/// </summary>
/// <param name="wurflFilePaths">Paths of the Wurfl xml and patch files.</param>
/// <param name="devices">Collection of mobile devices.</param>
/// <param name="masterFileDate">If a device has a creation date element only include it in the
/// device database if it was created after the master file's date and time.</param>
/// <remarks>If no files are found devices will remain unchanged.</remarks>
private static void ParseWurflFiles(Provider devices, StringCollection wurflFilePaths,
DateTime masterFileDate)
{
StringCollection availableCapabilities = new StringCollection();
foreach (string filePath in wurflFilePaths)
{
// Load the data from the XML file into the devices collection.
LoadXmlData(availableCapabilities,
devices,
filePath,
masterFileDate);
}
}
private static void LoadXmlData(
StringCollection availableCapabilities,
Provider devices,
string filePath,
DateTime masterFileDate)
{
DeviceInfo device = null;
FileInfo file = new FileInfo(filePath);
if (file.Exists)
{
// Open the reader using decompression if the file has an extension
// that indicates it's compressed.
using (XmlReader reader = GetReader(file))
{
try
{
// Process the data file.
while (reader.Read())
{
switch (reader.Name)
{
// Load Device Data
case Constants.DeviceNodeName:
if (reader.IsStartElement())
{
// If a device has already been created ensure it's saved.
if (device != null)
devices.Set(device);
// Create or get the device related to the current XML element.
device = LoadDevice(devices, reader);
}
break;
// Load the device capability.
case Constants.CapabilityNodeName:
if (reader.IsStartElement())
{
LoadCapabilityData(
reader,
device,
availableCapabilities);
}
break;
}
}
// If a device has not been written ensure it's added to the device dataset.
if (device != null)
devices.Set(device);
}
catch (XmlException ex)
{
throw new WurflException(
String.Format("XML exception processing wurfl file '{0}'.", filePath),
ex);
}
catch (IOException ex)
{
throw new WurflException(
String.Format("IO exception processing wurfl file '{0}'.", filePath),
ex);
}
catch (Exception ex)
{
throw new WurflException(
String.Format("Exception processing wurfl file '{0}'.", filePath),
ex);
}
}
}
}
/// <summary>
/// Processes the XML element containing the device attributes.
/// </summary>
/// <param name="devices">A list of loaded devices.</param>
/// <param name="reader">The XML stream readers.</param>
/// <returns>An empty device.</returns>
private static DeviceInfo LoadDevice(Provider devices, XmlReader reader)
{
// Create the next device using the fallback device if available.
string deviceId = reader.GetAttribute(Constants.IdAttributeName, string.Empty);
string userAgent = reader.GetAttribute(Constants.UserAgentAttributeName, string.Empty);
string fallbackDeviceId = reader.GetAttribute(Constants.FallbackAttributeName, string.Empty);
// If the device already exists then use the previous one. This may happen
// when an earlier device referenced a fallback device that had not yet
// been created.
DeviceInfo device = devices.GetDeviceInfoFromID(deviceId);
if (device == null)
{
// Create the new device.
device = new DeviceInfo(devices, deviceId, userAgent ?? String.Empty);
}
else if (userAgent != null)
{
// Ensure the correct UserAgent string is assigned to this device.
device.SetUserAgent(userAgent);
}
// If the Actual Device Root attribute is specified then set the value
// for this device.
bool isActualDeviceRoot;
if (bool.TryParse(reader.GetAttribute(Constants.ActualDeviceRoot, string.Empty), out isActualDeviceRoot))
device.IsActualDeviceRoot = isActualDeviceRoot;
// Check the fallback device is different to the device being loaded.
if (fallbackDeviceId != null && device.DeviceId != fallbackDeviceId)
{
// Does the fallback device already exist?
device.FallbackDevice = devices.GetDeviceInfoFromID(fallbackDeviceId);
if (device.FallbackDevice == null)
{
// No. So create new fallback device.
device.FallbackDevice = new DeviceInfo(devices, fallbackDeviceId);
// Add it to the available devices.
devices.Set(device.FallbackDevice);
}
}
return device;
}
/// <summary>
/// Creates a single instance of this class to be used by all
/// clients within the AppDomain.
/// </summary>
private static void LoadSingleton()
{
Provider newInstance = new Provider();
try
{
long startTicks = DateTime.Now.Ticks;
// Load data from all available sources.
Processor.ParseWurflFiles(newInstance);
long duration = TimeSpan.FromTicks(DateTime.Now.Ticks - startTicks + 1).Milliseconds;
// Log the length of time taken to load the device data.
EventLog.Info(String.Format("Loaded {0} devices using {1} strings in {2}ms",
newInstance._deviceIDs.Count,
Strings.Count,
duration));
// Log the number of devices assigned to each handler if debugging is enabled.
#if DEBUG
// Display the handler results.
//tomquery
/*if (newInstance._handlers != null && EventLog.IsDebug)
{
for (int i = 0; i < newInstance._handlers.Length; i++)
{
EventLog.Debug(String.Format("Handler '{0}' loaded with {1} devices.",
newInstance._handlers[i].GetType().Name,
newInstance._handlers[i].UserAgents.Count));
}
}*/
#endif
// Store the single instance and change the status to show the
// data has finished loading.
newInstance.IsLoaded = true;
_instance = newInstance;
}
catch (WurflException ex)
{
// Record the exception.
EventLog.Fatal(ex);
// Set an empty Devices instance as it's not possible
// to reliably load the data files specified.
_instance = new Provider();
}
}
