void fabric_AddRobotAction(object sender, GenericEventArgs<Robot> e)
 {
     RobotButton robotButton = robotPanel.AddRobot(e.Value).GetComponent<RobotButton>();
     _robotButtons.Add(robotButton);
     robotButton.ClickAction += robotButton_ClickAction;
     e.Value.ReturnAction += robots_ReturnAction;
 }

 void PrimitiveCommandHandler(object sender, GenericEventArgs<string> e)
 {
     if (current.Triangle != null)
     {
         InvokePrimitive(e.Argument);
     }
 }

        async void _taskManager_TaskCompleted(object sender, GenericEventArgs<TaskResult> e)
        {
            var result = e.Argument;

            if (result.Status == TaskCompletionStatus.Failed)
            {
                foreach (var user in _userManager
                    .Users
                    .Where(i => i.Configuration.IsAdministrator)
                    .ToList())
                {
                    var notification = new Notification
                    {
                        UserId = user.Id,
                        Category = "ScheduledTaskFailed",
                        Name = result.Name + " failed",
                        RelatedId = result.Name,
                        Description = result.ErrorMessage,
                        Level = NotificationLevel.Error
                    };

                    try
                    {
                        await _notificationsRepo.AddNotification(notification, CancellationToken.None).ConfigureAwait(false);
                    }
                    catch (Exception ex)
                    {
                        _logger.ErrorException("Error adding notification", ex);
                    }
                }
            }
        }

        void _deviceDiscovery_DeviceDiscovered(object sender, GenericEventArgs<UpnpDeviceInfo> e)
        {
            var info = e.Argument;

            string st = null;
            string nt = null;
            info.Headers.TryGetValue("ST", out st);
            info.Headers.TryGetValue("NT", out nt);

            if (string.Equals(st, "urn:ses-com:device:SatIPServer:1", StringComparison.OrdinalIgnoreCase) ||
                string.Equals(nt, "urn:ses-com:device:SatIPServer:1", StringComparison.OrdinalIgnoreCase))
            {
                string location;
                if (info.Headers.TryGetValue("Location", out location) && !string.IsNullOrWhiteSpace(location))
                {
                    _logger.Debug("SAT IP found at {0}", location);

                    // Just get the beginning of the url
                    Uri uri;
                    if (Uri.TryCreate(location, UriKind.Absolute, out uri))
                    {
                        var apiUrl = location.Replace(uri.LocalPath, String.Empty, StringComparison.OrdinalIgnoreCase)
                                .TrimEnd('/');

                        AddDevice(apiUrl, location);
                    }
                }
            }
        }

        void _deviceDiscovery_DeviceDiscovered(object sender, GenericEventArgs<UpnpDeviceInfo> e)
        {
            string server = null;
            var info = e.Argument;

            if (info.Headers.TryGetValue("SERVER", out server) && server.IndexOf("HDHomeRun", StringComparison.OrdinalIgnoreCase) != -1)
            {
                string location;
                if (info.Headers.TryGetValue("Location", out location))
                {
                    //_logger.Debug("HdHomerun found at {0}", location);

                    // Just get the beginning of the url
                    Uri uri;
                    if (Uri.TryCreate(location, UriKind.Absolute, out uri))
                    {
                        var apiUrl = location.Replace(uri.LocalPath, String.Empty, StringComparison.OrdinalIgnoreCase)
                                .TrimEnd('/');

                        //_logger.Debug("HdHomerun api url: {0}", apiUrl);
                        AddDevice(apiUrl);
                    }
                }
            }
        }

 // Invoke the Changed event; called whenever list changes
 protected virtual void OnFileUploadComplete(GenericEventArgs<string> e)
 {
     if (FileUploadComplete != null)
     {
         FileUploadComplete(this,e);
     }
 }

 void Demon_OnCollisionWithPlayer(object sender, GenericEventArgs<ArcanaPlayer> e)
 {
     if (attackCounter > attackRate)
     {
         e.Data.Damage(DemonDamage);
         attackCounter = TimeSpan.Zero;
     }
 }

 void AngryRock_OnCollisionWithPlayer(object sender, GenericEventArgs<ArcanaPlayer> e)
 {
     if (currentTime >= RockAttackSpeed)
     {
         currentTime = TimeSpan.Zero;
         e.Data.Damage(RockRamage);
     }
 }

 private void ConnectionManagerOnConnected(object sender, GenericEventArgs<ConnectionResult> e)
 {
     var apiClient = e.Argument.ApiClient;
     if (apiClient != null)
     {
         apiClient.UserUpdated -= ApiClientOnUserUpdated;
         apiClient.UserUpdated += ApiClientOnUserUpdated;
     }
 }

 void _taskManager_TaskCompleted(object sender, GenericEventArgs<TaskResult> e)
 {
     if (Plugin.Instance.Configuration.Notifications.Tasks)
     {
         if (e.Argument.Status.ToString() == "Failed")
         {
             _pusher.Push("Media Server Task " + e.Argument.Name + " Error : " + e.Argument.ErrorMessage, 0);
         }
     }
 }

        async void PlayAudio(object sender, GenericEventArgs<Stream> args)
        {
            await this.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async () =>
            {
                Stream str = args.EventData;
                InMemoryRandomAccessStream ras = new InMemoryRandomAccessStream();

                await str.CopyToAsync(ras.AsStreamForWrite());
                Windows.Media.Playback.BackgroundMediaPlayer.Current.SetStreamSource(ras);
            });
        }

        void commandHandler_StartMoveAction(object sender, GenericEventArgs<Robot> e)
        {
            foreach (Platform platform in _platforms)
                platform.DarkenPlatform();

            foreach (RobotButton button in _robotButtons)
            {
                if (button.FixedRobot == e.Value)
                    button.Deactivate();
            }
        }

        void _config_ConfigurationUpdating(object sender, GenericEventArgs<ServerConfiguration> e)
        {
            var options = e.Argument.SubtitleOptions;

            if (options != null &&
                !string.IsNullOrWhiteSpace(options.OpenSubtitlesPasswordHash) &&
                !options.OpenSubtitlesPasswordHash.StartsWith(PasswordHashPrefix, StringComparison.OrdinalIgnoreCase))
            {
                options.OpenSubtitlesPasswordHash = EncryptPassword(options.OpenSubtitlesPasswordHash);
            }
        }

 private void ConnectionManagerOnLocalUserSignIn(object sender, GenericEventArgs<UserDto> e)
 {
     Deployment.Current.Dispatcher.BeginInvoke(() =>
     {
         LoggedInUser = e.Argument;
         if (AuthenticationResult != null && _connectionManager.CurrentApiClient != null)
         {
             _connectionManager.CurrentApiClient.SetAuthenticationInfo(AuthenticationResult.AccessToken, LoggedInUserId);
         }
     });
 }

        private void ApiClientOnUserUpdated(object sender, GenericEventArgs<UserDto> e)
        {
            Deployment.Current.Dispatcher.BeginInvoke(() =>
            {
                SetUser(e.Argument);

                var apiClient = sender as IApiClient;
                if (apiClient != null)
                {
                    SetAccessToken(apiClient.AccessToken);
                }
            });
        }

        async void _userManager_UserLockedOut(object sender, GenericEventArgs<User> e)
        {
            var type = NotificationType.UserLockedOut.ToString();

            var notification = new NotificationRequest
            {
                NotificationType = type
            };

            notification.Variables["UserName"] = e.Argument.Name;

            await SendNotification(notification).ConfigureAwait(false);
        }

        async void _appHost_ApplicationUpdated(object sender, GenericEventArgs<PackageVersionInfo> e)
        {
            var type = NotificationType.ApplicationUpdateInstalled.ToString();

            var notification = new NotificationRequest
            {
                NotificationType = type
            };

            notification.Variables["Version"] = e.Argument.versionStr;
            notification.Variables["ReleaseNotes"] = e.Argument.description;

            await SendNotification(notification).ConfigureAwait(false);
        }

 /// <summary>
 /// Event handler for when a client connects.
 /// Makes sure there is enough room on the server before allowing it to proceed.
 /// if successful it starts the client read/write threads.
 /// </summary>
 /// <param name="sender">Client that is connecting</param>
 /// <param name="e">the handshake (contains its name)</param>
 public void Client_Connected(Client sender, GenericEventArgs<String> e)
 {
     if (!Interlocked.Equals(this.connectedClients, this.maxClients))
     {
         Interlocked.Increment(ref this.connectedClients);
         this.On_Client_Sending += sender.Client_Sending; //subscribe to the send to all event
         sender.StartUp();
         Console.WriteLine("Client connected: {0}", sender.Name);
     }
     else
     {
         sender.Close_Connection();
         Console.WriteLine("Client refused, server full: {0}", sender.Name);
     }
 }

        void _serverEvents_UserDataChanged(object sender, GenericEventArgs<UserDataChangeInfo> e)
        {
            var key = _item.UserData == null ? string.Empty : _item.UserData.Key;

            if (!string.IsNullOrEmpty(key))
            {
                var data = e.Argument.UserDataList.FirstOrDefault(i => string.Equals(key, i.Key, StringComparison.OrdinalIgnoreCase));

                if (data != null)
                {
                    _item.UserData = data;
                    RefreshUserDataFields();
                }
            }
        }

        private void TweetReceived(GenericEventArgs<ITweet> tweetEvent)
        {
            if (!tweetEvent.Value.Text.Contains(ConfigurationManager.AppSettings["AccountName"])) return;

            var tweet = tweetEvent.Value;

            var scoreInfo = new ScoreInfo
                {
                    Id = tweet.Id,
                    TextScore = StripMentions(tweet.Text),
                    Username = tweet.Creator.ScreenName,
                    DateTime = tweet.CreatedAt,
                };

            if (Received != null) Received(scoreInfo);
        }