Fixed reference path to dependent tizen dlls

Patch set #17: Removed SystemTest containing test code
Patch set #16: Fixed merged conflict
Patch set #15: Added log statements for error cases and incorporated review comments(#14)
Patch set #14: Fixed issues found during testing and added Test application(console).

Change-Id: I9daf44eefb1750a93307a89d7a1741d86f8568c8
Signed-off-by: Jyothi Kumar Sambolu <s.jyothi@samsung.com>

diff --git a/Tizen.System/Interop/Interop.Device.cs b/Tizen.System/Interop/Interop.Device.cs
index 31c2ea3..69644b4 100644 (file)
--- a/Tizen.System/Interop/Interop.Device.cs
+++ b/Tizen.System/Interop/Interop.Device.cs
@@ -21,7 +21,7 @@ namespace Tizen.System
         FlashBrightness
     }
 }
-internal static class Interop
+internal static partial class Interop
 {
     internal static partial class Device
     {

diff --git a/Tizen.System/Interop/Interop.Libraries.cs b/Tizen.System/Interop/Interop.Libraries.cs
new file mode 100644 (file)
index 0000000..f4ceadc
--- /dev/null
+++ b/Tizen.System/Interop/Interop.Libraries.cs
@@ -0,0 +1,22 @@
+/// Copyright 2016 by Samsung Electronics, Inc.,
+///
+/// This software is the confidential and proprietary information
+/// of Samsung Electronics, Inc. ("Confidential Information"). You
+/// shall not disclose such Confidential Information and shall use
+/// it only in accordance with the terms of the license agreement
+/// you entered into with Samsung.
+
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+internal static partial class Interop
+{
+    internal static partial class Libraries
+    {
+        public const string RuntimeInfo = "libcapi-system-runtime-info.so.0";
+    }
+}

diff --git a/Tizen.System/Interop/Interop.RuntimeInfo.cs b/Tizen.System/Interop/Interop.RuntimeInfo.cs
new file mode 100644 (file)
index 0000000..73ee692
--- /dev/null
+++ b/Tizen.System/Interop/Interop.RuntimeInfo.cs
@@ -0,0 +1,97 @@
+/// Copyright 2016 by Samsung Electronics, Inc.,
+///
+/// This software is the confidential and proprietary information
+/// of Samsung Electronics, Inc. ("Confidential Information"). You
+/// shall not disclose such Confidential Information and shall use
+/// it only in accordance with the terms of the license agreement
+/// you entered into with Samsung.
+
+
+using System;
+using System.Runtime.InteropServices;
+using Tizen.System;
+
+internal static partial class Interop
+{
+    internal static partial class RuntimeInfo
+    {
+        public delegate void RuntimeInformationChangedCallback(RuntimeInformationKey key, IntPtr userData);
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct MemoryInfo
+        {
+            public readonly int Total;
+            public readonly int Used;
+            public readonly int Free;
+            public readonly int Cache;
+            public readonly int Swap;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct ProcessMemoryInfo
+        {
+            public readonly int Vsz;
+            public readonly int Rss;
+            public readonly int Pss;
+            public readonly int SharedClean;
+            public readonly int SharedDirty;
+            public readonly int PrivateClean;
+            public readonly int PrivateDirty;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct CpuUsage
+        {
+            public readonly double User;
+            public readonly double System;
+            public readonly double Nice;
+            public readonly double IoWait;
+        }
+
+        [StructLayout(LayoutKind.Sequential)]
+        public struct ProcessCpuUsage
+        {
+            public readonly uint UTime;
+            public readonly uint STime;
+        }
+
+        [DllImport(Libraries.RuntimeInfo, EntryPoint = "runtime_info_get_value_int")]
+        public static extern int GetValue(RuntimeInformationKey key, out int status);
+
+        [DllImport(Libraries.RuntimeInfo, EntryPoint = "runtime_info_get_value_bool")]
+        public static extern int GetValue(RuntimeInformationKey key, out bool status);
+
+        [DllImport(Libraries.RuntimeInfo, EntryPoint = "runtime_info_get_value_double")]
+        public static extern int GetValue(RuntimeInformationKey key, out double status);
+
+        [DllImport(Libraries.RuntimeInfo, EntryPoint = "runtime_info_get_value_string")]
+        public static extern int GetValue(RuntimeInformationKey key, out string status);
+
+        [DllImport(Libraries.RuntimeInfo, EntryPoint = "runtime_info_get_system_memory_info")]
+        public static extern int GetSystemMemoryInfo(out MemoryInfo memoryInfo);
+
+        [DllImport(Libraries.RuntimeInfo, EntryPoint = "runtime_info_get_process_memory_info")]
+        public static extern int GetProcessMemoryInfo(int[] pid, int size, out ProcessMemoryInfo[] array);
+
+        [DllImport(Libraries.RuntimeInfo, EntryPoint = "runtime_info_get_cpu_usage")]
+        public static extern int GetCpuUsage(out CpuUsage cpuUsage);
+
+        [DllImport(Libraries.RuntimeInfo, EntryPoint = "runtime_info_get_process_cpu_usage")]
+        public static extern int GetProcessCpuUsage(int[] pid, int size, out ProcessCpuUsage[] array);
+
+        [DllImport(Libraries.RuntimeInfo, EntryPoint = "runtime_info_get_processor_count")]
+        public static extern int GetProcessorCount(out int processorCount);
+
+        [DllImport(Libraries.RuntimeInfo, EntryPoint = "runtime_info_get_processor_current_frequency")]
+        public static extern int GetProcessorCurrentFrequency(int coreId, out int cpuFreq);
+
+        [DllImport(Libraries.RuntimeInfo, EntryPoint = "runtime_info_get_processor_max_frequency")]
+        public static extern int GetProcessorMaxFrequency(int coreId, out int cpuFreq);
+
+        [DllImport(Libraries.RuntimeInfo, EntryPoint = "runtime_info_set_changed_cb")]
+        public static extern int SetRuntimeInfoChangedCallback(RuntimeInformationKey runtimeInfoKey, RuntimeInformationChangedCallback cb, IntPtr userData);
+
+        [DllImport(Libraries.RuntimeInfo, EntryPoint = "runtime_info_unset_changed_cb")]
+        public static extern int UnsetRuntimeInfoChangedCallback(RuntimeInformationKey runtimeInfoKey);
+    }
+}

diff --git a/Tizen.System/RuntimeInfo/CpuUsage.cs b/Tizen.System/RuntimeInfo/CpuUsage.cs
new file mode 100644 (file)
index 0000000..0775491
--- /dev/null
+++ b/Tizen.System/RuntimeInfo/CpuUsage.cs
@@ -0,0 +1,67 @@
+/// Copyright 2016 by Samsung Electronics, Inc.,
+///
+/// This software is the confidential and proprietary information
+/// of Samsung Electronics, Inc. ("Confidential Information"). You
+/// shall not disclose such Confidential Information and shall use
+/// it only in accordance with the terms of the license agreement
+/// you entered into with Samsung.
+
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Tizen.System
+{
+    /// <summary>
+    /// Structure for cpu usage.
+    /// </summary>
+    public class CpuUsage
+    {
+        internal CpuUsage(Interop.RuntimeInfo.CpuUsage usage)
+        {
+            IoWait = usage.IoWait;
+            Nice = usage.IoWait;
+            System = usage.System;
+            User = usage.User;
+        }
+        /// <summary>
+        /// Time running un-niced user processes (Percent)
+        /// </summary>
+        public double User { get; internal set; }
+        /// <summary>
+        /// Time running kernel processes (Percent)
+        /// </summary>
+        public double System { get; internal set; }
+        /// <summary>
+        /// Time running niced user processes (Percent)
+        /// </summary>
+        public double Nice { get; internal set; }
+        /// <summary>
+        /// Time waiting for I/O completion (Percent)
+        /// </summary>
+        public double IoWait { get; internal set; }
+    }
+
+    /// <summary>
+    /// Structure for cpu usage per processes
+    /// </summary>
+    public class ProcessCpuUsage
+    {
+        internal ProcessCpuUsage(Interop.RuntimeInfo.ProcessCpuUsage usage)
+        {
+            UTime = usage.UTime;
+            STime = usage.STime;
+        }
+        /// <summary>
+        /// Amount of time that this process has been scheduled in user mode (clock ticks)
+        /// </summary>
+        public uint UTime { get; internal set; }
+        /// <summary>
+        /// Amount of time that this process has been scheduled in kernel mode (clock ticks)
+        /// </summary>
+        public uint STime { get; internal set; }
+    }
+}

diff --git a/Tizen.System/RuntimeInfo/Enumerations.cs b/Tizen.System/RuntimeInfo/Enumerations.cs
new file mode 100644 (file)
index 0000000..d1f0702
--- /dev/null
+++ b/Tizen.System/RuntimeInfo/Enumerations.cs
@@ -0,0 +1,148 @@
+/// Copyright 2016 by Samsung Electronics, Inc.,
+///
+/// This software is the confidential and proprietary information
+/// of Samsung Electronics, Inc. ("Confidential Information"). You
+/// shall not disclose such Confidential Information and shall use
+/// it only in accordance with the terms of the license agreement
+/// you entered into with Samsung.
+
+
+using System;
+
+namespace Tizen.System
+{
+    /// <summary>
+    /// Enumeration for keys for runtime information
+    /// </summary>
+    public enum RuntimeInformationKey
+    {
+        /// <summary>
+        /// Indicates whether Bluetooth is enabled.
+        /// </summary>
+        Bluetooth = 2,
+        /// <summary>
+        /// Indicates whether Wi-Fi hotspot is enabled.
+        /// <see cref="WifiStatus"/>
+        /// </summary>
+        WifiHotspot = 3,
+        /// <summary>
+        /// Indicates whether Bluetooth tethering is enabled.
+        /// </summary>
+        BluetoothTethering = 4,
+        /// <summary>
+        /// Indicates whether USB tethering is enabled.
+        /// </summary>
+        UsbTethering = 5,
+        /// <summary>
+        /// Indicates whether the location service is allowed to use location data from GPS satellites.
+        /// </summary>
+        LocationService = 6,
+        /// <summary>
+        /// Indicates whether the location service is allowed to use location data from cellular and Wi-Fi.
+        /// </summary>
+        LocationNetworkPosition = 8,
+        /// <summary>
+        /// Indicates Whether the packet data through 3G network is enabled.
+        /// </summary>
+        PacketData = 9,
+        /// <summary>
+        /// Indicates whether data roaming is enabled.
+        /// </summary>
+        DataRoaming = 10,
+        /// <summary>
+        /// Indicates whether vibration is enabled.
+        /// </summary>
+        Vibration = 12,
+        /// <summary>
+        /// Indicates whether audio jack is connected.
+        /// </summary>
+        AudioJack = 17,
+        /// <summary>
+        /// Indicates the current status of GPS.
+        /// <see cref="GpsStatus"/>
+        /// </summary>
+        Gps = 18,
+        /// <summary>
+        /// Indicates the battery is currently charging.
+        /// </summary>
+        BatteryIsCharging = 19,
+        /// <summary>
+        /// Indicates whether TV out is connected.
+        /// </summary>
+        TvOut = 20,
+        /// <summary>
+        /// Indicates the change in audio jack connector type.
+        /// <see cref="AudioJackConnectionType"/>
+        /// </summary>
+        AudioJackConnector = 21,
+        /// <summary>
+        /// Indicates whether USB is connected.
+        /// </summary>
+        Usb = 23,
+        /// <summary>
+        /// Indicates whether charger is connected.
+        /// </summary>
+        Charger = 24,
+        /// <summary>
+        /// Indicates whether auto rotation is enabled.
+        /// </summary>
+        AutoRotation = 26
+    }
+
+    /// <summary>
+    /// Enumeration for Wi-Fi status
+    /// </summary>
+    public enum WifiStatus
+    {
+        /// <summary>
+        /// Wi-Fi is disabled.
+        /// </summary>
+        Disabled,
+        /// <summary>
+        /// Wi-Fi is enabled and network connection is not established.
+        /// </summary>
+        Unconnected,
+        /// <summary>
+        ///  Network connection is established in Wi-Fi network.
+        /// </summary>
+        Connected
+    }
+
+    /// <summary>
+    /// Enumeration for GPS status.
+    /// </summary>
+    public enum GpsStatus
+    {
+        /// <summary>
+        /// GPS is disabled.
+        /// </summary>
+        Disabled,
+        /// <summary>
+        /// GPS is searching for satellites.
+        /// </summary>
+        Searching,
+        /// <summary>
+        /// GPS connection is established.
+        /// </summary>
+        Connected
+    }
+
+    /// <summary>
+    /// Enumeration for type of audio jack connected.
+    /// </summary>
+    public enum AudioJackConnectionType
+    {
+        /// <summary>
+        /// Audio jack is not connected
+        /// </summary>
+        Unconnected,
+        /// <summary>
+        /// 3-conductor wire is connected.
+        /// </summary>
+        ThreeWireConnected,
+        /// <summary>
+        /// 4-conductor wire is connected.
+        /// </summary>
+        FourWireConnected
+    }
+}

diff --git a/Tizen.System/RuntimeInfo/MemoryInformation.cs b/Tizen.System/RuntimeInfo/MemoryInformation.cs
new file mode 100644 (file)
index 0000000..3554700
--- /dev/null
+++ b/Tizen.System/RuntimeInfo/MemoryInformation.cs
@@ -0,0 +1,97 @@
+/// Copyright 2016 by Samsung Electronics, Inc.,
+///
+/// This software is the confidential and proprietary information
+/// of Samsung Electronics, Inc. ("Confidential Information"). You
+/// shall not disclose such Confidential Information and shall use
+/// it only in accordance with the terms of the license agreement
+/// you entered into with Samsung.
+
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Tizen.System
+{
+    /// <summary>
+    /// Memory information.
+    /// </summary>
+    public class SystemMemoryInformation
+    {
+        internal SystemMemoryInformation(Interop.RuntimeInfo.MemoryInfo info)
+        {
+            Total = info.Total;
+            Used = info.Used;
+            Cache = info.Cache;
+            Free = info.Free;
+            Swap = info.Swap;
+        }
+        /// <summary>
+        /// Total memory (KiB)
+        /// </summary>
+        public int Total { get; internal set; }
+        /// <summary>
+        /// Used memory (KiB)
+        /// </summary>
+        public int Used { get; internal set; }
+        /// <summary>
+        /// Free memory (KiB)
+        /// </summary>
+        public int Free { get; internal set; }
+        /// <summary>
+        /// Cache memory (KiB)
+        /// </summary>
+        public int Cache { get; internal set; }
+        /// <summary>
+        /// Swap memory (KiB)
+        /// </summary>
+        public int Swap { get; internal set; }
+    }
+
+    /// <summary>
+    /// Memory information per processes
+    /// </summary>
+    public class ProcessMemoryInformation
+    {
+        internal ProcessMemoryInformation(Interop.RuntimeInfo.ProcessMemoryInfo info)
+        {
+            PrivateClean = info.PrivateClean;
+            PrivateDirty = info.PrivateDirty;
+            Pss = info.Pss;
+            Rss = info.Rss;
+            SharedClean = info.SharedClean;
+            SharedDirty = info.SharedDirty;
+            Vsz = info.Vsz;
+        }
+        /// <summary>
+        /// Virtual memory size (KiB)
+        /// </summary>
+        public int Vsz { get; internal set; }
+        /// <summary>
+        /// Resident set size (KiB)
+        /// </summary>
+        public int Rss { get; internal set; }
+        /// <summary>
+        /// Proportional set size (KiB)
+        /// </summary>
+        public int Pss { get; internal set; }
+        /// <summary>
+        /// Not modified and mapped by other processes (KiB)
+        /// </summary>
+        public int SharedClean { get; internal set; }
+        /// <summary>
+        /// Modified and mapped by other processes (KiB)
+        /// </summary>
+        public int SharedDirty { get; internal set; }
+        /// <summary>
+        /// Not modified and available only to that process (KiB)
+        /// </summary>
+        public int PrivateClean { get; internal set; }
+        /// <summary>
+        /// Modified and available only to that process (KiB)
+        /// </summary>
+        public int PrivateDirty { get; internal set; }
+    }
+}

diff --git a/Tizen.System/RuntimeInfo/RuntimeInfoErrorFactory.cs b/Tizen.System/RuntimeInfo/RuntimeInfoErrorFactory.cs
new file mode 100755 (executable)
index 0000000..860e876
--- /dev/null
+++ b/Tizen.System/RuntimeInfo/RuntimeInfoErrorFactory.cs
@@ -0,0 +1,55 @@
+using System;
+using Tizen.Internals.Errors;
+
+namespace Tizen.System
+{
+    internal enum RuntimeInfoError
+    {
+        None = ErrorCode.None,
+        InvalidParameter = ErrorCode.InvalidParameter,
+        OutOfMemory = ErrorCode.OutOfMemory,
+        Io = ErrorCode.IoError,
+        RemoteIo = ErrorCode.RemoteIo,
+        InvalidOperation = ErrorCode.InvalidOperation,
+        PermissionDenied = ErrorCode.PermissionDenied,
+        NotSupported = ErrorCode.NotSupported
+    }
+
+    internal static class RuntimeInfoErrorFactory
+    {
+        internal const string LogTag = "Tizen.System.RuntimeInformation";
+
+        internal static void ThrowException(int err)
+        {
+            RuntimeInfoError error = (RuntimeInfoError)err;
+            if (error == RuntimeInfoError.OutOfMemory)
+            {
+                throw new InvalidOperationException("Out of memory");
+            }
+            else if (error == RuntimeInfoError.InvalidParameter)
+            {
+                throw new ArgumentException("Invalid parameter");
+            }
+            else if (error == RuntimeInfoError.Io)
+            {
+                throw new ArgumentException("I/O Error");
+            }
+            else if (error == RuntimeInfoError.RemoteIo)
+            {
+                throw new ArgumentException("Remote I/O Error");
+            }
+            else if (error == RuntimeInfoError.InvalidOperation)
+            {
+                throw new ArgumentException("Invalid operation");
+            }
+            else if (error == RuntimeInfoError.PermissionDenied)
+            {
+                throw new ArgumentException("Permission denied");
+            }
+            else if (error == RuntimeInfoError.NotSupported)
+            {
+                throw new ArgumentException("Not supported");
+            }
+        }
+    }
+}

diff --git a/Tizen.System/RuntimeInfo/RuntimeInformation.cs b/Tizen.System/RuntimeInfo/RuntimeInformation.cs
new file mode 100644 (file)
index 0000000..4e83868
--- /dev/null
+++ b/Tizen.System/RuntimeInfo/RuntimeInformation.cs
@@ -0,0 +1,905 @@
+/// Copyright 2016 by Samsung Electronics, Inc.,
+///
+/// This software is the confidential and proprietary information
+/// of Samsung Electronics, Inc. ("Confidential Information"). You
+/// shall not disclose such Confidential Information and shall use
+/// it only in accordance with the terms of the license agreement
+/// you entered into with Samsung.
+
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Tizen.System
+{
+    /// <summary>
+    /// The RuntimeInformation provides functions to obtain runtime information of various system preferences.
+    /// </summary>
+    public static class RuntimeInformation
+    {
+        private static event EventHandler<RuntimeKeyStatusChangedEventArgs> s_bluetoothEnabled;
+        private static event EventHandler<RuntimeKeyStatusChangedEventArgs> s_wifiHotspotEnabled;
+        private static event EventHandler<RuntimeKeyStatusChangedEventArgs> s_bluetoothTetheringEnabled;
+        private static event EventHandler<RuntimeKeyStatusChangedEventArgs> s_usbTetheringEnabled;
+        private static event EventHandler<RuntimeKeyStatusChangedEventArgs> s_locationServiceEnabled;
+        private static event EventHandler<RuntimeKeyStatusChangedEventArgs> s_locationNetworkPositionEnabled;
+        private static event EventHandler<RuntimeKeyStatusChangedEventArgs> s_packetDataEnabled;
+        private static event EventHandler<RuntimeKeyStatusChangedEventArgs> s_dataRoamingEnabled;
+        private static event EventHandler<RuntimeKeyStatusChangedEventArgs> s_vibrationEnabled;
+        private static event EventHandler<RuntimeKeyStatusChangedEventArgs> s_audioJackConnected;
+        private static event EventHandler<RuntimeKeyStatusChangedEventArgs> s_gpsStatusChanged;
+        private static event EventHandler<RuntimeKeyStatusChangedEventArgs> s_batteryIsCharging;
+        private static event EventHandler<RuntimeKeyStatusChangedEventArgs> s_tvOutConnected;
+        private static event EventHandler<RuntimeKeyStatusChangedEventArgs> s_audioJackConnectorChanged;
+        private static event EventHandler<RuntimeKeyStatusChangedEventArgs> s_usbConnected;
+        private static event EventHandler<RuntimeKeyStatusChangedEventArgs> s_chargerConnected;
+        private static event EventHandler<RuntimeKeyStatusChangedEventArgs> s_autoRotationEnabled;
+
+        private static readonly Interop.RuntimeInfo.RuntimeInformationChangedCallback s_runtimeInfoChangedCallback = (RuntimeInformationKey key, IntPtr userData) =>
+        {
+            RuntimeKeyStatusChangedEventArgs eventArgs = new RuntimeKeyStatusChangedEventArgs()
+            {
+                Key = key
+            };
+            switch (key)
+            {
+                case RuntimeInformationKey.Bluetooth:
+                    {
+                        s_bluetoothEnabled?.Invoke(null, eventArgs);
+                        break;
+                    };
+                case RuntimeInformationKey.WifiHotspot:
+                    {
+                        s_wifiHotspotEnabled?.Invoke(null, eventArgs);
+                        break;
+                    };
+                case RuntimeInformationKey.BluetoothTethering:
+                    {
+                        s_bluetoothTetheringEnabled?.Invoke(null, eventArgs);
+                        break;
+                    };
+                case RuntimeInformationKey.UsbTethering:
+                    {
+                        s_usbTetheringEnabled?.Invoke(null, eventArgs);
+                        break;
+                    };
+                case RuntimeInformationKey.LocationService:
+                    {
+                        s_locationServiceEnabled?.Invoke(null, eventArgs);
+                        break;
+                    };
+                case RuntimeInformationKey.LocationNetworkPosition:
+                    {
+                        s_locationNetworkPositionEnabled?.Invoke(null, eventArgs);
+                        break;
+                    };
+                case RuntimeInformationKey.PacketData:
+                    {
+                        s_packetDataEnabled?.Invoke(null, eventArgs);
+                        break;
+                    };
+                case RuntimeInformationKey.DataRoaming:
+                    {
+                        s_dataRoamingEnabled?.Invoke(null, eventArgs);
+                        break;
+                    };
+                case RuntimeInformationKey.Vibration:
+                    {
+                        s_vibrationEnabled?.Invoke(null, eventArgs);
+                        break;
+                    };
+                case RuntimeInformationKey.AudioJack:
+                    {
+                        s_audioJackConnected?.Invoke(null, eventArgs);
+                        break;
+                    };
+                case RuntimeInformationKey.Gps:
+                    {
+                        s_gpsStatusChanged?.Invoke(null, eventArgs);
+                        break;
+                    };
+                case RuntimeInformationKey.BatteryIsCharging:
+                    {
+                        s_batteryIsCharging?.Invoke(null, eventArgs);
+                        break;
+                    };
+                case RuntimeInformationKey.TvOut:
+                    {
+                        s_tvOutConnected?.Invoke(null, eventArgs);
+                        break;
+                    };
+                case RuntimeInformationKey.AudioJackConnector:
+                    {
+                        s_audioJackConnectorChanged?.Invoke(null, eventArgs);
+                        break;
+                    };
+                case RuntimeInformationKey.Usb:
+                    {
+                        s_usbConnected?.Invoke(null, eventArgs);
+                        break;
+                    };
+                case RuntimeInformationKey.Charger:
+                    {
+                        s_chargerConnected?.Invoke(null, eventArgs);
+                        break;
+                    };
+                case RuntimeInformationKey.AutoRotation:
+                    {
+                        s_autoRotationEnabled?.Invoke(null, eventArgs);
+                        break;
+                    };
+                default:
+                    break;
+            };
+        };
+
+        internal static readonly Dictionary<RuntimeInformationKey, Type> s_keyDataTypeMapping = new Dictionary<RuntimeInformationKey, Type>
+        {
+            [RuntimeInformationKey.Bluetooth] = typeof(bool),
+            [RuntimeInformationKey.WifiHotspot] = typeof(bool),
+            [RuntimeInformationKey.BluetoothTethering] = typeof(bool),
+            [RuntimeInformationKey.UsbTethering] = typeof(bool),
+            [RuntimeInformationKey.LocationService] = typeof(bool),
+            [RuntimeInformationKey.LocationNetworkPosition] = typeof(bool),
+            [RuntimeInformationKey.PacketData] = typeof(bool),
+            [RuntimeInformationKey.DataRoaming] = typeof(bool),
+            [RuntimeInformationKey.Vibration] = typeof(bool),
+            [RuntimeInformationKey.AudioJack] = typeof(bool),
+            [RuntimeInformationKey.BatteryIsCharging] = typeof(bool),
+            [RuntimeInformationKey.TvOut] = typeof(bool),
+            [RuntimeInformationKey.Usb] = typeof(bool),
+            [RuntimeInformationKey.Charger] = typeof(bool),
+            [RuntimeInformationKey.AutoRotation] = typeof(bool),
+            [RuntimeInformationKey.Gps] = typeof(int),
+            [RuntimeInformationKey.AudioJackConnector] = typeof(int)
+        };
+
+        /// <summary>
+        /// This function gets current state of the given key which represents specific runtime information
+        /// </summary>
+        /// <param name="key">The runtime information key for which the current should be read </param>
+        /// <returns>The current status of the given key</returns>
+        internal static object GetStatus(RuntimeInformationKey key)
+        {
+            if (s_keyDataTypeMapping[key] == typeof(int))
+            {
+                int status;
+                int ret = Interop.RuntimeInfo.GetValue(key, out status);
+                if (ret != (int)RuntimeInfoError.None)
+                {
+                    Log.Error(RuntimeInfoErrorFactory.LogTag, "Interop failed to get value for key {0}", key.ToString());
+                    RuntimeInfoErrorFactory.ThrowException(ret);
+                }
+
+                return status;
+            }
+            else
+            {
+                bool status;
+                int ret = Interop.RuntimeInfo.GetValue(key, out status);
+                if (ret != (int)RuntimeInfoError.None)
+                {
+                    Log.Error(RuntimeInfoErrorFactory.LogTag, "Interop failed to get value for key {0}", key.ToString());
+                    RuntimeInfoErrorFactory.ThrowException(ret);
+                }
+
+                return status;
+            }
+        }
+
+        /// <summary>
+        /// Validates the data type of the status represented by Runtime Key.
+        /// Note that this is a generic method.
+        /// </summary>
+        /// <typeparam name="T">The generic type to validate.</typeparam>
+        /// <param name="key">The runtime information key for which the status type is validated </param>
+        /// <returns>true if the data type matches</returns>.
+        public static bool Is<T>(RuntimeInformationKey key)
+        {
+            if (!s_keyDataTypeMapping.ContainsKey(key))
+            {
+                Log.Error(RuntimeInfoErrorFactory.LogTag, "Invalid data type");
+                throw new ArgumentException("Invalid parameter");
+            }
+
+            return s_keyDataTypeMapping[key] == typeof(T);
+        }
+
+        /// <summary>
+        /// Gets the status of Runtime Key.
+        /// Note that this is a generic method.
+        /// </summary>
+        /// <typeparam name="T">The generic type to return.</typeparam>
+        /// <param name="key">The runtime information key for which the current should be read </param>
+        /// <returns>The current status of the given key</returns>.
+        public static T GetStatus<T>(RuntimeInformationKey key)
+        {
+            return (T)GetStatus(key);
+        }
+
+        /// <summary>
+        /// The System memory information
+        /// </summary>
+        public static SystemMemoryInformation GetSystemMemoryInformation()
+        {
+            Interop.RuntimeInfo.MemoryInfo info = new Interop.RuntimeInfo.MemoryInfo();
+            int ret = Interop.RuntimeInfo.GetSystemMemoryInfo(out info);
+            if (ret != (int)RuntimeInfoError.None)
+            {
+                Log.Error(RuntimeInfoErrorFactory.LogTag, "Interop failed to get System memory information");
+                RuntimeInfoErrorFactory.ThrowException(ret);
+            }
+
+            return new SystemMemoryInformation(info);
+        }
+
+        /// <summary>
+        /// Gets memory information per processes
+        /// </summary>
+        /// <param name="pid">List of unique process ids </param>
+        /// <returns>List of memory information per processes</returns>
+        public static IDictionary<int, ProcessMemoryInformation> GetProcessMemoryInformation(IEnumerable<int> pid)
+        {
+            int[] processArray = pid.ToArray<int>();
+            Interop.RuntimeInfo.ProcessMemoryInfo[] processMemoryArray = new Interop.RuntimeInfo.ProcessMemoryInfo[pid.Count<int>()];
+            Dictionary<int, ProcessMemoryInformation> map = new Dictionary<int, ProcessMemoryInformation>();
+            int ret = Interop.RuntimeInfo.GetProcessMemoryInfo(processArray, pid.Count<int>(), out processMemoryArray);
+            if (ret != (int)RuntimeInfoError.None)
+            {
+                Log.Error(RuntimeInfoErrorFactory.LogTag, "Interop failed to get Process memory information");
+                RuntimeInfoErrorFactory.ThrowException(ret);
+            }
+
+            int idx = 0;
+            foreach (Interop.RuntimeInfo.ProcessMemoryInfo cur in processMemoryArray)
+            {
+                ProcessMemoryInformation processMemory = new ProcessMemoryInformation(cur);
+                map.Add(processArray[idx], processMemory);
+                idx++;
+            }
+
+            return map;
+        }
+
+        /// <summary>
+        /// The CPU runtime
+        /// </summary>
+        public static CpuUsage GetCpuUsage()
+        {
+            Interop.RuntimeInfo.CpuUsage usage = new Interop.RuntimeInfo.CpuUsage();
+            int ret = Interop.RuntimeInfo.GetCpuUsage(out usage);
+            if (ret != (int)RuntimeInfoError.None)
+            {
+                Log.Error(RuntimeInfoErrorFactory.LogTag, "Interop failed to get cpu usage");
+                RuntimeInfoErrorFactory.ThrowException(ret);
+            }
+            return new CpuUsage(usage);
+        }
+
+        /// <summary>
+        /// The CPU run time per process
+        /// </summary>
+        /// <param name="pid">List of unique process ids </param>
+        /// <returns>List of CPU usage information per processes</returns>
+        public static IDictionary<int, ProcessCpuUsage> GetProcessCpuUsage(IEnumerable<int> pid)
+        {
+            int[] processArray = pid.ToArray<int>();
+            Interop.RuntimeInfo.ProcessCpuUsage[] processCpuUsageArray = new Interop.RuntimeInfo.ProcessCpuUsage[pid.Count<int>()];
+            Dictionary<int, ProcessCpuUsage> map = new Dictionary<int, ProcessCpuUsage>();
+            int ret = Interop.RuntimeInfo.GetProcessCpuUsage(processArray, pid.Count<int>(), out processCpuUsageArray);
+            if (ret != (int)RuntimeInfoError.None)
+            {
+                Log.Error(RuntimeInfoErrorFactory.LogTag, "Interop failed to get Process cpu usage");
+                RuntimeInfoErrorFactory.ThrowException(ret);
+            }
+
+            int idx = 0;
+            foreach (Interop.RuntimeInfo.ProcessCpuUsage cur in processCpuUsageArray)
+            {
+                ProcessCpuUsage processUsage = new ProcessCpuUsage(cur);
+                map.Add(processArray[idx], processUsage);
+                idx++;
+            }
+
+            return map;
+        }
+
+        /// <summary>
+        /// The number of processors
+        /// </summary>
+        public static int ProcessorCount
+        {
+            get
+            {
+                int count;
+                int ret = Interop.RuntimeInfo.GetProcessorCount(out count);
+                if (ret != (int)RuntimeInfoError.None)
+                {
+                    Log.Error(RuntimeInfoErrorFactory.LogTag, "Interop failed to get Processor count");
+                    RuntimeInfoErrorFactory.ThrowException(ret);
+                }
+
+                return count;
+            }
+        }
+
+        /// <summary>
+        /// Gets the current frequency of processor
+        /// </summary>
+        /// <param name="coreId">The index (from 0) of CPU core that you want to know the frequency</param>
+        /// <returns>The current frequency(MHz) of processor</returns>
+        public static int GetProcessorCurrentFrequency(int coreId)
+        {
+            int frequency;
+            int ret = Interop.RuntimeInfo.GetProcessorCurrentFrequency(coreId, out frequency);
+            if (ret != (int)RuntimeInfoError.None)
+            {
+                Log.Error(RuntimeInfoErrorFactory.LogTag, "Interop failed to get Processor current frequency");
+                RuntimeInfoErrorFactory.ThrowException(ret);
+            }
+            return frequency;
+        }
+
+        /// <summary>
+        /// Gets the max frequency of processor
+        /// </summary>
+        /// <param name="coreId">The index (from 0) of CPU core that you want to know the frequency</param>
+        /// <returns>The max frequency(MHz) of processor</returns>
+        public static int GetProcessorMaxFrequency(int coreId)
+        {
+            int frequency;
+            int ret = Interop.RuntimeInfo.GetProcessorMaxFrequency(coreId, out frequency);
+            if (ret != (int)RuntimeInfoError.None)
+            {
+                Log.Error(RuntimeInfoErrorFactory.LogTag, "Interop failed to get  Processor max frequency");
+                RuntimeInfoErrorFactory.ThrowException(ret);
+            }
+            return frequency;
+        }
+
+        /// <summary>
+        /// (event) BluetoothEnabled is rasied when system preference for bluetooth is changed.
+        /// </summary>
+        public static event EventHandler<RuntimeKeyStatusChangedEventArgs> BluetoothEnabled
+        {
+            add
+            {
+                if (s_bluetoothEnabled == null)
+                {
+                    int ret = Interop.RuntimeInfo.SetRuntimeInfoChangedCallback(RuntimeInformationKey.Bluetooth, s_runtimeInfoChangedCallback, IntPtr.Zero);
+                    if (ret != (int)RuntimeInfoError.None)
+                    {
+                        Log.Error(RuntimeInfoErrorFactory.LogTag, "Interop failed to add event handler");
+                        RuntimeInfoErrorFactory.ThrowException(ret);
+                    }
+                }
+                s_bluetoothEnabled += value;
+            }
+            remove
+            {
+                s_bluetoothEnabled -= value;
+                if (s_bluetoothEnabled == null)
+                {
+                    int ret = Interop.RuntimeInfo.UnsetRuntimeInfoChangedCallback(RuntimeInformationKey.Bluetooth);
+                    if (ret != (int)RuntimeInfoError.None)
+                    {
+                        Log.Error(RuntimeInfoErrorFactory.LogTag, "Interop failed to add event handler");
+                        RuntimeInfoErrorFactory.ThrowException(ret);
+                    }
+                }
+            }
+        }
+        /// <summary>
+        /// (event) WifiHotspotEnabled is rasied when system preference for Wi-Fi is changed.
+        /// </summary>
+        public static event EventHandler<RuntimeKeyStatusChangedEventArgs> WifiHotspotEnabled
+        {
+            add
+            {
+                if (s_wifiHotspotEnabled == null)
+                {
+                    int ret = Interop.RuntimeInfo.SetRuntimeInfoChangedCallback(RuntimeInformationKey.WifiHotspot, s_runtimeInfoChangedCallback, IntPtr.Zero);
+                    if (ret != (int)RuntimeInfoError.None)
+                    {
+                        Log.Error(RuntimeInfoErrorFactory.LogTag, "Interop failed to add event handler");
+                        RuntimeInfoErrorFactory.ThrowException(ret);
+                    }
+                }
+                s_wifiHotspotEnabled += value;
+            }
+            remove
+            {
+                s_wifiHotspotEnabled -= value;
+                if (s_wifiHotspotEnabled == null)
+                {
+                    int ret = Interop.RuntimeInfo.UnsetRuntimeInfoChangedCallback(RuntimeInformationKey.WifiHotspot);
+                    if (ret != (int)RuntimeInfoError.None)
+                    {
+                        Log.Error(RuntimeInfoErrorFactory.LogTag, "Interop failed to add event handler");
+                        RuntimeInfoErrorFactory.ThrowException(ret);
+                    }
+                }
+            }
+        }
+        /// <summary>
+        /// (event) BluetoothTetheringEnabled is rasied when system preference for bluetooth tethering is changed.
+        /// </summary>
+        public static event EventHandler<RuntimeKeyStatusChangedEventArgs> BluetoothTetheringEnabled
+        {
+            add
+            {
+                if (s_bluetoothTetheringEnabled == null)
+                {
+                    int ret = Interop.RuntimeInfo.SetRuntimeInfoChangedCallback(RuntimeInformationKey.BluetoothTethering, s_runtimeInfoChangedCallback, IntPtr.Zero);
+                    if (ret != (int)RuntimeInfoError.None)
+                    {
+                        Log.Error(RuntimeInfoErrorFactory.LogTag, "Interop failed to add event handler");
+                        RuntimeInfoErrorFactory.ThrowException(ret);
+                    }
+                }
+                s_bluetoothTetheringEnabled += value;
+            }
+            remove
+            {
+                s_bluetoothTetheringEnabled -= value;
+                if (s_bluetoothTetheringEnabled == null)
+                {
+                    int ret = Interop.RuntimeInfo.UnsetRuntimeInfoChangedCallback(RuntimeInformationKey.BluetoothTethering);
+                    if (ret != (int)RuntimeInfoError.None)
+                    {
+                        Log.Error(RuntimeInfoErrorFactory.LogTag, "Interop failed to add event handler");
+                        RuntimeInfoErrorFactory.ThrowException(ret);
+                    }
+                }
+            }
+        }
+        /// <summary>
+        /// (event) UsbTetheringEnabled is rasied when system preference for USB terhering is changed.
+        /// </summary>
+        public static event EventHandler<RuntimeKeyStatusChangedEventArgs> UsbTetheringEnabled
+        {
+            add
+            {
+                if (s_usbTetheringEnabled == null)
+                {
+                    int ret = Interop.RuntimeInfo.SetRuntimeInfoChangedCallback(RuntimeInformationKey.UsbTethering, s_runtimeInfoChangedCallback, IntPtr.Zero);
+                    if (ret != (int)RuntimeInfoError.None)
+                    {
+                        Log.Error(RuntimeInfoErrorFactory.LogTag, "Interop failed to add event handler");
+                        RuntimeInfoErrorFactory.ThrowException(ret);
+                    }
+                }
+                s_usbTetheringEnabled += value;
+            }
+            remove
+            {
+                s_usbTetheringEnabled -= value;
+                if (s_usbTetheringEnabled == null)
+                {
+                    int ret = Interop.RuntimeInfo.UnsetRuntimeInfoChangedCallback(RuntimeInformationKey.UsbTethering);
+                    if (ret != (int)RuntimeInfoError.None)
+                    {
+                        Log.Error(RuntimeInfoErrorFactory.LogTag, "Interop failed to add event handler");
+                        RuntimeInfoErrorFactory.ThrowException(ret);
+                    }
+                }
+            }
+        }
+        /// <summary>
+        /// (event) LocationServiceEnabled is rasied when system preference for location service is changed.
+        /// </summary>
+        public static event EventHandler<RuntimeKeyStatusChangedEventArgs> LocationServiceEnabled
+        {
+            add
+            {
+                if (s_locationServiceEnabled == null)
+                {
+                    int ret = Interop.RuntimeInfo.SetRuntimeInfoChangedCallback(RuntimeInformationKey.LocationService, s_runtimeInfoChangedCallback, IntPtr.Zero);
+                    if (ret != (int)RuntimeInfoError.None)
+                    {
+                        Log.Error(RuntimeInfoErrorFactory.LogTag, "Interop failed to add event handler");
+                        RuntimeInfoErrorFactory.ThrowException(ret);
+                    }
+                }
+                s_locationServiceEnabled += value;
+            }
+            remove
+            {
+                s_locationServiceEnabled -= value;
+                if (s_locationServiceEnabled == null)
+                {
+                    int ret = Interop.RuntimeInfo.UnsetRuntimeInfoChangedCallback(RuntimeInformationKey.LocationService);
+                    RuntimeInfoErrorFactory.ThrowException(ret);
+                }
+            }
+        }
+        /// <summary>
+        /// (event) LocationNetworkPositionEnabled is rasied when system preference for allowing location service to use location data from cellular and Wi-Fi is changed.
+        /// </summary>
+        public static event EventHandler<RuntimeKeyStatusChangedEventArgs> LocationNetworkPositionEnabled
+        {
+            add
+            {
+                if (s_locationNetworkPositionEnabled == null)
+                {
+                    int ret = Interop.RuntimeInfo.SetRuntimeInfoChangedCallback(RuntimeInformationKey.LocationNetworkPosition, s_runtimeInfoChangedCallback, IntPtr.Zero);
+                    if (ret != (int)RuntimeInfoError.None)
+                    {
+                        Log.Error(RuntimeInfoErrorFactory.LogTag, "Interop failed to add event handler");
+                        RuntimeInfoErrorFactory.ThrowException(ret);
+                    }
+                }
+                s_locationNetworkPositionEnabled += value;
+            }
+            remove
+            {
+                s_locationNetworkPositionEnabled -= value;
+                if (s_locationNetworkPositionEnabled == null)
+                {
+                    int ret = Interop.RuntimeInfo.UnsetRuntimeInfoChangedCallback(RuntimeInformationKey.LocationNetworkPosition);
+                    if (ret != (int)RuntimeInfoError.None)
+                    {
+                        Log.Error(RuntimeInfoErrorFactory.LogTag, "Interop failed to add event handler");
+                        RuntimeInfoErrorFactory.ThrowException(ret);
+                    }
+                }
+            }
+        }
+        /// <summary>
+        /// (event) PacketDataEnabled is rasied when system preference for package data through 3G network is changed.
+        /// </summary>
+        public static event EventHandler<RuntimeKeyStatusChangedEventArgs> PacketDataEnabled
+        {
+            add
+            {
+                if (s_packetDataEnabled == null)
+                {
+                    int ret = Interop.RuntimeInfo.SetRuntimeInfoChangedCallback(RuntimeInformationKey.PacketData, s_runtimeInfoChangedCallback, IntPtr.Zero);
+                    if (ret != (int)RuntimeInfoError.None)
+                    {
+                        Log.Error(RuntimeInfoErrorFactory.LogTag, "Interop failed to add event handler");
+                        RuntimeInfoErrorFactory.ThrowException(ret);
+                    }
+                }
+                s_packetDataEnabled += value;
+            }
+            remove
+            {
+                s_packetDataEnabled -= value;
+                if (s_packetDataEnabled == null)
+                {
+                    int ret = Interop.RuntimeInfo.UnsetRuntimeInfoChangedCallback(RuntimeInformationKey.PacketData);
+                    if (ret != (int)RuntimeInfoError.None)
+                    {
+                        Log.Error(RuntimeInfoErrorFactory.LogTag, "Interop failed to add event handler");
+                        RuntimeInfoErrorFactory.ThrowException(ret);
+                    }
+                }
+            }
+        }
+        /// <summary>
+        /// (event) DataRoamingEnabled is rasied when system preference for data roaming is changed.
+
+        /// </summary>
+        public static event EventHandler<RuntimeKeyStatusChangedEventArgs> DataRoamingEnabled
+        {
+            add
+            {
+                if (s_dataRoamingEnabled == null)
+                {
+                    int ret = Interop.RuntimeInfo.SetRuntimeInfoChangedCallback(RuntimeInformationKey.DataRoaming, s_runtimeInfoChangedCallback, IntPtr.Zero);
+                    if (ret != (int)RuntimeInfoError.None)
+                    {
+                        Log.Error(RuntimeInfoErrorFactory.LogTag, "Interop failed to add event handler");
+                        RuntimeInfoErrorFactory.ThrowException(ret);
+                    }
+                }
+                s_dataRoamingEnabled += value;
+            }
+            remove
+            {
+                s_dataRoamingEnabled -= value;
+                if (s_dataRoamingEnabled == null)
+                {
+                    int ret = Interop.RuntimeInfo.UnsetRuntimeInfoChangedCallback(RuntimeInformationKey.DataRoaming);
+                    if (ret != (int)RuntimeInfoError.None)
+                    {
+                        Log.Error(RuntimeInfoErrorFactory.LogTag, "Interop failed to add event handler");
+                        RuntimeInfoErrorFactory.ThrowException(ret);
+                    }
+                }
+            }
+        }
+        /// <summary>
+        /// (event) VibrationEnabled is rasied when system preference for vibration is changed.
+        /// </summary>
+        public static event EventHandler<RuntimeKeyStatusChangedEventArgs> VibrationEnabled
+        {
+            add
+            {
+                if (s_vibrationEnabled == null)
+                {
+                    int ret = Interop.RuntimeInfo.SetRuntimeInfoChangedCallback(RuntimeInformationKey.Vibration, s_runtimeInfoChangedCallback, IntPtr.Zero);
+                    if (ret != (int)RuntimeInfoError.None)
+                    {
+                        Log.Error(RuntimeInfoErrorFactory.LogTag, "Interop failed to add event handler");
+                        RuntimeInfoErrorFactory.ThrowException(ret);
+                    }
+                }
+                s_vibrationEnabled += value;
+            }
+            remove
+            {
+                s_vibrationEnabled -= value;
+                if (s_vibrationEnabled == null)
+                {
+                    int ret = Interop.RuntimeInfo.UnsetRuntimeInfoChangedCallback(RuntimeInformationKey.Vibration);
+                    if (ret != (int)RuntimeInfoError.None)
+                    {
+                        Log.Error(RuntimeInfoErrorFactory.LogTag, "Interop failed to add event handler");
+                        RuntimeInfoErrorFactory.ThrowException(ret);
+                    }
+                }
+            }
+        }
+        /// <summary>
+        /// (event) AudioJackConnected is rasied when audio jack is connected/disconnected.
+        /// </summary>
+        public static event EventHandler<RuntimeKeyStatusChangedEventArgs> AudioJackConnected
+        {
+            add
+            {
+                if (s_audioJackConnected == null)
+                {
+                    int ret = Interop.RuntimeInfo.SetRuntimeInfoChangedCallback(RuntimeInformationKey.AudioJack, s_runtimeInfoChangedCallback, IntPtr.Zero);
+                    if (ret != (int)RuntimeInfoError.None)
+                    {
+                        Log.Error(RuntimeInfoErrorFactory.LogTag, "Interop failed to add event handler");
+                        RuntimeInfoErrorFactory.ThrowException(ret);
+                    }
+                }
+                s_audioJackConnected += value;
+            }
+            remove
+            {
+                s_audioJackConnected -= value;
+                if (s_audioJackConnected == null)
+                {
+                    int ret = Interop.RuntimeInfo.UnsetRuntimeInfoChangedCallback(RuntimeInformationKey.AudioJack);
+                    if (ret != (int)RuntimeInfoError.None)
+                    {
+                        Log.Error(RuntimeInfoErrorFactory.LogTag, "Interop failed to add event handler");
+                        RuntimeInfoErrorFactory.ThrowException(ret);
+                    }
+                }
+            }
+        }
+        /// <summary>
+        /// (event) GpsStatusChanged is rasied when status of GPS is changed.
+        /// </summary>
+        public static event EventHandler<RuntimeKeyStatusChangedEventArgs> GpsStatusChanged
+        {
+            add
+            {
+                if (s_gpsStatusChanged == null)
+                {
+                    int ret = Interop.RuntimeInfo.SetRuntimeInfoChangedCallback(RuntimeInformationKey.Gps, s_runtimeInfoChangedCallback, IntPtr.Zero);
+                    if (ret != (int)RuntimeInfoError.None)
+                    {
+                        Log.Error(RuntimeInfoErrorFactory.LogTag, "Interop failed to add event handler");
+                        RuntimeInfoErrorFactory.ThrowException(ret);
+                    }
+                }
+                s_gpsStatusChanged += value;
+            }
+            remove
+            {
+                s_gpsStatusChanged -= value;
+                if (s_gpsStatusChanged == null)
+                {
+                    int ret = Interop.RuntimeInfo.UnsetRuntimeInfoChangedCallback(RuntimeInformationKey.Gps);
+                    if (ret != (int)RuntimeInfoError.None)
+                    {
+                        Log.Error(RuntimeInfoErrorFactory.LogTag, "Interop failed to add event handler");
+                        RuntimeInfoErrorFactory.ThrowException(ret);
+                    }
+                }
+            }
+        }
+        /// <summary>
+        /// (event) BatteryIsCharging is rasied battery is currently charging.
+        /// </summary>
+        public static event EventHandler<RuntimeKeyStatusChangedEventArgs> BatteryIsCharging
+        {
+            add
+            {
+                if (s_batteryIsCharging == null)
+                {
+                    int ret = Interop.RuntimeInfo.SetRuntimeInfoChangedCallback(RuntimeInformationKey.BatteryIsCharging, s_runtimeInfoChangedCallback, IntPtr.Zero);
+                    if (ret != (int)RuntimeInfoError.None)
+                    {
+                        Log.Error(RuntimeInfoErrorFactory.LogTag, "Interop failed to add event handler");
+                        RuntimeInfoErrorFactory.ThrowException(ret);
+                    }
+                }
+                s_batteryIsCharging += value;
+            }
+            remove
+            {
+                s_batteryIsCharging -= value;
+                if (s_batteryIsCharging == null)
+                {
+                    int ret = Interop.RuntimeInfo.UnsetRuntimeInfoChangedCallback(RuntimeInformationKey.BatteryIsCharging);
+                    if (ret != (int)RuntimeInfoError.None)
+                    {
+                        Log.Error(RuntimeInfoErrorFactory.LogTag, "Interop failed to add event handler");
+                        RuntimeInfoErrorFactory.ThrowException(ret);
+                    }
+                }
+            }
+        }
+        /// <summary>
+        /// (event) TvOutConnected is rasied when TV out is connected/disconnected.
+        /// </summary>
+        public static event EventHandler<RuntimeKeyStatusChangedEventArgs> TvOutConnected
+        {
+            add
+            {
+                if (s_tvOutConnected == null)
+                {
+                    int ret = Interop.RuntimeInfo.SetRuntimeInfoChangedCallback(RuntimeInformationKey.TvOut, s_runtimeInfoChangedCallback, IntPtr.Zero);
+                    if (ret != (int)RuntimeInfoError.None)
+                    {
+                        Log.Error(RuntimeInfoErrorFactory.LogTag, "Interop failed to add event handler");
+                        RuntimeInfoErrorFactory.ThrowException(ret);
+                    }
+                }
+                s_tvOutConnected += value;
+            }
+            remove
+            {
+                s_tvOutConnected -= value;
+                if (s_tvOutConnected == null)
+                {
+                    int ret = Interop.RuntimeInfo.UnsetRuntimeInfoChangedCallback(RuntimeInformationKey.TvOut);
+                    if (ret != (int)RuntimeInfoError.None)
+                    {
+                        Log.Error(RuntimeInfoErrorFactory.LogTag, "Interop failed to add event handler");
+                        RuntimeInfoErrorFactory.ThrowException(ret);
+                    }
+                }
+            }
+        }
+        /// <summary>
+        /// (event) AudioJackConnectorChanged is rasied when audio jack connection changes.
+        /// </summary>
+        public static event EventHandler<RuntimeKeyStatusChangedEventArgs> AudioJackConnectorChanged
+        {
+            add
+            {
+                if (s_audioJackConnectorChanged == null)
+                {
+                    int ret = Interop.RuntimeInfo.SetRuntimeInfoChangedCallback(RuntimeInformationKey.AudioJackConnector, s_runtimeInfoChangedCallback, IntPtr.Zero);
+                    if (ret != (int)RuntimeInfoError.None)
+                    {
+                        Log.Error(RuntimeInfoErrorFactory.LogTag, "Interop failed to add event handler");
+                        RuntimeInfoErrorFactory.ThrowException(ret);
+                    }
+                }
+                s_audioJackConnectorChanged += value;
+            }
+            remove
+            {
+                s_audioJackConnectorChanged -= value;
+                if (s_audioJackConnectorChanged == null)
+                {
+                    int ret = Interop.RuntimeInfo.UnsetRuntimeInfoChangedCallback(RuntimeInformationKey.AudioJackConnector);
+                    if (ret != (int)RuntimeInfoError.None)
+                    {
+                        Log.Error(RuntimeInfoErrorFactory.LogTag, "Interop failed to add event handler");
+                        RuntimeInfoErrorFactory.ThrowException(ret);
+                    }
+                }
+            }
+        }
+        /// <summary>
+        /// (event) UsbConnected is rasied when USB is connected/disconnected.
+        /// </summary>
+        public static event EventHandler<RuntimeKeyStatusChangedEventArgs> UsbConnected
+        {
+            add
+            {
+                if (s_usbConnected == null)
+                {
+                    int ret = Interop.RuntimeInfo.SetRuntimeInfoChangedCallback(RuntimeInformationKey.Usb, s_runtimeInfoChangedCallback, IntPtr.Zero);
+                    if (ret != (int)RuntimeInfoError.None)
+                    {
+                        Log.Error(RuntimeInfoErrorFactory.LogTag, "Interop failed to add event handler");
+                        RuntimeInfoErrorFactory.ThrowException(ret);
+                    }
+                }
+                s_usbConnected += value;
+            }
+            remove
+            {
+                s_usbConnected -= value;
+                if (s_usbConnected == null)
+                {
+                    int ret = Interop.RuntimeInfo.UnsetRuntimeInfoChangedCallback(RuntimeInformationKey.Usb);
+                    if (ret != (int)RuntimeInfoError.None)
+                    {
+                        Log.Error(RuntimeInfoErrorFactory.LogTag, "Interop failed to add event handler");
+                        RuntimeInfoErrorFactory.ThrowException(ret);
+                    }
+                }
+            }
+        }
+        /// <summary>
+        /// (event) ChargerConnected is rasied when charger is connected/disconnected.
+        /// </summary>
+        public static event EventHandler<RuntimeKeyStatusChangedEventArgs> ChargerConnected
+        {
+            add
+            {
+                if (s_chargerConnected == null)
+                {
+                    int ret = Interop.RuntimeInfo.SetRuntimeInfoChangedCallback(RuntimeInformationKey.Charger, s_runtimeInfoChangedCallback, IntPtr.Zero);
+                    if (ret != (int)RuntimeInfoError.None)
+                    {
+                        Log.Error(RuntimeInfoErrorFactory.LogTag, "Interop failed to add event handler");
+                        RuntimeInfoErrorFactory.ThrowException(ret);
+                    }
+                }
+                s_chargerConnected += value;
+            }
+            remove
+            {
+                s_chargerConnected -= value;
+                if (s_chargerConnected == null)
+                {
+                    int ret = Interop.RuntimeInfo.UnsetRuntimeInfoChangedCallback(RuntimeInformationKey.Charger);
+                    if (ret != (int)RuntimeInfoError.None)
+                    {
+                        Log.Error(RuntimeInfoErrorFactory.LogTag, "Interop failed to add event handler");
+                        RuntimeInfoErrorFactory.ThrowException(ret);
+                    }
+                }
+            }
+        }
+        /// <summary>
+        /// (event) AutoRotationEnabled is rasied when system preference for auto rotaion is changed.
+        /// </summary>
+        public static event EventHandler<RuntimeKeyStatusChangedEventArgs> AutoRotationEnabled
+        {
+            add
+            {
+                if (s_autoRotationEnabled == null)
+                {
+                    int ret = Interop.RuntimeInfo.SetRuntimeInfoChangedCallback(RuntimeInformationKey.AutoRotation, s_runtimeInfoChangedCallback, IntPtr.Zero);
+                    if (ret != (int)RuntimeInfoError.None)
+                    {
+                        Log.Error(RuntimeInfoErrorFactory.LogTag, "Interop failed to add event handler");
+                        RuntimeInfoErrorFactory.ThrowException(ret);
+                    }
+                }
+                s_autoRotationEnabled += value;
+            }
+            remove
+            {
+                s_autoRotationEnabled -= value;
+                if (s_autoRotationEnabled == null)
+                {
+                    int ret = Interop.RuntimeInfo.UnsetRuntimeInfoChangedCallback(RuntimeInformationKey.AutoRotation);
+                    if (ret != (int)RuntimeInfoError.None)
+                    {
+                        Log.Error(RuntimeInfoErrorFactory.LogTag, "Interop failed to add event handler");
+                        RuntimeInfoErrorFactory.ThrowException(ret);
+                    }
+                }
+            }
+        }
+    }
+}

diff --git a/Tizen.System/RuntimeInfo/RuntimeKeyStatusChangedEventArgs.cs b/Tizen.System/RuntimeInfo/RuntimeKeyStatusChangedEventArgs.cs
new file mode 100755 (executable)
index 0000000..f567252
--- /dev/null
+++ b/Tizen.System/RuntimeInfo/RuntimeKeyStatusChangedEventArgs.cs
@@ -0,0 +1,28 @@
+/// Copyright 2016 by Samsung Electronics, Inc.,
+///
+/// This software is the confidential and proprietary information
+/// of Samsung Electronics, Inc. ("Confidential Information"). You
+/// shall not disclose such Confidential Information and shall use
+/// it only in accordance with the terms of the license agreement
+/// you entered into with Samsung.
+
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace Tizen.System
+{
+    /// <summary>
+    /// RuntimeInfoChangedEventArgs is an extended EventArgs class. This class contains event arguments for runtime event listeners
+    /// </summary>
+    public class RuntimeKeyStatusChangedEventArgs : EventArgs
+    {
+        /// <summary>
+        /// The key indicating the runtime system preference which was changed.
+        /// </summary>
+        public RuntimeInformationKey Key { get; internal set; }
+    }
+}

diff --git a/Tizen.System/Tizen.System.csproj b/Tizen.System/Tizen.System.csproj
index 6c61840..2e6a0d7 100644 (file)
--- a/Tizen.System/Tizen.System.csproj
+++ b/Tizen.System/Tizen.System.csproj
@@ -1,5 +1,5 @@
 <?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="14.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
+<Project ToolsVersion="4.0" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
   <Import Project="$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props" Condition="Exists('$(MSBuildExtensionsPath)\$(MSBuildToolsVersion)\Microsoft.Common.props')" />
   <PropertyGroup>
     <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
@@ -12,6 +12,8 @@
     <TargetFrameworkVersion>v4.0</TargetFrameworkVersion>
     <FileAlignment>512</FileAlignment>
     <TargetFrameworkProfile />
+    <ProductVersion>8.0.30703</ProductVersion>
+    <SchemaVersion>2.0</SchemaVersion>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
     <DebugSymbols>true</DebugSymbols>
@@ -21,8 +23,6 @@
     <DefineConstants>DEBUG;TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
-    <DocumentationFile>
-    </DocumentationFile>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
     <DebugType>pdbonly</DebugType>
@@ -47,12 +47,12 @@
     <Reference Include="System.Data" />
     <Reference Include="System.Net.Http" />
     <Reference Include="System.Xml" />
-    <Reference Include="Tizen">
-      <HintPath>..\..\tizen\Tizen\bin\Debug\Tizen.dll</HintPath>
-    </Reference>
     <Reference Include="Tizen.Internals">
       <HintPath>..\..\tizen\Tizen.Internals\bin\Debug\Tizen.Internals.dll</HintPath>
     </Reference>
+    <Reference Include="Tizen">
+      <HintPath>..\..\tizen\Tizen\bin\Debug\Tizen.dll</HintPath>
+    </Reference>
   </ItemGroup>
   <ItemGroup>
     <Compile Include="Device\Battery.cs" />
@@ -64,7 +64,15 @@
     <Compile Include="Device\IR.cs" />
     <Compile Include="Device\DeviceEventArgs.cs" />
     <Compile Include="Interop\Interop.Device.cs" />
+    <Compile Include="Interop\Interop.RuntimeInfo.cs" />
+    <Compile Include="Interop\Interop.Libraries.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="RuntimeInfo\CpuUsage.cs" />
+    <Compile Include="RuntimeInfo\Enumerations.cs" />
+    <Compile Include="RuntimeInfo\RuntimeInfoErrorFactory.cs" />
+    <Compile Include="RuntimeInfo\RuntimeInformation.cs" />
+    <Compile Include="RuntimeInfo\RuntimeKeyStatusChangedEventArgs.cs" />
+    <Compile Include="RuntimeInfo\MemoryInformation.cs" />
   </ItemGroup>
   <ItemGroup>
     <None Include="packaging\csapi-tizen.system.manifest" />

diff --git a/packaging/csapi-tizen.system.spec b/packaging/csapi-tizen.system.spec
index c7cb90c..4b05ac1 100755 (executable)
--- a/packaging/csapi-tizen.system.spec
+++ b/packaging/csapi-tizen.system.spec
@@ -22,15 +22,17 @@ Requires(postun): mono-core
 
 # P/Invoke Dependencies
 BuildRequires: pkgconfig(capi-system-device)
+BuildRequires: pkgconfig(capi-system-runtime-info)
 
 # P/Invoke Runtime Dependencies
 # TODO: It should be removed after fix tizen-rpm-config
 Requires: capi-system-device
+Requires: capi-system-runtime-info
 # DLL Dependencies
 #BuildRequires: ...
 
 %description
-Tizen System Device API for C#
+Tizen System API for C#
 
 %package devel
 Summary:    Development package for %{name}
@@ -56,7 +58,15 @@ mcs -target:library -out:%{dllname} -keyfile:Tizen.System/Tizen.System.snk \
   Tizen.System/Device/Haptic.cs \
   Tizen.System/Device/Led.cs \
   Tizen.System/Device/Power.cs \
-  Tizen.System/Interop/Interop.Device.cs
+  Tizen.System/Interop/Interop.Device.cs \
+  Tizen.System/Interop/Interop.Libraries.cs \
+  Tizen.System/Interop/Interop.RuntimeInfo.cs \
+  Tizen.System/RuntimeInfo/CpuUsage.cs \
+  Tizen.System/RuntimeInfo/Enumerations.cs \
+  Tizen.System/RuntimeInfo/MemoryInformation.cs \
+  Tizen.System/RuntimeInfo/RuntimeInfoErrorFactory.cs \
+  Tizen.System/RuntimeInfo/RuntimeInformation.cs \
+  Tizen.System/RuntimeInfo/RuntimeKeyStatusChangedEventArgs.cs
 
 # check p/invoke
 if [ -x %{dllname} ]; then