move classes to portable server project

Emby.Server.Implementations/EntryPoints/AutomaticRestartEntryPoint.cs

@@ -0,0 +1,124 @@
+using MediaBrowser.Controller;
+using MediaBrowser.Controller.Configuration;
+using MediaBrowser.Controller.Plugins;
+using MediaBrowser.Controller.Session;
+using MediaBrowser.Model.Logging;
+using MediaBrowser.Model.Tasks;
+using System;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using MediaBrowser.Controller.LiveTv;
+using MediaBrowser.Model.LiveTv;
+using MediaBrowser.Model.Threading;
+
+namespace Emby.Server.Implementations.EntryPoints
+{
+    public class AutomaticRestartEntryPoint : IServerEntryPoint
+    {
+        private readonly IServerApplicationHost _appHost;
+        private readonly ILogger _logger;
+        private readonly ITaskManager _iTaskManager;
+        private readonly ISessionManager _sessionManager;
+        private readonly IServerConfigurationManager _config;
+        private readonly ILiveTvManager _liveTvManager;
+        private readonly ITimerFactory _timerFactory;
+
+        private ITimer _timer;
+
+        public AutomaticRestartEntryPoint(IServerApplicationHost appHost, ILogger logger, ITaskManager iTaskManager, ISessionManager sessionManager, IServerConfigurationManager config, ILiveTvManager liveTvManager, ITimerFactory timerFactory)
+        {
+            _appHost = appHost;
+            _logger = logger;
+            _iTaskManager = iTaskManager;
+            _sessionManager = sessionManager;
+            _config = config;
+            _liveTvManager = liveTvManager;
+            _timerFactory = timerFactory;
+        }
+
+        public void Run()
+        {
+            if (_appHost.CanSelfRestart)
+            {
+                _appHost.HasPendingRestartChanged += _appHost_HasPendingRestartChanged;
+            }
+        }
+
+        void _appHost_HasPendingRestartChanged(object sender, EventArgs e)
+        {
+            DisposeTimer();
+
+            if (_appHost.HasPendingRestart)
+            {
+                _timer = _timerFactory.Create(TimerCallback, null, TimeSpan.FromMinutes(10), TimeSpan.FromMinutes(10));
+            }
+        }
+
+        private async void TimerCallback(object state)
+        {
+            if (_config.Configuration.EnableAutomaticRestart)
+            {
+                var isIdle = await IsIdle().ConfigureAwait(false);
+
+                if (isIdle)
+                {
+                    DisposeTimer();
+
+                    try
+                    {
+                        _appHost.Restart();
+                    }
+                    catch (Exception ex)
+                    {
+                        _logger.ErrorException("Error restarting server", ex);
+                    }
+                }
+            }
+        }
+
+        private async Task<bool> IsIdle()
+        {
+            if (_iTaskManager.ScheduledTasks.Any(i => i.State != TaskState.Idle))
+            {
+                return false;
+            }
+
+            if (_liveTvManager.Services.Count == 1)
+            {
+                try
+                {
+                    var timers = await _liveTvManager.GetTimers(new TimerQuery(), CancellationToken.None).ConfigureAwait(false);
+                    if (timers.Items.Any(i => i.Status == RecordingStatus.InProgress))
+                    {
+                        return false;
+                    }
+                }
+                catch (Exception ex)
+                {
+                    _logger.ErrorException("Error getting timers", ex);
+                }
+            }
+
+            var now = DateTime.UtcNow;
+
+            return !_sessionManager.Sessions.Any(i => (now - i.LastActivityDate).TotalMinutes < 30);
+        }
+
+        public void Dispose()
+        {
+            _appHost.HasPendingRestartChanged -= _appHost_HasPendingRestartChanged;
+
+            DisposeTimer();
+        }
+
+        private void DisposeTimer()
+        {
+            if (_timer != null)
+            {
+                _timer.Dispose();
+                _timer = null;
+            }
+        }
+    }
+}

Emby.Server.Implementations/EntryPoints/LibraryChangedNotifier.cs

