static IDisposable handleViewModelActivation(IViewFor view, IObservable <bool> activation)
{
var vmDisposable = new SerialDisposable();
var viewVmDisposable = new SerialDisposable();
return(new CompositeDisposable(
// Activation
activation.Subscribe(activated => {
if (activated)
{
viewVmDisposable.Disposable = view.WhenAnyValue(x => x.ViewModel)
.Select(x => x as ISupportsActivation)
.Subscribe(x =>
{
// NB: We need to make sure to respect ordering so that the cleanup
// happens before we activate again
vmDisposable.Disposable = Disposable.Empty;
if (x != null)
{
vmDisposable.Disposable = x.Activator.Activate();
}
});
}
else
{
viewVmDisposable.Disposable = Disposable.Empty;
vmDisposable.Disposable = Disposable.Empty;
}
}),
vmDisposable,
viewVmDisposable));
}
public static IDisposable WhenViewModelAnyValue(this IViewFor view, Action <CompositeDisposable> block)
{
return(view.WhenActivated(disposable =>
{
view.WhenAnyValue(x => x.ViewModel).Where(x => x != null).Subscribe(_ => block.Invoke(disposable)).DisposeWith(disposable);
}));
}
private static IDisposable HandleViewModelOnViewLoaded(IViewFor view, IObservable <bool> viewEvents)
{
var vmDisposable = new SerialDisposable();
var viewVmDisposable = new SerialDisposable();
return(new CompositeDisposable(
viewEvents.Subscribe(loaded =>
{
if (loaded)
{
_logger.LogInformation($"Binding {view.ViewModel?.GetType().ToString() ?? "null"} and {view}");
viewVmDisposable.Disposable = view.WhenAnyValue(x => x.ViewModel)
.Select(x => x as IViewAware)
.Subscribe(x =>
{
// NB: We need to make sure to respect ordering so that the cleanup happens before we execute ViewLoaded again
vmDisposable.Disposable = Disposable.Empty;
if (x != null)
{
vmDisposable.Disposable = x.View.ViewLoaded();
}
});
}
else
{
viewVmDisposable.Disposable = Disposable.Empty;
vmDisposable.Disposable = Disposable.Empty;
}
}),
vmDisposable,
viewVmDisposable));
}
private static IDisposable HandleViewOnActivatedAndLoaded(IViewFor view, Func <IEnumerable <IDisposable> > block, IObservable <bool> viewEvents)
{
var viewVmDisposable = new SerialDisposable();
var viewDisposable = new SerialDisposable();
var vmDisposable = new SerialDisposable();
return(new CompositeDisposable(
viewEvents.Subscribe(loaded =>
{
if (loaded)
{
viewVmDisposable.Disposable = view.WhenAnyValue(x => x.ViewModel)
.Select(x => x as IActivate)
.Subscribe(activatable =>
{
if (activatable != null)
{
vmDisposable.Disposable = activatable.WhenAnyValue(x => x.IsActive).Subscribe(isActive =>
{
// NB: We need to make sure to respect ordering so that the cleanup happens before we invoke block again
viewDisposable.Disposable = Disposable.Empty;
if (isActive)
{
viewDisposable.Disposable = new CompositeDisposable(block());
}
});
}
else
{
vmDisposable.Disposable = Disposable.Empty;
viewDisposable.Disposable = Disposable.Empty;
}
});
}
else
{
viewVmDisposable.Disposable = Disposable.Empty;
vmDisposable.Disposable = Disposable.Empty;
viewDisposable.Disposable = Disposable.Empty;
}
}),
viewDisposable,
vmDisposable,
viewVmDisposable));
}
/// <summary>
/// Executes <paramref name="block"/> when ViewModel is activated
/// </summary>
/// <remarks>ViewModel shouldn't outlive the <paramref name="view"/>, because this method subscribes to ViewModel change.
/// We need that subscription because of ListView cells reuse
/// </remarks>
public static IDisposable WhenViewModelActivated <T>(this IViewFor <T> view, Action <CompositeDisposable> block)
where T : class, IHaveActivator, IReactiveObject
{
IDisposable activated = null;
var vmChange = view.WhenAnyValue(v => v.ViewModel)
// ViewModel can be changed for ListView cells because of their reuse
.DistinctUntilChanged()
.Subscribe(vm =>
{
activated?.Dispose();
activated = vm?.Activator.WhenActivated(block);
});
return(Disposable.Create(() =>
{
activated?.Dispose();
vmChange.Dispose();
}));
}
static IDisposable handleViewModelActivation(IViewFor view,
Tuple <IObservable <Unit>, IObservable <Unit> > activation)
{
var vm = view.ViewModel as ISupportsActivation;
var disp = new SerialDisposable()
{
Disposable = (vm != null ? vm.Activator.Activate() : Disposable.Empty)
};
var latestVm = Observable.Merge(
activation.Item1.Select(_ => view.WhenAnyValue(x => x.ViewModel)),
activation.Item2.Select(_ => Observable.Never <object>().StartWith(default(object))))
.Switch()
.Select(x => x as ISupportsActivation);
return(new CompositeDisposable(
disp,
latestVm.Subscribe(x => disp.Disposable =
(x != null ? x.Activator.Activate() : Disposable.Empty))));
}
static IDisposable handleViewModelActivation(IViewFor view, IObservable<bool> activation)
{
var vmDisposable = new SerialDisposable();
var viewVmDisposable = new SerialDisposable();
return new CompositeDisposable(
// Activation
activation.Subscribe(activated => {
if (activated) {
viewVmDisposable.Disposable = view.WhenAnyValue(x => x.ViewModel)
.Select(x => x as ISupportsActivation)
.Subscribe(x =>
{
// NB: We need to make sure to respect ordering so that the cleanup
// happens before we activate again
vmDisposable.Disposable = Disposable.Empty;
if (x != null) {
vmDisposable.Disposable = x.Activator.Activate();
}
});
} else {
viewVmDisposable.Disposable = Disposable.Empty;
vmDisposable.Disposable = Disposable.Empty;
}
}),
vmDisposable,
viewVmDisposable);
}
public static IObservable <TRet> WhenViewModel <TViewModel, TRet>(this IViewFor <TViewModel> @this,
System.Linq.Expressions.Expression <Func <TViewModel, TRet> > @select) where TViewModel : class
{
return(@this.WhenAnyValue(x => x.ViewModel).Where(x => x != null).Select(x => x.WhenAnyValue(@select)).Switch());
}
static IDisposable handleViewModelActivation(IViewFor view, Tuple<IObservable<Unit>, IObservable<Unit>> activation)
{
var vmDisposable = new SerialDisposable();
return new CompositeDisposable(
// Activation
activation.Item1
.Select(_ => view.WhenAnyValue(x => x.ViewModel))
.Switch()
.Select(x => x as ISupportsActivation)
.Subscribe(x => {
// NB: We need to make sure to respect ordering so that the cleanup
// happens before we activate again
vmDisposable.Disposable = Disposable.Empty;
if(x != null) {
vmDisposable.Disposable = x.Activator.Activate();
}
}),
// Deactivation
activation.Item2.Subscribe(_ => {
vmDisposable.Disposable = Disposable.Empty;
}),
vmDisposable);
}
static IDisposable handleViewModelActivation(IViewFor view,
Tuple<IObservable<Unit>, IObservable<Unit>> activation)
{
var vm = view.ViewModel as ISupportsActivation;
var disp = new SerialDisposable() {Disposable = (vm != null ? vm.Activator.Activate() : Disposable.Empty)};
var latestVm = Observable.Merge(
activation.Item1.Select(_ => view.WhenAnyValue(x => x.ViewModel)),
activation.Item2.Select(_ => Observable.Never<object>().StartWith(default(object))))
.Switch()
.Select(x => x as ISupportsActivation);
return new CompositeDisposable(
disp,
latestVm.Subscribe(x => disp.Disposable =
(x != null ? x.Activator.Activate() : Disposable.Empty)));
}