< Summary - Jellyfin

Information
Class: Jellyfin.Server.Implementations.Devices.DeviceManager
Assembly: Jellyfin.Server.Implementations
File(s): /srv/git/jellyfin/Jellyfin.Server.Implementations/Devices/DeviceManager.cs
Line coverage
38%
Covered lines: 43
Uncovered lines: 69
Coverable lines: 112
Total lines: 311
Line coverage: 38.3%
Branch coverage
28%
Covered branches: 9
Total branches: 32
Branch coverage: 28.1%
Method coverage

Feature is only available for sponsors

Upgrade to PRO version

Coverage history

Coverage history 0 25 50 75 100

Metrics

MethodBranch coverage Crap Score Cyclomatic complexity Line coverage
.ctor(...)50%4486.66%
SaveCapabilities(...)100%210%
GetDeviceOptions(...)50%2266.66%
GetCapabilities(...)50%4480%
GetDevice(...)0%2040%
GetDevices(...)50%4483.33%
GetDeviceInfos(...)100%210%
GetDevicesForUser(...)0%2040%
CanAccessDevice(...)33.33%7666.66%
ToDeviceInfo(...)0%2040%
ToDeviceOptionsDto(...)100%210%
ToDeviceInfoDto(...)100%210%
ToClientCapabilitiesDto(...)100%11100%

File(s)

/srv/git/jellyfin/Jellyfin.Server.Implementations/Devices/DeviceManager.cs