@@ -0,0 +1,343 @@
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Plugins;
+using MediaBrowser.Controller.Session;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.Logging;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using MediaBrowser.Controller.Entities.Audio;
+using MediaBrowser.Model.Extensions;
+using MediaBrowser.Model.Threading;
+
+namespace Emby.Server.Implementations.EntryPoints
+{
+    public class LibraryChangedNotifier : IServerEntryPoint
+    {
+        /// <summary>
+        /// The _library manager
+        /// </summary>
+        private readonly ILibraryManager _libraryManager;
+
+        private readonly ISessionManager _sessionManager;
+        private readonly IUserManager _userManager;
+        private readonly ILogger _logger;
+        private readonly ITimerFactory _timerFactory;
+
+        /// <summary>
+        /// The _library changed sync lock
+        /// </summary>
+        private readonly object _libraryChangedSyncLock = new object();
+
+        private readonly List<Folder> _foldersAddedTo = new List<Folder>();
+        private readonly List<Folder> _foldersRemovedFrom = new List<Folder>();
+
+        private readonly List<BaseItem> _itemsAdded = new List<BaseItem>();
+        private readonly List<BaseItem> _itemsRemoved = new List<BaseItem>();
+        private readonly List<BaseItem> _itemsUpdated = new List<BaseItem>();
+
+        /// <summary>
+        /// Gets or sets the library update timer.
+        /// </summary>
+        /// <value>The library update timer.</value>
+        private ITimer LibraryUpdateTimer { get; set; }
+
+        /// <summary>
+        /// The library update duration
+        /// </summary>
+        private const int LibraryUpdateDuration = 5000;
+
+        public LibraryChangedNotifier(ILibraryManager libraryManager, ISessionManager sessionManager, IUserManager userManager, ILogger logger, ITimerFactory timerFactory)
+        {
+            _libraryManager = libraryManager;
+            _sessionManager = sessionManager;
+            _userManager = userManager;
+            _logger = logger;
+            _timerFactory = timerFactory;
+        }
+
+        public void Run()
+        {
+            _libraryManager.ItemAdded += libraryManager_ItemAdded;
+            _libraryManager.ItemUpdated += libraryManager_ItemUpdated;
+            _libraryManager.ItemRemoved += libraryManager_ItemRemoved;
+
+        }
+
+        /// <summary>
+        /// Handles the ItemAdded event of the libraryManager control.
+        /// </summary>
+        /// <param name="sender">The source of the event.</param>
+        /// <param name="e">The <see cref="ItemChangeEventArgs"/> instance containing the event data.</param>
+        void libraryManager_ItemAdded(object sender, ItemChangeEventArgs e)
+        {
+            if (!FilterItem(e.Item))
+            {
+                return;
+            }
+
+            lock (_libraryChangedSyncLock)
+            {
+                if (LibraryUpdateTimer == null)
+                {
+                    LibraryUpdateTimer = _timerFactory.Create(LibraryUpdateTimerCallback, null, LibraryUpdateDuration,
+                                                   Timeout.Infinite);
+                }
+                else
+                {
+                    LibraryUpdateTimer.Change(LibraryUpdateDuration, Timeout.Infinite);
+                }
+
+                if (e.Item.Parent != null)
+                {
+                    _foldersAddedTo.Add(e.Item.Parent);
+                }
+
+                _itemsAdded.Add(e.Item);
+            }
+        }
+
+        /// <summary>
+        /// Handles the ItemUpdated event of the libraryManager control.
+        /// </summary>
+        /// <param name="sender">The source of the event.</param>
+        /// <param name="e">The <see cref="ItemChangeEventArgs"/> instance containing the event data.</param>
+        void libraryManager_ItemUpdated(object sender, ItemChangeEventArgs e)
+        {
+            if (!FilterItem(e.Item))
+            {
+                return;
+            }
+
+            lock (_libraryChangedSyncLock)
+            {
+                if (LibraryUpdateTimer == null)
+                {
+                    LibraryUpdateTimer = _timerFactory.Create(LibraryUpdateTimerCallback, null, LibraryUpdateDuration,
+                                                   Timeout.Infinite);
+                }
+                else
+                {
+                    LibraryUpdateTimer.Change(LibraryUpdateDuration, Timeout.Infinite);
+                }
+
+                _itemsUpdated.Add(e.Item);
+            }
+        }
+
+        /// <summary>
+        /// Handles the ItemRemoved event of the libraryManager control.
+        /// </summary>
+        /// <param name="sender">The source of the event.</param>
+        /// <param name="e">The <see cref="ItemChangeEventArgs"/> instance containing the event data.</param>
+        void libraryManager_ItemRemoved(object sender, ItemChangeEventArgs e)
+        {
+            if (!FilterItem(e.Item))
+            {
+                return;
+            }
+
+            lock (_libraryChangedSyncLock)
+            {
+                if (LibraryUpdateTimer == null)
+                {
+                    LibraryUpdateTimer = _timerFactory.Create(LibraryUpdateTimerCallback, null, LibraryUpdateDuration,
+                                                   Timeout.Infinite);
+                }
+                else
+                {
+                    LibraryUpdateTimer.Change(LibraryUpdateDuration, Timeout.Infinite);
+                }
+
+                if (e.Item.Parent != null)
+                {
+                    _foldersRemovedFrom.Add(e.Item.Parent);
+                }
+
+                _itemsRemoved.Add(e.Item);
+            }
+        }
+
+        /// <summary>
+        /// Libraries the update timer callback.
+        /// </summary>
+        /// <param name="state">The state.</param>
+        private void LibraryUpdateTimerCallback(object state)
+        {
+            lock (_libraryChangedSyncLock)
+            {
+                // Remove dupes in case some were saved multiple times
+                var foldersAddedTo = _foldersAddedTo.DistinctBy(i => i.Id).ToList();
+
+                var foldersRemovedFrom = _foldersRemovedFrom.DistinctBy(i => i.Id).ToList();
+
+                var itemsUpdated = _itemsUpdated
+                    .Where(i => !_itemsAdded.Contains(i))
+                    .DistinctBy(i => i.Id)
+                    .ToList();
+
+                SendChangeNotifications(_itemsAdded.ToList(), itemsUpdated, _itemsRemoved.ToList(), foldersAddedTo, foldersRemovedFrom, CancellationToken.None);
+
+                if (LibraryUpdateTimer != null)
+                {
+                    LibraryUpdateTimer.Dispose();
+                    LibraryUpdateTimer = null;
+                }
+
+                _itemsAdded.Clear();
+                _itemsRemoved.Clear();
+                _itemsUpdated.Clear();
+                _foldersAddedTo.Clear();
+                _foldersRemovedFrom.Clear();
+            }
+        }
+
+        /// <summary>
+        /// Sends the change notifications.
+        /// </summary>
+        /// <param name="itemsAdded">The items added.</param>
+        /// <param name="itemsUpdated">The items updated.</param>
+        /// <param name="itemsRemoved">The items removed.</param>
+        /// <param name="foldersAddedTo">The folders added to.</param>
+        /// <param name="foldersRemovedFrom">The folders removed from.</param>
+        /// <param name="cancellationToken">The cancellation token.</param>
+        private async void SendChangeNotifications(List<BaseItem> itemsAdded, List<BaseItem> itemsUpdated, List<BaseItem> itemsRemoved, List<Folder> foldersAddedTo, List<Folder> foldersRemovedFrom, CancellationToken cancellationToken)
+        {
+            foreach (var user in _userManager.Users.ToList())
+            {
+                var id = user.Id;
+                var userSessions = _sessionManager.Sessions
+                    .Where(u => u.UserId.HasValue && u.UserId.Value == id && u.SessionController != null && u.IsActive)
+                    .ToList();
+
+                if (userSessions.Count > 0)
+                {
+                    LibraryUpdateInfo info;
+
+                    try
+                    {
+                         info = GetLibraryUpdateInfo(itemsAdded, itemsUpdated, itemsRemoved, foldersAddedTo,
+                                                        foldersRemovedFrom, id);
+                    }
+                    catch (Exception ex)
+                    {
+                        _logger.ErrorException("Error in GetLibraryUpdateInfo", ex);
+                        return;
+                    }
+
+                    foreach (var userSession in userSessions)
+                    {
+                        try
+                        {
+                            await userSession.SessionController.SendLibraryUpdateInfo(info, cancellationToken).ConfigureAwait(false);
+                        }
+                        catch (Exception ex)
+                        {
+                            _logger.ErrorException("Error sending LibraryChanged message", ex);
+                        }
+                    }
+                }
+
+            }
+        }
+
+        /// <summary>
+        /// Gets the library update info.
+        /// </summary>
+        /// <param name="itemsAdded">The items added.</param>
+        /// <param name="itemsUpdated">The items updated.</param>
+        /// <param name="itemsRemoved">The items removed.</param>
+        /// <param name="foldersAddedTo">The folders added to.</param>
+        /// <param name="foldersRemovedFrom">The folders removed from.</param>
+        /// <param name="userId">The user id.</param>
+        /// <returns>LibraryUpdateInfo.</returns>
+        private LibraryUpdateInfo GetLibraryUpdateInfo(IEnumerable<BaseItem> itemsAdded, IEnumerable<BaseItem> itemsUpdated, IEnumerable<BaseItem> itemsRemoved, IEnumerable<Folder> foldersAddedTo, IEnumerable<Folder> foldersRemovedFrom, Guid userId)
+        {
+            var user = _userManager.GetUserById(userId);
+
+            return new LibraryUpdateInfo
+            {
+                ItemsAdded = itemsAdded.SelectMany(i => TranslatePhysicalItemToUserLibrary(i, user)).Select(i => i.Id.ToString("N")).Distinct().ToList(),
+
+                ItemsUpdated = itemsUpdated.SelectMany(i => TranslatePhysicalItemToUserLibrary(i, user)).Select(i => i.Id.ToString("N")).Distinct().ToList(),
+
+                ItemsRemoved = itemsRemoved.SelectMany(i => TranslatePhysicalItemToUserLibrary(i, user, true)).Select(i => i.Id.ToString("N")).Distinct().ToList(),
+
+                FoldersAddedTo = foldersAddedTo.SelectMany(i => TranslatePhysicalItemToUserLibrary(i, user)).Select(i => i.Id.ToString("N")).Distinct().ToList(),
+
+                FoldersRemovedFrom = foldersRemovedFrom.SelectMany(i => TranslatePhysicalItemToUserLibrary(i, user)).Select(i => i.Id.ToString("N")).Distinct().ToList()
+            };
+        }
+
+        private bool FilterItem(BaseItem item)
+        {
+            if (!item.IsFolder && item.LocationType == LocationType.Virtual)
+            {
+                return false;
+            }
+
+            if (item is IItemByName && !(item is MusicArtist))
+            {
+                return false;
+            }
+
+            return item.SourceType == SourceType.Library;
+        }
+
+        /// <summary>
+        /// Translates the physical item to user library.
+        /// </summary>
+        /// <typeparam name="T"></typeparam>
+        /// <param name="item">The item.</param>
+        /// <param name="user">The user.</param>
+        /// <param name="includeIfNotFound">if set to <c>true</c> [include if not found].</param>
+        /// <returns>IEnumerable{``0}.</returns>
+        private IEnumerable<T> TranslatePhysicalItemToUserLibrary<T>(T item, User user, bool includeIfNotFound = false)
+            where T : BaseItem
+        {
+            // If the physical root changed, return the user root
+            if (item is AggregateFolder)
+            {
+                return new[] { user.RootFolder as T };
+            }
+
+            // Return it only if it's in the user's library
+            if (includeIfNotFound || item.IsVisibleStandalone(user))
+            {
+                return new[] { item };
+            }
+
+            return new T[] { };
+        }
+
+        /// <summary>
+        /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
+        /// </summary>
+        public void Dispose()
+        {
+            Dispose(true);
+        }
+
+        /// <summary>
+        /// Releases unmanaged and - optionally - managed resources.
+        /// </summary>
+        /// <param name="dispose"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
+        protected virtual void Dispose(bool dispose)
+        {
+            if (dispose)
+            {
+                if (LibraryUpdateTimer != null)
+                {
+                    LibraryUpdateTimer.Dispose();
+                    LibraryUpdateTimer = null;
+                }
+
+                _libraryManager.ItemAdded -= libraryManager_ItemAdded;
+                _libraryManager.ItemUpdated -= libraryManager_ItemUpdated;
+                _libraryManager.ItemRemoved -= libraryManager_ItemRemoved;
+            }
+        }
+    }
+}

