Esempio n. 1
0
        public override async Task OpenAsync(BuildStatusToken statusToken)
        {
            try
            {
                IsSyncing = true;

                IMqttServerOptions options = new MqttServerOptionsBuilder()
                                             .WithDefaultEndpointPort(Port)
                                             .WithApplicationMessageInterceptor(this)
                                             .Build();

                if (statusToken?.IsEnded.HasValue == true)
                {
                    return;
                }

                isOpen = true;
                await server.StartAsync(options);
            }
            catch
            {
                try
                {
                    await CloseAsync();
                }
                catch { }

                throw;
            }
            finally
            {
                IsSyncing = false;
            }
        }
        public override async Task SyncService(BuildStatusToken statusToken)
        {
            try
            {
                isSyncing           = true;
                connection.IsSynced = false;
                connection.Service  = Service;

                Task publishTask = Task.Run(() => SendMessagesHandler(connection));
                Task pingTask    = Task.Run(() => SendPingsHandler(connection));
                Task receiveTask = Task.Run(() => ReceiveHandler(connection));
                Task processTask = Task.Run(() => ProcessHandler(connection));

                await connection.SendCommand(SyncCmd, false, TimeSpan.FromSeconds(1000), statusToken.EndTask);

                connection.IsSynced = true;

                connection.Task = Task.WhenAll(publishTask, pingTask, receiveTask, processTask);
            }
            catch (Exception e)
            {
                try
                {
                    await connection.CloseAsync(e, true);
                }
                catch { }

                throw;
            }
            finally
            {
                isSyncing = false;
            }
        }
        public override async Task OpenAsync(BuildStatusToken statusToken)
        {
            if (IsOpen)
            {
                return;
            }

            try
            {
                IPAddress address;
                if (!IPAddress.TryParse(ServerAddress, out address))
                {
                    address = await GetIpAddress(ServerAddress);
                }

                TcpClient client = new TcpClient();
                await client.ConnectAsync(address, Port ?? -1);

                connection = new OwnTcpClientConnection(client);
                connection.Disconnected += Connection_Disconnected;
            }
            catch
            {
                if (connection != null)
                {
                    connection.Disconnected -= Connection_Disconnected;
                    connection.Client.Dispose();
                    connection = null;
                }
                throw;
            }
        }
Esempio n. 4
0
        public override Task SetService(IAudioServiceBase service, BuildStatusToken statusToken)
        {
            Unsubscribe(Service);
            Service = service;
            Subscribe(Service);

            return(SyncService(statusToken));
        }
Esempio n. 5
0
        public override async Task SyncService(BuildStatusToken statusToken)
        {
            try
            {
                connections  = new List <OwnTcpServerConnection>();
                processQueue = new AsyncQueue <OwnTcpSendMessage>();

                openTask = Task.WhenAll(ProcessHandler(processQueue), NewConnectionsHandler(processQueue));
            }
            catch (Exception e)
            {
                await CloseAsync(e, true);

                throw;
            }
        }
Esempio n. 6
0
        public override async Task SetService(IAudioServiceBase service, BuildStatusToken statusToken)
        {
            try
            {
                IsSyncing = true;

                Unsubscribe(Service);
                Service = service;
                InitPlaylists();

                await SyncService(statusToken, false);
            }
            finally
            {
                IsSyncing = false;
            }
        }
Esempio n. 7
0
        public override async Task OpenAsync(BuildStatusToken statusToken)
        {
            if (isOpen)
            {
                return;
            }

            try
            {
                isOpen = true;
                listener.Start();
            }
            catch
            {
                await CloseAsync();

                throw;
            }
        }
Esempio n. 8
0
        private async Task SyncService(BuildStatusToken statusToken, bool unsubscribe)
        {
            try
            {
                IsSyncing = true;

                if (unsubscribe)
                {
                    Unsubscribe(Service);
                }
                Subscribe(Service);

                if (statusToken?.IsEnded.HasValue == true)
                {
                    return;
                }
                await PublishCurrentPlaylist();

                if (statusToken?.IsEnded.HasValue == true)
                {
                    return;
                }
                await Task.WhenAll(Service.SourcePlaylists.Select(PublishPlaylist));

                if (statusToken?.IsEnded.HasValue == true)
                {
                    return;
                }
                await Task.WhenAll(Service.Playlists.Select(PublishPlaylist));

                if (statusToken?.IsEnded.HasValue == true)
                {
                    return;
                }
                await PublishPlaylists();

                if (statusToken?.IsEnded.HasValue == true)
                {
                    return;
                }
                await PublishPlayState();

                if (statusToken?.IsEnded.HasValue == true)
                {
                    return;
                }
                await PublishVolume();

                if (statusToken?.IsEnded.HasValue == true)
                {
                    return;
                }
                await PublishAudioData();

                if (statusToken?.IsEnded.HasValue == true)
                {
                    return;
                }
                await PublishIsSearchShuffle();

                if (statusToken?.IsEnded.HasValue == true)
                {
                    return;
                }
                await PublishSearchKey();

                if (statusToken?.IsEnded.HasValue == true)
                {
                    return;
                }
            }
            finally
            {
                IsSyncing = false;
            }
        }
Esempio n. 9
0
 public override async Task SyncService(BuildStatusToken statusToken)
 {
     await SyncService(statusToken, true);
 }