Merge pull request #773 from michaelstonis/master

Adds support for FragmentActivity

ReactiveUI.AndroidSupport/ReactiveFragmentActivity.cs

@@ -0,0 +1,170 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using Android.App;
+using Android.Content;
+using Android.OS;
+using Android.Runtime;
+using Android.Views;
+using Android.Widget;
+using System.Runtime.Serialization;
+using System.ComponentModel;
+using System.Reflection;
+using System.Reactive.Linq;
+using System.Reactive.Subjects;
+using System.Reactive.Concurrency;
+using System.Reactive.Threading.Tasks;
+using System.Threading;
+using System.Threading.Tasks;
+using System.Reactive.Disposables;
+using System.Diagnostics.Contracts;
+using System.Runtime.CompilerServices;
+using Splat;
+using System.Reactive;
+using Android.Support.V4.App;
+
+namespace ReactiveUI
+{
+    /// <summary>
+    /// This is an Activity that is both an Activity and has ReactiveObject powers 
+    /// (i.e. you can call RaiseAndSetIfChanged)
+    /// </summary>
+    public class ReactiveFragmentActivity<TViewModel> : ReactiveFragmentActivity, IViewFor<TViewModel>, ICanActivate
+        where TViewModel : class
+    {
+        protected ReactiveFragmentActivity() { }
+
+        TViewModel _ViewModel;
+        public TViewModel ViewModel
+        {
+            get { return _ViewModel; }
+            set { this.RaiseAndSetIfChanged(ref _ViewModel, value); }
+        }
+
+        object IViewFor.ViewModel
+        {
+            get { return _ViewModel; }
+            set { _ViewModel = (TViewModel)value; }
+        }
+    }
+
+    /// <summary>
+    /// This is an Activity that is both an Activity and has ReactiveObject powers 
+    /// (i.e. you can call RaiseAndSetIfChanged)
+    /// </summary>
+    public class ReactiveFragmentActivity : FragmentActivity, IReactiveObject, IReactiveNotifyPropertyChanged<ReactiveFragmentActivity>, IHandleObservableErrors
+    {
+        public event PropertyChangingEventHandler PropertyChanging
+        {
+            add { PropertyChangingEventManager.AddHandler(this, value); }
+            remove { PropertyChangingEventManager.RemoveHandler(this, value); }
+        }
+
+        void IReactiveObject.RaisePropertyChanging(PropertyChangingEventArgs args)
+        {
+            PropertyChangingEventManager.DeliverEvent(this, args);
+        }
+
+        public event PropertyChangedEventHandler PropertyChanged
+        {
+            add { PropertyChangedEventManager.AddHandler(this, value); }
+            remove { PropertyChangedEventManager.RemoveHandler(this, value); }
+        }
+
+        void IReactiveObject.RaisePropertyChanged(PropertyChangedEventArgs args)
+        {
+            PropertyChangedEventManager.DeliverEvent(this, args);
+        }
+
+        /// <summary>
+        /// Represents an Observable that fires *before* a property is about to
+        /// be changed.         
+        /// </summary>
+        public IObservable<IReactivePropertyChangedEventArgs<ReactiveFragmentActivity>> Changing
+        {
+            get { return this.getChangingObservable(); }
+        }
+
+        /// <summary>
+        /// Represents an Observable that fires *after* a property has changed.
+        /// </summary>
+        public IObservable<IReactivePropertyChangedEventArgs<ReactiveFragmentActivity>> Changed
+        {
+            get { return this.getChangedObservable(); }
+        }
+
+        /// <summary>
+        /// When this method is called, an object will not fire change
+        /// notifications (neither traditional nor Observable notifications)
+        /// until the return value is disposed.
+        /// </summary>
+        /// <returns>An object that, when disposed, reenables change
+        /// notifications.</returns>
+        public IDisposable SuppressChangeNotifications()
+        {
+            return this.suppressChangeNotifications();
+        }
+
+        public IObservable<Exception> ThrownExceptions { get { return this.getThrownExceptionsObservable(); } }
+
+        readonly Subject<Unit> activated = new Subject<Unit>();
+        public IObservable<Unit> Activated { get { return activated; } }
+
+        readonly Subject<Unit> deactivated = new Subject<Unit>();
+        public IObservable<Unit> Deactivated { get { return deactivated; } }
+
+        protected override void OnPause()
+        {
+            base.OnPause();
+            deactivated.OnNext(Unit.Default);
+        }
+
+        protected override void OnResume()
+        {
+            base.OnResume();
+            activated.OnNext(Unit.Default);
+        }
+
+        readonly Subject<Tuple<int, Result, Intent>> activityResult = new Subject<Tuple<int, Result, Intent>>();
+        public IObservable<Tuple<int, Result, Intent>> ActivityResult
+        {
+            get { return activityResult; }
+        }
+
+        protected override void OnActivityResult(int requestCode, Result resultCode, Intent data)
+        {
+            base.OnActivityResult(requestCode, resultCode, data);
+            activityResult.OnNext(Tuple.Create(requestCode, resultCode, data));
+        }
+
+        public Task<Tuple<Result, Intent>> StartActivityForResultAsync(Intent intent, int requestCode)
+        {
+            // NB: It's important that we set up the subscription *before* we
+            // call ActivityForResult
+            var ret = ActivityResult
+                .Where(x => x.Item1 == requestCode)
+                .Select(x => Tuple.Create(x.Item2, x.Item3))
+                .FirstAsync()
+                .ToTask();
+
+            StartActivityForResult(intent, requestCode);
+            return ret;
+        }
+
+        public Task<Tuple<Result, Intent>> StartActivityForResultAsync(Type type, int requestCode)
+        {
+            // NB: It's important that we set up the subscription *before* we
+            // call ActivityForResult
+            var ret = ActivityResult
+                .Where(x => x.Item1 == requestCode)
+                .Select(x => Tuple.Create(x.Item2, x.Item3))
+                .FirstAsync()
+                .ToTask();
+
+            StartActivityForResult(type, requestCode);
+            return ret;
+        }
+    }
+}
+

ReactiveUI.AndroidSupport/ReactiveUI.AndroidSupport.csproj

@@ -71,6 +71,7 @@
     <Compile Include="..\CommonAssemblyInfo.cs">
       <Link>Properties\CommonAssemblyInfo.cs</Link>
     </Compile>
+    <Compile Include="ReactiveFragmentActivity.cs" />
     <Compile Include="ReactivePagerAdapter.cs" />
     <Compile Include="ReactiveFragment.cs" />
   </ItemGroup>
@@ -92,4 +93,4 @@
       <Name>ReactiveUI_Android</Name>
     </ProjectReference>
   </ItemGroup>
-</Project>
+</Project>