Emby.Server.Implementations/EntryPoints/LoadRegistrations.cs

@@ -0,0 +1,73 @@
+using MediaBrowser.Common.Security;
+using MediaBrowser.Controller.Plugins;
+using MediaBrowser.Model.Logging;
+using System;
+using System.Threading.Tasks;
+using MediaBrowser.Model.Threading;
+
+namespace Emby.Server.Implementations.EntryPoints
+{
+    /// <summary>
+    /// Class LoadRegistrations
+    /// </summary>
+    public class LoadRegistrations : IServerEntryPoint
+    {
+        /// <summary>
+        /// The _security manager
+        /// </summary>
+        private readonly ISecurityManager _securityManager;
+
+        /// <summary>
+        /// The _logger
+        /// </summary>
+        private readonly ILogger _logger;
+
+        private ITimer _timer;
+        private readonly ITimerFactory _timerFactory;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="LoadRegistrations" /> class.
+        /// </summary>
+        /// <param name="securityManager">The security manager.</param>
+        /// <param name="logManager">The log manager.</param>
+        public LoadRegistrations(ISecurityManager securityManager, ILogManager logManager, ITimerFactory timerFactory)
+        {
+            _securityManager = securityManager;
+            _timerFactory = timerFactory;
+
+            _logger = logManager.GetLogger("Registration Loader");
+        }
+
+        /// <summary>
+        /// Runs this instance.
+        /// </summary>
+        public void Run()
+        {
+            _timer = _timerFactory.Create(s => LoadAllRegistrations(), null, TimeSpan.FromMilliseconds(100), TimeSpan.FromHours(12));
+        }
+
+        private async Task LoadAllRegistrations()
+        {
+            try
+            {
+                await _securityManager.LoadAllRegistrationInfo().ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                _logger.ErrorException("Error loading registration info", ex);
+            }
+        }
+
+        /// <summary>
+        /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
+        /// </summary>
+        public void Dispose()
+        {
+            if (_timer != null)
+            {
+                _timer.Dispose();
+                _timer = null;
+            }
+        }
+    }
+}

