jellyfin/Emby.Dlna/Main/DlnaEntryPoint.cs

416 lines
14 KiB
C#
Raw Normal View History

#pragma warning disable CS1591
#pragma warning disable SA1600
using System;
using System.Net.Sockets;
using System.Globalization;
2019-01-13 19:16:19 +00:00
using System.Threading;
using System.Threading.Tasks;
using Emby.Dlna.PlayTo;
using Emby.Dlna.Ssdp;
using MediaBrowser.Common.Configuration;
2016-10-29 22:22:20 +00:00
using MediaBrowser.Common.Extensions;
using MediaBrowser.Common.Net;
using MediaBrowser.Controller;
using MediaBrowser.Controller.Configuration;
using MediaBrowser.Controller.Dlna;
using MediaBrowser.Controller.Drawing;
using MediaBrowser.Controller.Library;
2019-01-13 19:16:19 +00:00
using MediaBrowser.Controller.MediaEncoding;
2016-10-29 22:22:20 +00:00
using MediaBrowser.Controller.Plugins;
using MediaBrowser.Controller.Session;
2018-09-12 17:26:21 +00:00
using MediaBrowser.Controller.TV;
2016-10-29 22:22:20 +00:00
using MediaBrowser.Model.Dlna;
using MediaBrowser.Model.Globalization;
2016-11-04 08:31:05 +00:00
using MediaBrowser.Model.Net;
2016-11-04 19:51:59 +00:00
using MediaBrowser.Model.System;
2019-01-13 19:16:19 +00:00
using Microsoft.Extensions.Logging;
2016-10-29 22:22:20 +00:00
using Rssdp;
using Rssdp.Infrastructure;
using OperatingSystem = MediaBrowser.Common.System.OperatingSystem;
2016-10-29 22:22:20 +00:00
2016-10-29 22:34:54 +00:00
namespace Emby.Dlna.Main
2016-10-29 22:22:20 +00:00
{
2018-09-12 17:26:21 +00:00
public class DlnaEntryPoint : IServerEntryPoint, IRunBeforeStartup
2016-10-29 22:22:20 +00:00
{
private readonly IServerConfigurationManager _config;
private readonly ILogger _logger;
private readonly IServerApplicationHost _appHost;
private PlayToManager _manager;
private readonly ISessionManager _sessionManager;
private readonly IHttpClient _httpClient;
private readonly ILibraryManager _libraryManager;
private readonly IUserManager _userManager;
private readonly IDlnaManager _dlnaManager;
private readonly IImageProcessor _imageProcessor;
private readonly IUserDataManager _userDataManager;
private readonly ILocalizationManager _localization;
private readonly IMediaSourceManager _mediaSourceManager;
private readonly IMediaEncoder _mediaEncoder;
private readonly IDeviceDiscovery _deviceDiscovery;
private SsdpDevicePublisher _Publisher;
2016-11-04 08:31:05 +00:00
private readonly ISocketFactory _socketFactory;
2016-12-04 21:30:38 +00:00
private readonly INetworkManager _networkManager;
2016-11-04 08:31:05 +00:00
2016-11-14 19:48:01 +00:00
private ISsdpCommunicationsServer _communicationsServer;
2018-09-12 17:26:21 +00:00
internal IContentDirectory ContentDirectory { get; private set; }
internal IConnectionManager ConnectionManager { get; private set; }
internal IMediaReceiverRegistrar MediaReceiverRegistrar { get; private set; }
public static DlnaEntryPoint Current;
2016-10-29 22:22:20 +00:00
public DlnaEntryPoint(IServerConfigurationManager config,
ILoggerFactory loggerFactory,
2016-10-29 22:22:20 +00:00
IServerApplicationHost appHost,
ISessionManager sessionManager,
IHttpClient httpClient,
ILibraryManager libraryManager,
IUserManager userManager,
IDlnaManager dlnaManager,
IImageProcessor imageProcessor,
IUserDataManager userDataManager,
2018-09-12 17:26:21 +00:00
ILocalizationManager localizationManager,
2016-10-29 22:22:20 +00:00
IMediaSourceManager mediaSourceManager,
2019-01-07 23:27:46 +00:00
IDeviceDiscovery deviceDiscovery,
IMediaEncoder mediaEncoder,
ISocketFactory socketFactory,
2018-09-12 17:26:21 +00:00
INetworkManager networkManager,
IUserViewManager userViewManager,
ITVSeriesManager tvSeriesManager)
2016-10-29 22:22:20 +00:00
{
_config = config;
_appHost = appHost;
_sessionManager = sessionManager;
_httpClient = httpClient;
_libraryManager = libraryManager;
_userManager = userManager;
_dlnaManager = dlnaManager;
_imageProcessor = imageProcessor;
_userDataManager = userDataManager;
2018-09-12 17:26:21 +00:00
_localization = localizationManager;
2016-10-29 22:22:20 +00:00
_mediaSourceManager = mediaSourceManager;
_deviceDiscovery = deviceDiscovery;
_mediaEncoder = mediaEncoder;
2016-11-04 08:31:05 +00:00
_socketFactory = socketFactory;
2016-12-04 21:30:38 +00:00
_networkManager = networkManager;
_logger = loggerFactory.CreateLogger("Dlna");
2018-09-12 17:26:21 +00:00
ContentDirectory = new ContentDirectory.ContentDirectory(
dlnaManager,
2019-01-07 23:27:46 +00:00
userDataManager,
imageProcessor,
libraryManager,
config,
userManager,
_logger,
httpClient,
localizationManager,
mediaSourceManager,
2018-09-12 17:26:21 +00:00
userViewManager,
2019-01-07 23:27:46 +00:00
mediaEncoder,
2018-09-12 17:26:21 +00:00
tvSeriesManager);
ConnectionManager = new ConnectionManager.ConnectionManager(dlnaManager, config, _logger, httpClient);
2018-09-12 17:26:21 +00:00
MediaReceiverRegistrar = new MediaReceiverRegistrar.MediaReceiverRegistrar(_logger, httpClient, config);
2018-09-12 17:26:21 +00:00
Current = this;
2016-10-29 22:22:20 +00:00
}
2019-01-27 14:40:37 +00:00
public async Task RunAsync()
2016-10-29 22:22:20 +00:00
{
2019-01-27 14:40:37 +00:00
await ((DlnaManager)_dlnaManager).InitProfilesAsync().ConfigureAwait(false);
2016-10-29 22:22:20 +00:00
ReloadComponents();
_config.NamedConfigurationUpdated += _config_NamedConfigurationUpdated;
}
void _config_NamedConfigurationUpdated(object sender, ConfigurationUpdateEventArgs e)
{
if (string.Equals(e.Key, "dlna", StringComparison.OrdinalIgnoreCase))
{
ReloadComponents();
}
}
private async void ReloadComponents()
{
var options = _config.GetDlnaConfiguration();
2018-09-12 17:26:21 +00:00
StartSsdpHandler();
2016-10-29 22:22:20 +00:00
2018-09-12 17:26:21 +00:00
if (options.EnableServer)
2016-10-29 22:22:20 +00:00
{
2018-09-12 17:26:21 +00:00
await StartDevicePublisher(options).ConfigureAwait(false);
2016-10-29 22:22:20 +00:00
}
2018-09-12 17:26:21 +00:00
else
2016-10-29 22:22:20 +00:00
{
2018-09-12 17:26:21 +00:00
DisposeDevicePublisher();
2016-10-29 22:22:20 +00:00
}
2018-09-12 17:26:21 +00:00
if (options.EnablePlayTo)
2016-10-29 22:22:20 +00:00
{
StartPlayToManager();
}
2018-09-12 17:26:21 +00:00
else
2016-10-29 22:22:20 +00:00
{
DisposePlayToManager();
}
}
private void StartSsdpHandler()
{
try
{
2016-11-14 19:48:01 +00:00
if (_communicationsServer == null)
{
var enableMultiSocketBinding = OperatingSystem.Id == OperatingSystemId.Windows ||
OperatingSystem.Id == OperatingSystemId.Linux;
2016-12-05 18:46:38 +00:00
_communicationsServer = new SsdpCommunicationsServer(_config, _socketFactory, _networkManager, _logger, enableMultiSocketBinding)
2016-11-14 19:48:01 +00:00
{
IsShared = true
};
2016-10-29 22:22:20 +00:00
2018-09-12 17:26:21 +00:00
StartDeviceDiscovery(_communicationsServer);
}
2016-10-29 22:22:20 +00:00
}
catch (Exception ex)
{
2018-12-20 12:11:26 +00:00
_logger.LogError(ex, "Error starting ssdp handlers");
2016-10-29 22:22:20 +00:00
}
}
private void LogMessage(string msg)
{
_logger.LogDebug(msg);
2016-10-29 22:22:20 +00:00
}
2016-11-14 19:48:01 +00:00
private void StartDeviceDiscovery(ISsdpCommunicationsServer communicationsServer)
2016-10-29 22:22:20 +00:00
{
try
{
2016-11-14 19:48:01 +00:00
((DeviceDiscovery)_deviceDiscovery).Start(communicationsServer);
2016-10-29 22:22:20 +00:00
}
catch (Exception ex)
{
2018-12-20 12:11:26 +00:00
_logger.LogError(ex, "Error starting device discovery");
2016-10-29 22:22:20 +00:00
}
}
private void DisposeDeviceDiscovery()
{
try
{
_logger.LogInformation("Disposing DeviceDiscovery");
2016-10-29 22:22:20 +00:00
((DeviceDiscovery)_deviceDiscovery).Dispose();
}
catch (Exception ex)
{
2018-12-20 12:11:26 +00:00
_logger.LogError(ex, "Error stopping device discovery");
2016-10-29 22:22:20 +00:00
}
}
2018-09-12 17:26:21 +00:00
public async Task StartDevicePublisher(Configuration.DlnaOptions options)
2016-10-29 22:22:20 +00:00
{
2018-09-12 17:26:21 +00:00
if (!options.BlastAliveMessages)
2016-10-29 22:22:20 +00:00
{
2018-09-12 17:26:21 +00:00
return;
2016-10-29 22:22:20 +00:00
}
2018-09-12 17:26:21 +00:00
if (_Publisher != null)
2016-10-29 22:22:20 +00:00
{
2018-09-12 17:26:21 +00:00
return;
2016-10-29 22:22:20 +00:00
}
try
{
_Publisher = new SsdpDevicePublisher(_communicationsServer, _networkManager, OperatingSystem.Name, Environment.OSVersion.VersionString, _config.GetDlnaConfiguration().SendOnlyMatchedHost);
2018-09-12 17:26:21 +00:00
_Publisher.LogFunction = LogMessage;
_Publisher.SupportPnpRootDevice = false;
2016-10-29 22:22:20 +00:00
await RegisterServerEndpoints().ConfigureAwait(false);
2018-09-12 17:26:21 +00:00
_Publisher.StartBroadcastingAliveMessages(TimeSpan.FromSeconds(options.BlastAliveMessageIntervalSeconds));
2016-10-29 22:22:20 +00:00
}
catch (Exception ex)
{
2018-12-20 12:11:26 +00:00
_logger.LogError(ex, "Error registering endpoint");
2016-10-29 22:22:20 +00:00
}
}
private async Task RegisterServerEndpoints()
{
var addresses = await _appHost.GetLocalIpAddresses(CancellationToken.None).ConfigureAwait(false);
2016-10-29 22:22:20 +00:00
2016-11-04 23:57:21 +00:00
var udn = CreateUuid(_appHost.SystemId);
2016-10-29 22:22:20 +00:00
foreach (var address in addresses)
{
if (address.AddressFamily == AddressFamily.InterNetworkV6)
{
2019-02-23 01:56:55 +00:00
// Not support IPv6 right now
continue;
}
2016-10-29 22:22:20 +00:00
var fullService = "urn:schemas-upnp-org:device:MediaServer:1";
2019-02-02 15:12:16 +00:00
_logger.LogInformation("Registering publisher for {0} on {1}", fullService, address);
2016-10-29 22:22:20 +00:00
var descriptorUri = "/dlna/" + udn + "/description.xml";
2016-11-08 18:44:23 +00:00
var uri = new Uri(_appHost.GetLocalApiUrl(address) + descriptorUri);
2016-10-29 22:22:20 +00:00
var device = new SsdpRootDevice
{
2018-09-12 17:26:21 +00:00
CacheLifetime = TimeSpan.FromSeconds(1800), //How long SSDP clients can cache this info.
2019-01-07 23:27:46 +00:00
Location = uri, // Must point to the URL that serves your devices UPnP description document.
Address = address,
SubnetMask = _networkManager.GetLocalIpSubnetMask(address),
2018-12-13 09:18:29 +00:00
FriendlyName = "Jellyfin",
Manufacturer = "Jellyfin",
2018-12-13 19:10:22 +00:00
ModelName = "Jellyfin Server",
2016-10-29 22:22:20 +00:00
Uuid = udn
2019-01-07 23:27:46 +00:00
// This must be a globally unique value that survives reboots etc. Get from storage or embedded hardware etc.
2016-10-29 22:22:20 +00:00
};
SetProperies(device, fullService);
_Publisher.AddDevice(device);
2019-01-13 19:16:19 +00:00
var embeddedDevices = new[]
2016-10-29 22:22:20 +00:00
{
"urn:schemas-upnp-org:service:ContentDirectory:1",
"urn:schemas-upnp-org:service:ConnectionManager:1",
2016-11-15 19:42:43 +00:00
//"urn:microsoft.com:service:X_MS_MediaReceiverRegistrar:1"
2016-10-29 22:22:20 +00:00
};
foreach (var subDevice in embeddedDevices)
{
var embeddedDevice = new SsdpEmbeddedDevice
{
FriendlyName = device.FriendlyName,
Manufacturer = device.Manufacturer,
ModelName = device.ModelName,
Uuid = udn
2019-01-07 23:27:46 +00:00
// This must be a globally unique value that survives reboots etc. Get from storage or embedded hardware etc.
2016-10-29 22:22:20 +00:00
};
SetProperies(embeddedDevice, subDevice);
device.AddDevice(embeddedDevice);
}
}
}
private string CreateUuid(string text)
{
if (!Guid.TryParse(text, out var guid))
2016-11-04 23:57:21 +00:00
{
guid = text.GetMD5();
}
return guid.ToString("N", CultureInfo.InvariantCulture);
2016-10-29 22:22:20 +00:00
}
private void SetProperies(SsdpDevice device, string fullDeviceType)
{
var service = fullDeviceType.Replace("urn:", string.Empty).Replace(":1", string.Empty);
var serviceParts = service.Split(':');
var deviceTypeNamespace = serviceParts[0].Replace('.', '-');
device.DeviceTypeNamespace = deviceTypeNamespace;
device.DeviceClass = serviceParts[1];
device.DeviceType = serviceParts[2];
}
private readonly object _syncLock = new object();
private void StartPlayToManager()
{
lock (_syncLock)
{
2018-09-12 17:26:21 +00:00
if (_manager != null)
{
return;
}
2016-10-29 22:22:20 +00:00
try
{
_manager = new PlayToManager(_logger,
_sessionManager,
_libraryManager,
_userManager,
_dlnaManager,
_appHost,
_imageProcessor,
_deviceDiscovery,
_httpClient,
_config,
_userDataManager,
_localization,
_mediaSourceManager,
2019-02-05 08:49:46 +00:00
_mediaEncoder);
2016-10-29 22:22:20 +00:00
_manager.Start();
}
catch (Exception ex)
{
2018-12-20 12:11:26 +00:00
_logger.LogError(ex, "Error starting PlayTo manager");
2016-10-29 22:22:20 +00:00
}
}
}
private void DisposePlayToManager()
{
lock (_syncLock)
{
if (_manager != null)
{
try
{
_logger.LogInformation("Disposing PlayToManager");
2016-10-29 22:22:20 +00:00
_manager.Dispose();
}
catch (Exception ex)
{
2018-12-20 12:11:26 +00:00
_logger.LogError(ex, "Error disposing PlayTo manager");
2016-10-29 22:22:20 +00:00
}
_manager = null;
}
}
}
public void Dispose()
{
2018-09-12 17:26:21 +00:00
DisposeDevicePublisher();
2016-10-29 22:22:20 +00:00
DisposePlayToManager();
2018-09-12 17:26:21 +00:00
DisposeDeviceDiscovery();
2016-11-14 19:48:01 +00:00
if (_communicationsServer != null)
{
_logger.LogInformation("Disposing SsdpCommunicationsServer");
2016-11-14 19:48:01 +00:00
_communicationsServer.Dispose();
_communicationsServer = null;
}
2018-09-12 17:26:21 +00:00
ContentDirectory = null;
ConnectionManager = null;
MediaReceiverRegistrar = null;
Current = null;
2016-10-29 22:22:20 +00:00
}
2018-09-12 17:26:21 +00:00
public void DisposeDevicePublisher()
2016-10-29 22:22:20 +00:00
{
if (_Publisher != null)
{
_logger.LogInformation("Disposing SsdpDevicePublisher");
2016-10-29 22:22:20 +00:00
_Publisher.Dispose();
2018-09-12 17:26:21 +00:00
_Publisher = null;
2016-10-29 22:22:20 +00:00
}
}
}
}