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))); }