Emby.Server.Implementations/EntryPoints/RecordingNotifier.cs

@@ -0,0 +1,77 @@
+using System;
+using System.Linq;
+using System.Threading;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.LiveTv;
+using MediaBrowser.Controller.Plugins;
+using MediaBrowser.Controller.Session;
+using MediaBrowser.Model.Logging;
+
+namespace Emby.Server.Implementations.EntryPoints
+{
+    public class RecordingNotifier : IServerEntryPoint
+    {
+        private readonly ILiveTvManager _liveTvManager;
+        private readonly ISessionManager _sessionManager;
+        private readonly IUserManager _userManager;
+        private readonly ILogger _logger;
+
+        public RecordingNotifier(ISessionManager sessionManager, IUserManager userManager, ILogger logger, ILiveTvManager liveTvManager)
+        {
+            _sessionManager = sessionManager;
+            _userManager = userManager;
+            _logger = logger;
+            _liveTvManager = liveTvManager;
+        }
+
+        public void Run()
+        {
+            _liveTvManager.TimerCancelled += _liveTvManager_TimerCancelled;
+            _liveTvManager.SeriesTimerCancelled += _liveTvManager_SeriesTimerCancelled;
+            _liveTvManager.TimerCreated += _liveTvManager_TimerCreated;
+            _liveTvManager.SeriesTimerCreated += _liveTvManager_SeriesTimerCreated;
+        }
+
+        private void _liveTvManager_SeriesTimerCreated(object sender, MediaBrowser.Model.Events.GenericEventArgs<TimerEventInfo> e)
+        {
+            SendMessage("SeriesTimerCreated", e.Argument);
+        }
+
+        private void _liveTvManager_TimerCreated(object sender, MediaBrowser.Model.Events.GenericEventArgs<TimerEventInfo> e)
+        {
+            SendMessage("TimerCreated", e.Argument);
+        }
+
+        private void _liveTvManager_SeriesTimerCancelled(object sender, MediaBrowser.Model.Events.GenericEventArgs<TimerEventInfo> e)
+        {
+            SendMessage("SeriesTimerCancelled", e.Argument);
+        }
+
+        private void _liveTvManager_TimerCancelled(object sender, MediaBrowser.Model.Events.GenericEventArgs<TimerEventInfo> e)
+        {
+            SendMessage("TimerCancelled", e.Argument);
+        }
+
+        private async void SendMessage(string name, TimerEventInfo info)
+        {
+            var users = _userManager.Users.Where(i => i.Policy.EnableLiveTvAccess).Select(i => i.Id.ToString("N")).ToList();
+
+            try
+            {
+                await _sessionManager.SendMessageToUserSessions<TimerEventInfo>(users, name, info, CancellationToken.None);
+            }
+            catch (Exception ex)
+            {
+                _logger.ErrorException("Error sending message", ex);
+            }
+        }
+
+        public void Dispose()
+        {
+            _liveTvManager.TimerCancelled -= _liveTvManager_TimerCancelled;
+            _liveTvManager.SeriesTimerCancelled -= _liveTvManager_SeriesTimerCancelled;
+            _liveTvManager.TimerCreated -= _liveTvManager_TimerCreated;
+            _liveTvManager.SeriesTimerCreated -= _liveTvManager_SeriesTimerCreated;
+        }
+    }
+}

Emby.Server.Implementations/EntryPoints/RefreshUsersMetadata.cs

@@ -0,0 +1,41 @@
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Plugins;
+using System.Threading;
+
+namespace Emby.Server.Implementations.EntryPoints
+{
+    /// <summary>
+    /// Class RefreshUsersMetadata
+    /// </summary>
+    public class RefreshUsersMetadata : IServerEntryPoint
+    {
+        /// <summary>
+        /// The _user manager
+        /// </summary>
+        private readonly IUserManager _userManager;
+
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RefreshUsersMetadata" /> class.
+        /// </summary>
+        /// <param name="userManager">The user manager.</param>
+        public RefreshUsersMetadata(IUserManager userManager)
+        {
+            _userManager = userManager;
+        }
+
+        /// <summary>
+        /// Runs this instance.
+        /// </summary>
+        public async void Run()
+        {
+            await _userManager.RefreshUsersMetadata(CancellationToken.None).ConfigureAwait(false);
+        }
+
+        /// <summary>
+        /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
+        /// </summary>
+        public void Dispose()
+        {
+        }
+    }
+}