#LineLine coverage
 1using System;
 2using System.Collections.Concurrent;
 3using System.Collections.Generic;
 4using System.Linq;
 5using System.Threading.Tasks;
 6using Jellyfin.Data;
 7using Jellyfin.Data.Dtos;
 8using Jellyfin.Data.Events;
 9using Jellyfin.Data.Queries;
 10using Jellyfin.Database.Implementations;
 11using Jellyfin.Database.Implementations.Entities;
 12using Jellyfin.Database.Implementations.Entities.Security;
 13using Jellyfin.Database.Implementations.Enums;
 14using Jellyfin.Extensions;
 15using MediaBrowser.Common.Extensions;
 16using MediaBrowser.Controller.Devices;
 17using MediaBrowser.Controller.Library;
 18using MediaBrowser.Model.Devices;
 19using MediaBrowser.Model.Dto;
 20using MediaBrowser.Model.Querying;
 21using MediaBrowser.Model.Session;
 22using Microsoft.EntityFrameworkCore;
 23
 24namespace Jellyfin.Server.Implementations.Devices
 25{
 26    /// <summary>
 27    /// Manages the creation, updating, and retrieval of devices.
 28    /// </summary>
 29    public class DeviceManager : IDeviceManager
 30    {
 31        private readonly IDbContextFactory<JellyfinDbContext> _dbProvider;
 32        private readonly IUserManager _userManager;
 2133        private readonly ConcurrentDictionary<string, ClientCapabilities> _capabilitiesMap = new();
 34        private readonly ConcurrentDictionary<int, Device> _devices;
 35        private readonly ConcurrentDictionary<string, DeviceOptions> _deviceOptions;
 36
 37        /// <summary>
 38        /// Initializes a new instance of the <see cref="DeviceManager"/> class.
 39        /// </summary>
 40        /// <param name="dbProvider">The database provider.</param>
 41        /// <param name="userManager">The user manager.</param>
 42        public DeviceManager(IDbContextFactory<JellyfinDbContext> dbProvider, IUserManager userManager)
 43        {
 2144            _dbProvider = dbProvider;
 2145            _userManager = userManager;
 2146            _devices = new ConcurrentDictionary<int, Device>();
 2147            _deviceOptions = new ConcurrentDictionary<string, DeviceOptions>();
 48
 2149            using var dbContext = _dbProvider.CreateDbContext();
 4250            foreach (var device in dbContext.Devices
 2151                         .OrderBy(d => d.Id)
 2152                         .AsEnumerable())
 53            {
 054                _devices.TryAdd(device.Id, device);
 55            }
 56
 4257            foreach (var deviceOption in dbContext.DeviceOptions
 2158                         .OrderBy(d => d.Id)
 2159                         .AsEnumerable())
 60            {
 061                _deviceOptions.TryAdd(deviceOption.DeviceId, deviceOption);
 62            }
 2163        }
 64
 65        /// <inheritdoc />
 66        public event EventHandler<GenericEventArgs<Tuple<string, DeviceOptions>>>? DeviceOptionsUpdated;
 67
 68        /// <inheritdoc />
 69        public void SaveCapabilities(string deviceId, ClientCapabilities capabilities)
 70        {
 071            _capabilitiesMap[deviceId] = capabilities;
 072        }
 73
 74        /// <inheritdoc />
 75        public async Task UpdateDeviceOptions(string deviceId, string? deviceName)
 76        {
 77            DeviceOptions? deviceOptions;
 78            var dbContext = await _dbProvider.CreateDbContextAsync().ConfigureAwait(false);
 79            await using (dbContext.ConfigureAwait(false))
 80            {
 81                deviceOptions = await dbContext.DeviceOptions.FirstOrDefaultAsync(dev => dev.DeviceId == deviceId).Confi
 82                if (deviceOptions is null)
 83                {
 84                    deviceOptions = new DeviceOptions(deviceId);
 85                    dbContext.DeviceOptions.Add(deviceOptions);
 86                }
 87
 88                deviceOptions.CustomName = deviceName;
 89                await dbContext.SaveChangesAsync().ConfigureAwait(false);
 90            }
 91
 92            _deviceOptions[deviceId] = deviceOptions;
 93
 94            DeviceOptionsUpdated?.Invoke(this, new GenericEventArgs<Tuple<string, DeviceOptions>>(new Tuple<string, Devi
 95        }
 96
 97        /// <inheritdoc />
 98        public async Task<Device> CreateDevice(Device device)
 99        {
 100            var dbContext = await _dbProvider.CreateDbContextAsync().ConfigureAwait(false);
 101            await using (dbContext.ConfigureAwait(false))
 102            {
 103                dbContext.Devices.Add(device);
 104                await dbContext.SaveChangesAsync().ConfigureAwait(false);
 105                _devices.TryAdd(device.Id, device);
 106            }
 107
 108            return device;
 109        }
 110
 111        /// <inheritdoc />
 112        public DeviceOptionsDto? GetDeviceOptions(string deviceId)
 113        {
 15114            if (_deviceOptions.TryGetValue(deviceId, out var deviceOptions))
 115            {
 0116                return ToDeviceOptionsDto(deviceOptions);
 117            }
 118
 15119            return null;
 120        }
 121
 122        /// <inheritdoc />
 123        public ClientCapabilities GetCapabilities(string? deviceId)
 124        {
 15125            if (deviceId is null)
 126            {
 0127                return new();
 128            }
 129
 15130            return _capabilitiesMap.TryGetValue(deviceId, out ClientCapabilities? result)
 15131                ? result
 15132                : new();
 133        }
 134
 135        /// <inheritdoc />
 136        public DeviceInfoDto? GetDevice(string id)
 137        {
 0138            var device = _devices.Values.Where(d => d.DeviceId == id).OrderByDescending(d => d.DateLastActivity).FirstOr
 0139            _deviceOptions.TryGetValue(id, out var deviceOption);
 140
 0141            var deviceInfo = device is null ? null : ToDeviceInfo(device, deviceOption);
 0142            return deviceInfo is null ? null : ToDeviceInfoDto(deviceInfo);
 143        }
 144
 145        /// <inheritdoc />
 146        public QueryResult<Device> GetDevices(DeviceQuery query)
 147        {
 115148            IEnumerable<Device> devices = _devices.Values
 115149                .Where(device => !query.UserId.HasValue || device.UserId.Equals(query.UserId.Value))
 115150                .Where(device => query.DeviceId is null || device.DeviceId == query.DeviceId)
 115151                .Where(device => query.AccessToken is null || device.AccessToken == query.AccessToken)
 115152                .OrderBy(d => d.Id)
 115153                .ToList();
 115154            var count = devices.Count();
 155
 115156            if (query.Skip.HasValue)
 157            {
 0158                devices = devices.Skip(query.Skip.Value);
 159            }
 160
 115161            if (query.Limit.HasValue)
 162            {
 0163                devices = devices.Take(query.Limit.Value);
 164            }
 165
 115166            return new QueryResult<Device>(query.Skip, count, devices.ToList());
 167        }
 168
 169        /// <inheritdoc />
 170        public QueryResult<DeviceInfo> GetDeviceInfos(DeviceQuery query)
 171        {
 0172            var devices = GetDevices(query);
 173
 0174            return new QueryResult<DeviceInfo>(
 0175                devices.StartIndex,
 0176                devices.TotalRecordCount,
 0177                devices.Items.Select(device => ToDeviceInfo(device)).ToList());
 178        }
 179
 180        /// <inheritdoc />
 181        public QueryResult<DeviceInfoDto> GetDevicesForUser(Guid? userId)
 182        {
 0183            IEnumerable<Device> devices = _devices.Values
 0184                .OrderByDescending(d => d.DateLastActivity)
 0185                .ThenBy(d => d.DeviceId);
 186
 0187            if (!userId.IsNullOrEmpty())
 188            {
 0189                var user = _userManager.GetUserById(userId.Value);
 0190                if (user is null)
 191                {
 0192                    throw new ResourceNotFoundException();
 193                }
 194
 0195                devices = devices.Where(i => CanAccessDevice(user, i.DeviceId));
 196            }
 197
 0198            var array = devices.Select(device =>
 0199                {
 0200                    _deviceOptions.TryGetValue(device.DeviceId, out var option);
 0201                    return ToDeviceInfo(device, option);
 0202                })
 0203                .Select(ToDeviceInfoDto)
 0204                .ToArray();
 205
 0206            return new QueryResult<DeviceInfoDto>(array);
 207        }
 208
 209        /// <inheritdoc />
 210        public async Task DeleteDevice(Device device)
 211        {
 212            _devices.TryRemove(device.Id, out _);
 213            var dbContext = await _dbProvider.CreateDbContextAsync().ConfigureAwait(false);
 214            await using (dbContext.ConfigureAwait(false))
 215            {
 216                dbContext.Devices.Remove(device);
 217                await dbContext.SaveChangesAsync().ConfigureAwait(false);
 218            }
 219        }
 220
 221        /// <inheritdoc />
 222        public async Task UpdateDevice(Device device)
 223        {
 224            var dbContext = await _dbProvider.CreateDbContextAsync().ConfigureAwait(false);
 225            await using (dbContext.ConfigureAwait(false))
 226            {
 227                dbContext.Devices.Update(device);
 228                await dbContext.SaveChangesAsync().ConfigureAwait(false);
 229            }
 230
 231            _devices[device.Id] = device;
 232        }
 233
 234        /// <inheritdoc />
 235        public bool CanAccessDevice(User user, string deviceId)
 236        {
 15237            ArgumentNullException.ThrowIfNull(user);
 15238            ArgumentException.ThrowIfNullOrEmpty(deviceId);
 239
 15240            if (user.HasPermission(PermissionKind.EnableAllDevices) || user.HasPermission(PermissionKind.IsAdministrator
 241            {
 15242                return true;
 243            }
 244
 0245            return user.GetPreference(PreferenceKind.EnabledDevices).Contains(deviceId, StringComparison.OrdinalIgnoreCa
 0246                   || !GetCapabilities(deviceId).SupportsPersistentIdentifier;
 247        }
 248
 249        private DeviceInfo ToDeviceInfo(Device authInfo, DeviceOptions? options = null)
 250        {
 0251            var caps = GetCapabilities(authInfo.DeviceId);
 0252            var user = _userManager.GetUserById(authInfo.UserId) ?? throw new ResourceNotFoundException("User with UserI
 253
 0254            return new()
 0255            {
 0256                AppName = authInfo.AppName,
 0257                AppVersion = authInfo.AppVersion,
 0258                Id = authInfo.DeviceId,
 0259                LastUserId = authInfo.UserId,
 0260                LastUserName = user.Username,
 0261                Name = authInfo.DeviceName,
 0262                DateLastActivity = authInfo.DateLastActivity,
 0263                IconUrl = caps.IconUrl,
 0264                CustomName = options?.CustomName,
 0265            };
 266        }
 267
 268        private DeviceOptionsDto ToDeviceOptionsDto(DeviceOptions options)
 269        {
 0270            return new()
 0271            {
 0272                Id = options.Id,
 0273                DeviceId = options.DeviceId,
 0274                CustomName = options.CustomName,
 0275            };
 276        }
 277
 278        private DeviceInfoDto ToDeviceInfoDto(DeviceInfo info)
 279        {
 0280            return new()
 0281            {
 0282                Name = info.Name,
 0283                CustomName = info.CustomName,
 0284                AccessToken = info.AccessToken,
 0285                Id = info.Id,
 0286                LastUserName = info.LastUserName,
 0287                AppName = info.AppName,
 0288                AppVersion = info.AppVersion,
 0289                LastUserId = info.LastUserId,
 0290                DateLastActivity = info.DateLastActivity,
 0291                Capabilities = ToClientCapabilitiesDto(info.Capabilities),
 0292                IconUrl = info.IconUrl
 0293            };
 294        }
 295
 296        /// <inheritdoc />
 297        public ClientCapabilitiesDto ToClientCapabilitiesDto(ClientCapabilities capabilities)
 298        {
 15299            return new()
 15300            {
 15301                PlayableMediaTypes = capabilities.PlayableMediaTypes,
 15302                SupportedCommands = capabilities.SupportedCommands,
 15303                SupportsMediaControl = capabilities.SupportsMediaControl,
 15304                SupportsPersistentIdentifier = capabilities.SupportsPersistentIdentifier,
 15305                DeviceProfile = capabilities.DeviceProfile,
 15306                AppStoreUrl = capabilities.AppStoreUrl,
 15307                IconUrl = capabilities.IconUrl
 15308            };
 309        }
 310    }
 311}
Generated by: ReportGenerator 5.4.5.0
4/26/2025 - 12:10:59 AM
GitHub | reportgenerator.io

Methods/Properties

.ctor(Microsoft.EntityFrameworkCore.IDbContextFactory`1<Jellyfin.Database.Implementations.JellyfinDbContext>,MediaBrowser.Controller.Library.IUserManager)
SaveCapabilities(System.String,MediaBrowser.Model.Session.ClientCapabilities)
GetDeviceOptions(System.String)
GetCapabilities(System.String)
GetDevice(System.String)
GetDevices(Jellyfin.Data.Queries.DeviceQuery)
GetDeviceInfos(Jellyfin.Data.Queries.DeviceQuery)
GetDevicesForUser(System.Nullable`1<System.Guid>)
CanAccessDevice(Jellyfin.Database.Implementations.Entities.User,System.String)
ToDeviceInfo(Jellyfin.Database.Implementations.Entities.Security.Device,Jellyfin.Database.Implementations.Entities.Security.DeviceOptions)
ToDeviceOptionsDto(Jellyfin.Database.Implementations.Entities.Security.DeviceOptions)
ToDeviceInfoDto(MediaBrowser.Model.Devices.DeviceInfo)
ToClientCapabilitiesDto(MediaBrowser.Model.Session.ClientCapabilities)