示例#1
0
        private static DeviceCacheItem GetFromCacheInternal(string id)
        {
            return(ExceptionUtility.Try <DeviceCacheItem>(() =>
            {
                DeviceCacheItem output = null;

                if (id != null)
                {
                    _cachedDevices.TryGetValue(id, out output);
                }

                return output;
            }));
        }
示例#2
0
        /// <summary>
        /// Unregisters a listener from updates to a specific device.
        /// </summary>
        /// <param name="id">Id of the device for which to no longer receive updates</param>
        /// <param name="callback">The callback listener</param>
        public static void UnsubscribeFromDeviceUpdates(string id, Action <Device> callback)
        {
            ExceptionUtility.Try(() =>
            {
                DeviceCacheItem value = null;

                if (_cachedDevices.TryGetValue(id, out value))
                {
                    value.RemoveUpdateCallback(callback);
                }

                LogUtility.LogMessage(id + " unsubscribed from device updates.");
            });
        }
示例#3
0
        /// <summary>
        /// Registers a listener for updates to a specific device.
        /// </summary>
        /// <param name="id">Id of the device for which to receive updates</param>
        /// <param name="callback">The callback listener</param>
        public static void SubscribeToDeviceUpdates(string id, Action <Device> callback)
        {
            ExceptionUtility.Try(() =>
            {
                DeviceCacheItem value = null;

                if (_cachedDevices.TryGetValue(id, out value))
                {
                    value.AddUpdateCallback(callback);
                }

                LogUtility.LogMessage(id + " subscribing to device updates.");
            });
        }
示例#4
0
        private static void AddOrUpdateInternal(Device device)
        {
            ExceptionUtility.Try(() =>
            {
                if (device != null)
                {
                    if (device != null && !String.IsNullOrEmpty(device.Id))
                    {
                        if (device.Type == null)
                        {
                            device.Type = TryGetDeviceType(device.Id);
                        }

                        device.MergeFromMetadata();
                        var newItem = new DeviceCacheItem(device);
                        _cachedDevices.AddOrUpdate(device.Id, (k) =>
                        {
                            LogUtility.LogMessage("Device " + device.Id + " added to cache.");
                            return(newItem);
                        },
                                                   (k, v) =>
                        {
                            if (v.Device != null)
                            {
                                //then merge new data into old data
                                v.Device.MergeFromParent(newItem.Device, false, false);
                                LogUtility.LogMessage("Device " + device.Id + " updated in cache.");
                            }
                            else
                            {
                                v.Device = newItem.Device;
                                LogUtility.LogMessage("Device " + device.Id + " added to cache.");
                            }

                            foreach (var callback in v.UpdateCallbacks)
                            {
                                LogUtility.LogMessage("Calling callback event for device " + v.Device.Id);
                                callback(v.Device);
                            }
                            return(v);
                        });

                        LimitAlerts();
                    }
                }
            });
        }