Emby.Server.Implementations/EntryPoints/ServerEventNotifier.cs

@@ -0,0 +1,203 @@
+using MediaBrowser.Common.Plugins;
+using MediaBrowser.Common.Updates;
+using MediaBrowser.Controller;
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Net;
+using MediaBrowser.Controller.Plugins;
+using MediaBrowser.Controller.Session;
+using MediaBrowser.Controller.Sync;
+using MediaBrowser.Model.Events;
+using MediaBrowser.Model.Sync;
+using System;
+using System.Collections.Generic;
+using System.Threading;
+using MediaBrowser.Model.Tasks;
+
+namespace Emby.Server.Implementations.EntryPoints
+{
+    /// <summary>
+    /// Class WebSocketEvents
+    /// </summary>
+    public class ServerEventNotifier : IServerEntryPoint
+    {
+        /// <summary>
+        /// The _server manager
+        /// </summary>
+        private readonly IServerManager _serverManager;
+
+        /// <summary>
+        /// The _user manager
+        /// </summary>
+        private readonly IUserManager _userManager;
+
+        /// <summary>
+        /// The _installation manager
+        /// </summary>
+        private readonly IInstallationManager _installationManager;
+
+        /// <summary>
+        /// The _kernel
+        /// </summary>
+        private readonly IServerApplicationHost _appHost;
+
+        /// <summary>
+        /// The _task manager
+        /// </summary>
+        private readonly ITaskManager _taskManager;
+
+        private readonly ISessionManager _sessionManager;
+        private readonly ISyncManager _syncManager;
+
+        public ServerEventNotifier(IServerManager serverManager, IServerApplicationHost appHost, IUserManager userManager, IInstallationManager installationManager, ITaskManager taskManager, ISessionManager sessionManager, ISyncManager syncManager)
+        {
+            _serverManager = serverManager;
+            _userManager = userManager;
+            _installationManager = installationManager;
+            _appHost = appHost;
+            _taskManager = taskManager;
+            _sessionManager = sessionManager;
+            _syncManager = syncManager;
+        }
+
+        public void Run()
+        {
+            _userManager.UserDeleted += userManager_UserDeleted;
+            _userManager.UserUpdated += userManager_UserUpdated;
+            _userManager.UserConfigurationUpdated += _userManager_UserConfigurationUpdated;
+
+            _appHost.HasPendingRestartChanged += kernel_HasPendingRestartChanged;
+
+            _installationManager.PluginUninstalled += InstallationManager_PluginUninstalled;
+            _installationManager.PackageInstalling += _installationManager_PackageInstalling;
+            _installationManager.PackageInstallationCancelled += _installationManager_PackageInstallationCancelled;
+            _installationManager.PackageInstallationCompleted += _installationManager_PackageInstallationCompleted;
+            _installationManager.PackageInstallationFailed += _installationManager_PackageInstallationFailed;
+
+            _taskManager.TaskCompleted += _taskManager_TaskCompleted;
+            _syncManager.SyncJobCreated += _syncManager_SyncJobCreated;
+            _syncManager.SyncJobCancelled += _syncManager_SyncJobCancelled;
+        }
+
+        void _syncManager_SyncJobCancelled(object sender, GenericEventArgs<SyncJob> e)
+        {
+            _sessionManager.SendMessageToUserDeviceSessions(e.Argument.TargetId, "SyncJobCancelled", e.Argument, CancellationToken.None);
+        }
+
+        void _syncManager_SyncJobCreated(object sender, GenericEventArgs<SyncJobCreationResult> e)
+        {
+            _sessionManager.SendMessageToUserDeviceSessions(e.Argument.Job.TargetId, "SyncJobCreated", e.Argument, CancellationToken.None);
+        }
+
+        void _installationManager_PackageInstalling(object sender, InstallationEventArgs e)
+        {
+            _serverManager.SendWebSocketMessage("PackageInstalling", e.InstallationInfo);
+        }
+
+        void _installationManager_PackageInstallationCancelled(object sender, InstallationEventArgs e)
+        {
+            _serverManager.SendWebSocketMessage("PackageInstallationCancelled", e.InstallationInfo);
+        }
+
+        void _installationManager_PackageInstallationCompleted(object sender, InstallationEventArgs e)
+        {
+            _serverManager.SendWebSocketMessage("PackageInstallationCompleted", e.InstallationInfo);
+        }
+
+        void _installationManager_PackageInstallationFailed(object sender, InstallationFailedEventArgs e)
+        {
+            _serverManager.SendWebSocketMessage("PackageInstallationFailed", e.InstallationInfo);
+        }
+
+        void _taskManager_TaskCompleted(object sender, TaskCompletionEventArgs e)
+        {
+            _serverManager.SendWebSocketMessage("ScheduledTaskEnded", e.Result);
+        }
+
+        /// <summary>
+        /// Installations the manager_ plugin uninstalled.
+        /// </summary>
+        /// <param name="sender">The sender.</param>
+        /// <param name="e">The e.</param>
+        void InstallationManager_PluginUninstalled(object sender, GenericEventArgs<IPlugin> e)
+        {
+            _serverManager.SendWebSocketMessage("PluginUninstalled", e.Argument.GetPluginInfo());
+        }
+
+        /// <summary>
+        /// Handles the HasPendingRestartChanged event of the kernel control.
+        /// </summary>
+        /// <param name="sender">The source of the event.</param>
+        /// <param name="e">The <see cref="EventArgs" /> instance containing the event data.</param>
+        void kernel_HasPendingRestartChanged(object sender, EventArgs e)
+        {
+            _sessionManager.SendRestartRequiredNotification(CancellationToken.None);
+        }
+
+        /// <summary>
+        /// Users the manager_ user updated.
+        /// </summary>
+        /// <param name="sender">The sender.</param>
+        /// <param name="e">The e.</param>
+        void userManager_UserUpdated(object sender, GenericEventArgs<User> e)
+        {
+            var dto = _userManager.GetUserDto(e.Argument);
+
+            SendMessageToUserSession(e.Argument, "UserUpdated", dto);
+        }
+
+        /// <summary>
+        /// Users the manager_ user deleted.
+        /// </summary>
+        /// <param name="sender">The sender.</param>
+        /// <param name="e">The e.</param>
+        void userManager_UserDeleted(object sender, GenericEventArgs<User> e)
+        {
+            SendMessageToUserSession(e.Argument, "UserDeleted", e.Argument.Id.ToString("N"));
+        }
+
+        void _userManager_UserConfigurationUpdated(object sender, GenericEventArgs<User> e)
+        {
+            var dto = _userManager.GetUserDto(e.Argument);
+
+            SendMessageToUserSession(e.Argument, "UserConfigurationUpdated", dto);
+        }
+
+        private async void SendMessageToUserSession<T>(User user, string name, T data)
+        {
+            await _sessionManager.SendMessageToUserSessions(new List<string> { user.Id.ToString("N") }, name, data, CancellationToken.None);
+        }
+
+        /// <summary>
+        /// Performs application-defined tasks associated with freeing, releasing, or resetting unmanaged resources.
+        /// </summary>
+        public void Dispose()
+        {
+            Dispose(true);
+        }
+
+        /// <summary>
+        /// Releases unmanaged and - optionally - managed resources.
+        /// </summary>
+        /// <param name="dispose"><c>true</c> to release both managed and unmanaged resources; <c>false</c> to release only unmanaged resources.</param>
+        protected virtual void Dispose(bool dispose)
+        {
+            if (dispose)
+            {
+                _userManager.UserDeleted -= userManager_UserDeleted;
+                _userManager.UserUpdated -= userManager_UserUpdated;
+                _userManager.UserConfigurationUpdated -= _userManager_UserConfigurationUpdated;
+
+                _installationManager.PluginUninstalled -= InstallationManager_PluginUninstalled;
+                _installationManager.PackageInstalling -= _installationManager_PackageInstalling;
+                _installationManager.PackageInstallationCancelled -= _installationManager_PackageInstallationCancelled;
+                _installationManager.PackageInstallationCompleted -= _installationManager_PackageInstallationCompleted;
+                _installationManager.PackageInstallationFailed -= _installationManager_PackageInstallationFailed;
+
+                _appHost.HasPendingRestartChanged -= kernel_HasPendingRestartChanged;
+                _syncManager.SyncJobCreated -= _syncManager_SyncJobCreated;
+                _syncManager.SyncJobCancelled -= _syncManager_SyncJobCancelled;
+            }
+        }
+    }
+}

