public override void OnCreated()
{
Log = LogManager.GetLogger(string.Format("ChatClient<NetId:{0}>", Channel.Id));
SetHandler <IChatLogin>(this);
DisconnectedEvent.Subscribe(OnDisconnectAsync);
Log.Info("connected");
}
/// <summary>
/// Create a rx mqtt client based on a <see cref="IManagedMqttClient"/>.
/// </summary>
/// <param name="managedMqttClient">The manged mqtt client.</param>
/// <param name="logger">The mqtt net logger.</param>
/// <remarks>
/// Use the <see cref="MqttFactoryExtensions.CreateRxMqttClient(IMqttFactory)"/> or
/// <see cref="MqttFactoryExtensions.CreateRxMqttClient(IMqttFactory, IMqttNetLogger)"/>
/// factory methods to crate the client.
/// </remarks>
/// <exception cref="ArgumentNullException"></exception>
public RxMqttClient(IManagedMqttClient managedMqttClient, IMqttNetLogger logger)
{
InternalClient = managedMqttClient ?? throw new ArgumentNullException(nameof(managedMqttClient));
if (logger == null)
{
throw new ArgumentNullException(nameof(logger));
}
this.logger = logger.WithSource(nameof(RxMqttClient));
topicSubscriptionCache = new Dictionary <string, IObservable <MqttApplicationMessageReceivedEventArgs> >();
var cancelationSubject = new Subject <Unit>();
ConnectedEvent = CrateFromHandler <MqttClientConnectedEventArgs>(observer =>
{
managedMqttClient.UseConnectedHandler(args => observer.OnNext(args));
return(Disposable.Create(() => managedMqttClient.ConnectedHandler = null));
});
DisconnectedEvent = CrateFromHandler <MqttClientDisconnectedEventArgs>(observer =>
{
managedMqttClient.UseDisconnectedHandler(args => observer.OnNext(args));
return(Disposable.Create(() => managedMqttClient.DisconnectedHandler = null));
});
ConnectingFailedEvent = CrateFromHandler <ManagedProcessFailedEventArgs>(observer =>
{
managedMqttClient.ConnectingFailedHandler = new ConnectingFailedHandlerDelegate(args => observer.OnNext(args));
return(Disposable.Create(() => managedMqttClient.ConnectingFailedHandler = null));
});
SynchronizingSubscriptionsFailedEvent = CrateFromHandler <ManagedProcessFailedEventArgs>(observer =>
{
managedMqttClient.SynchronizingSubscriptionsFailedHandler = new SynchronizingSubscriptionsFailedHandlerDelegate(args => observer.OnNext(args));
return(Disposable.Create(() => managedMqttClient.SynchronizingSubscriptionsFailedHandler = null));
});
ApplicationMessageProcessedEvent = CrateFromHandler <ApplicationMessageProcessedEventArgs>(observer =>
{
managedMqttClient.ApplicationMessageProcessedHandler = new ApplicationMessageProcessedHandlerDelegate(args => observer.OnNext(args));
return(Disposable.Create(() => managedMqttClient.ApplicationMessageReceivedHandler = null));
});
ApplicationMessageSkippedEvent = CrateFromHandler <ApplicationMessageSkippedEventArgs>(observer =>
{
managedMqttClient.ApplicationMessageSkippedHandler = new ApplicationMessageSkippedHandlerDelegate(args => observer.OnNext(args));
return(Disposable.Create(() => managedMqttClient.ApplicationMessageReceivedHandler = null));
});
Connected = Observable
.Create <bool>(observer =>
{
var connected = ConnectedEvent.Subscribe(_ => observer.OnNext(true));
var disconnected = DisconnectedEvent.Subscribe(_ => observer.OnNext(false));
return(new CompositeDisposable(connected, disconnected));
})
.TakeUntil(cancelationSubject) // complete on dispose
.Prepend(IsConnected) // start with current state
.Append(false) // finish with false
.Replay(1) // replay last state on subscribe
.RefCount(); // count subscriptions and dispose source observable when no subscription
applicationMessageReceived = CrateFromHandler <MqttApplicationMessageReceivedEventArgs>(observer =>
{
managedMqttClient.UseApplicationMessageReceivedHandler(args => observer.OnNext(args));
return(Disposable.Create(() => managedMqttClient.ApplicationMessageReceivedHandler = null));
});
IObservable <T> CrateFromHandler <T>(Func <IObserver <T>, IDisposable> func)
{
return(Observable.Create(func)
.TakeUntil(cancelationSubject) // complete on dispose
.Publish() // publish from on source observable
.RefCount()); // count subscriptions and dispose source observable when no subscription
}
cleanUp = Disposable.Create(() =>
{
cancelationSubject.OnNext(Unit.Default); // complete all observers
cancelationSubject.Dispose();
try { managedMqttClient.Dispose(); }
catch { }
});
}