Emby.Server.Implementations/EntryPoints/UsageEntryPoint.cs

@@ -0,0 +1,133 @@
+using MediaBrowser.Common;
+using MediaBrowser.Common.Extensions;
+using MediaBrowser.Common.Net;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Plugins;
+using MediaBrowser.Controller.Session;
+using MediaBrowser.Model.Logging;
+using System;
+using System.Collections.Concurrent;
+using System.Collections.Generic;
+using System.Threading;
+using System.Threading.Tasks;
+using MediaBrowser.Controller.Configuration;
+
+namespace Emby.Server.Implementations.EntryPoints
+{
+    /// <summary>
+    /// Class UsageEntryPoint
+    /// </summary>
+    public class UsageEntryPoint : IServerEntryPoint
+    {
+        private readonly IApplicationHost _applicationHost;
+        private readonly IHttpClient _httpClient;
+        private readonly ILogger _logger;
+        private readonly ISessionManager _sessionManager;
+        private readonly IUserManager _userManager;
+        private readonly IServerConfigurationManager _config;
+
+        private readonly ConcurrentDictionary<Guid, ClientInfo> _apps = new ConcurrentDictionary<Guid, ClientInfo>();
+
+        public UsageEntryPoint(ILogger logger, IApplicationHost applicationHost, IHttpClient httpClient, ISessionManager sessionManager, IUserManager userManager, IServerConfigurationManager config)
+        {
+            _logger = logger;
+            _applicationHost = applicationHost;
+            _httpClient = httpClient;
+            _sessionManager = sessionManager;
+            _userManager = userManager;
+            _config = config;
+
+            _sessionManager.SessionStarted += _sessionManager_SessionStarted;
+        }
+
+        void _sessionManager_SessionStarted(object sender, SessionEventArgs e)
+        {
+            var session = e.SessionInfo;
+
+            if (!string.IsNullOrEmpty(session.Client) &&
+                !string.IsNullOrEmpty(session.DeviceName) &&
+                !string.IsNullOrEmpty(session.DeviceId) &&
+                !string.IsNullOrEmpty(session.ApplicationVersion))
+            {
+                var keys = new List<string>
+                {
+                    session.Client,
+                    session.DeviceName,
+                    session.DeviceId,
+                    session.ApplicationVersion
+                };
+
+                var key = string.Join("_", keys.ToArray()).GetMD5();
+
+                _apps.GetOrAdd(key, guid => GetNewClientInfo(session));
+            }
+        }
+
+        private async void ReportNewSession(ClientInfo client)
+        {
+            if (!_config.Configuration.EnableAnonymousUsageReporting)
+            {
+                return;
+            }
+
+            try
+            {
+                await new UsageReporter(_applicationHost, _httpClient, _userManager, _logger)
+                    .ReportAppUsage(client, CancellationToken.None)
+                    .ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                _logger.ErrorException("Error sending anonymous usage statistics.", ex);
+            }
+        }
+
+        private ClientInfo GetNewClientInfo(SessionInfo session)
+        {
+            var info = new ClientInfo
+            {
+                AppName = session.Client,
+                AppVersion = session.ApplicationVersion,
+                DeviceName = session.DeviceName,
+                DeviceId = session.DeviceId
+            };
+
+            ReportNewSession(info);
+
+            return info;
+        }
+
+        public async void Run()
+        {
+            await Task.Delay(5000).ConfigureAwait(false);
+            OnTimerFired();
+        }
+
+        /// <summary>
+        /// Called when [timer fired].
+        /// </summary>
+        private async void OnTimerFired()
+        {
+            if (!_config.Configuration.EnableAnonymousUsageReporting)
+            {
+                return;
+            }
+
+            try
+            {
+                await new UsageReporter(_applicationHost, _httpClient, _userManager, _logger)
+                    .ReportServerUsage(CancellationToken.None)
+                    .ConfigureAwait(false);
+            }
+            catch (Exception ex)
+            {
+                _logger.ErrorException("Error sending anonymous usage statistics.", ex);
+            }
+        }
+
+        public void Dispose()
+        {
+            _sessionManager.SessionStarted -= _sessionManager_SessionStarted;
+        }
+    }
+}

Emby.Server.Implementations/EntryPoints/UsageReporter.cs

@@ -0,0 +1,138 @@
+using MediaBrowser.Common;
+using MediaBrowser.Common.Net;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Model.Connect;
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using MediaBrowser.Model.Logging;
+
+namespace Emby.Server.Implementations.EntryPoints
+{
+    public class UsageReporter
+    {
+        private readonly IApplicationHost _applicationHost;
+        private readonly IHttpClient _httpClient;
+        private readonly IUserManager _userManager;
+        private readonly ILogger _logger;
+        private const string MbAdminUrl = "https://www.mb3admin.com/admin/";
+
+        public UsageReporter(IApplicationHost applicationHost, IHttpClient httpClient, IUserManager userManager, ILogger logger)
+        {
+            _applicationHost = applicationHost;
+            _httpClient = httpClient;
+            _userManager = userManager;
+            _logger = logger;
+        }
+
+        public async Task ReportServerUsage(CancellationToken cancellationToken)
+        {
+            cancellationToken.ThrowIfCancellationRequested();
+
+            var data = new Dictionary<string, string>
+            {
+                { "feature", _applicationHost.Name }, 
+                { "mac", _applicationHost.SystemId }, 
+                { "serverid", _applicationHost.SystemId }, 
+                { "deviceid", _applicationHost.SystemId }, 
+                { "ver", _applicationHost.ApplicationVersion.ToString() }, 
+                { "platform", _applicationHost.OperatingSystemDisplayName }, 
+                { "isservice", _applicationHost.IsRunningAsService.ToString().ToLower()}
+            };
+
+            var users = _userManager.Users.ToList();
+
+            data["localusers"] = users.Count(i => !i.ConnectLinkType.HasValue).ToString(CultureInfo.InvariantCulture);
+            data["guests"] = users.Count(i => i.ConnectLinkType.HasValue && i.ConnectLinkType.Value == UserLinkType.Guest).ToString(CultureInfo.InvariantCulture);
+            data["linkedusers"] = users.Count(i => i.ConnectLinkType.HasValue && i.ConnectLinkType.Value == UserLinkType.LinkedUser).ToString(CultureInfo.InvariantCulture);
+
+            data["plugins"] = string.Join(",", _applicationHost.Plugins.Select(i => i.Id).ToArray());
+
+            var logErrors = false;
+#if DEBUG
+            logErrors = true;
+#endif
+            var options = new HttpRequestOptions
+            {
+                Url = MbAdminUrl + "service/registration/ping",
+                CancellationToken = cancellationToken,
+
+                // Seeing block length errors
+                EnableHttpCompression = false,
+
+                LogRequest = false,
+                LogErrors = logErrors,
+                BufferContent = false
+            };
+
+            options.SetPostData(data);
+
+            using (var response = await _httpClient.SendAsync(options, "POST").ConfigureAwait(false))
+            {
+                
+            }
+        }
+
+        public async Task ReportAppUsage(ClientInfo app, CancellationToken cancellationToken)
+        {
+            if (string.IsNullOrWhiteSpace(app.DeviceId))
+            {
+                throw new ArgumentException("Client info must have a device Id");
+            }
+
+            _logger.Info("App Activity: app: {0}, version: {1}, deviceId: {2}, deviceName: {3}",
+                app.AppName ?? "Unknown App",
+                app.AppVersion ?? "Unknown",
+                app.DeviceId,
+                app.DeviceName ?? "Unknown");
+
+            cancellationToken.ThrowIfCancellationRequested();
+
+            var data = new Dictionary<string, string>
+            {
+                { "feature", app.AppName ?? "Unknown App" }, 
+                { "serverid", _applicationHost.SystemId }, 
+                { "deviceid", app.DeviceId }, 
+                { "mac", app.DeviceId }, 
+                { "ver", app.AppVersion ?? "Unknown" }, 
+                { "platform", app.DeviceName }, 
+            };
+
+            var logErrors = false;
+
+#if DEBUG
+            logErrors = true;
+#endif
+            var options = new HttpRequestOptions
+            {
+                Url = MbAdminUrl + "service/registration/ping",
+                CancellationToken = cancellationToken,
+
+                // Seeing block length errors
+                EnableHttpCompression = false,
+
+                LogRequest = false,
+                LogErrors = logErrors,
+                BufferContent = false
+            };
+
+            options.SetPostData(data);
+
+            using (var response = await _httpClient.SendAsync(options, "POST").ConfigureAwait(false))
+            {
+
+            }
+        }
+    }
+
+    public class ClientInfo
+    {
+        public string AppName { get; set; }
+        public string AppVersion { get; set; }
+        public string DeviceName { get; set; }
+        public string DeviceId { get; set; }
+    }
+}

Emby.Server.Implementations/EntryPoints/UserDataChangeNotifier.cs

@@ -0,0 +1,165 @@
+using MediaBrowser.Controller.Entities;
+using MediaBrowser.Controller.Library;
+using MediaBrowser.Controller.Plugins;
+using MediaBrowser.Controller.Session;
+using MediaBrowser.Model.Entities;
+using MediaBrowser.Model.Logging;
+using MediaBrowser.Model.Session;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+using System.Threading.Tasks;
+using MediaBrowser.Model.Extensions;
+using MediaBrowser.Model.Threading;
+
+namespace Emby.Server.Implementations.EntryPoints
+{
+    class UserDataChangeNotifier : IServerEntryPoint
+    {
+        private readonly ISessionManager _sessionManager;
+        private readonly ILogger _logger;
+        private readonly IUserDataManager _userDataManager;
+        private readonly IUserManager _userManager;
+
+        private readonly object _syncLock = new object();
+        private ITimer UpdateTimer { get; set; }
+        private readonly ITimerFactory _timerFactory;
+        private const int UpdateDuration = 500;
+
+        private readonly Dictionary<Guid, List<IHasUserData>> _changedItems = new Dictionary<Guid, List<IHasUserData>>();
+
+        public UserDataChangeNotifier(IUserDataManager userDataManager, ISessionManager sessionManager, ILogger logger, IUserManager userManager, ITimerFactory timerFactory)
+        {
+            _userDataManager = userDataManager;
+            _sessionManager = sessionManager;
+            _logger = logger;
+            _userManager = userManager;
+            _timerFactory = timerFactory;
+        }
+
+        public void Run()
+        {
+            _userDataManager.UserDataSaved += _userDataManager_UserDataSaved;
+        }
+
+        void _userDataManager_UserDataSaved(object sender, UserDataSaveEventArgs e)
+        {
+            if (e.SaveReason == UserDataSaveReason.PlaybackProgress)
+            {
+                return;
+            }
+
+            lock (_syncLock)
+            {
+                if (UpdateTimer == null)
+                {
+                    UpdateTimer = _timerFactory.Create(UpdateTimerCallback, null, UpdateDuration,
+                                                   Timeout.Infinite);
+                }
+                else
+                {
+                    UpdateTimer.Change(UpdateDuration, Timeout.Infinite);
+                }
+
+                List<IHasUserData> keys;
+
+                if (!_changedItems.TryGetValue(e.UserId, out keys))
+                {
+                    keys = new List<IHasUserData>();
+                    _changedItems[e.UserId] = keys;
+                }
+
+                keys.Add(e.Item);
+
+                var baseItem = e.Item as BaseItem;
+
+                // Go up one level for indicators
+                if (baseItem != null)
+                {
+                    var parent = baseItem.GetParent();
+
+                    if (parent != null)
+                    {
+                        keys.Add(parent);
+                    }
+                }
+            }
+        }
+
+        private void UpdateTimerCallback(object state)
+        {
+            lock (_syncLock)
+            {
+                // Remove dupes in case some were saved multiple times
+                var changes = _changedItems.ToList();
+                _changedItems.Clear();
+
+                var task = SendNotifications(changes, CancellationToken.None);
+
+                if (UpdateTimer != null)
+                {
+                    UpdateTimer.Dispose();
+                    UpdateTimer = null;
+                }
+            }
+        }
+
+        private async Task SendNotifications(IEnumerable<KeyValuePair<Guid, List<IHasUserData>>> changes, CancellationToken cancellationToken)
+        {
+            foreach (var pair in changes)
+            {
+                var userId = pair.Key;
+                var userSessions = _sessionManager.Sessions
+                    .Where(u => u.ContainsUser(userId) && u.SessionController != null && u.IsActive)
+                    .ToList();
+
+                if (userSessions.Count > 0)
+                {
+                    var user = _userManager.GetUserById(userId);
+
+                    var dtoList = pair.Value
+                        .DistinctBy(i => i.Id)
+                        .Select(i =>
+                        {
+                            var dto = _userDataManager.GetUserDataDto(i, user).Result;
+                            dto.ItemId = i.Id.ToString("N");
+                            return dto;
+                        })
+                        .ToList();
+
+                    var info = new UserDataChangeInfo
+                    {
+                        UserId = userId.ToString("N"),
+
+                        UserDataList = dtoList
+                    };
+
+                    foreach (var userSession in userSessions)
+                    {
+                        try
+                        {
+                            await userSession.SessionController.SendUserDataChangeInfo(info, cancellationToken).ConfigureAwait(false);
+                        }
+                        catch (Exception ex)
+                        {
+                            _logger.ErrorException("Error sending UserDataChanged message", ex);
+                        }
+                    }
+                }
+
+            }
+        }
+
+        public void Dispose()
+        {
+            if (UpdateTimer != null)
+            {
+                UpdateTimer.Dispose();
+                UpdateTimer = null;
+            }
+
+            _userDataManager.UserDataSaved -= _userDataManager_UserDataSaved;
+        }
+    }
+}