update for 1.0.0-beta14

.circleci/config.yml

@@ -9,11 +9,7 @@ jobs:
     docker:
       - image: microsoft/dotnet:2.0-sdk-jessie
     steps:
-      - run:
-          name: install packages
-          command: apt-get -q update && apt-get install -qy awscli
       - checkout
-      - run: aws s3 cp s3://launchdarkly-pastebin/ci/dotnet/LaunchDarkly.Xamarin.snk LaunchDarkly.Xamarin.snk
       - run: dotnet restore
       - run: dotnet build src/LaunchDarkly.Xamarin -f netstandard2.0
       - run: dotnet test tests/LaunchDarkly.Xamarin.Tests/LaunchDarkly.Xamarin.Tests.csproj -f netcoreapp2.0

CODEOWNERS

@@ -1 +1 @@
-* @ashanbrown
+

README.md

@@ -11,14 +11,15 @@ Quick setup
 
         Install-Package LaunchDarkly.Xamarin
 
-1. Import the LaunchDarkly package:
+1. Import the LaunchDarkly packages:
 
+        using LaunchDarkly.Client;
         using LaunchDarkly.Xamarin;
 
 2. Initialize the LDClient with your Mobile key and user:
 
         User user = User.WithKey(username);
-        LdClient ldClient = LdClient.Init("YOUR_MOBILE_KEY", username);
+        LdClient ldClient = LdClient.Init("YOUR_MOBILE_KEY", user);
 
 Your first feature flag
 -----------------------
@@ -49,26 +50,6 @@ Contributing
 
 See [Contributing](https://github.com/launchdarkly/xamarin-client/blob/master/CONTRIBUTING.md).
 
-Signing
--------
-The artifacts generated from this repo are signed by LaunchDarkly. The public key file is in this repo at `LaunchDarkly.Xamarin.pk` as well as here:
-
-```
-Public Key:
-00240000048000009400000006020000
-00240000525341310004000001000100
-058a1dbccbc342759dc98b1eaba4467b
-fdea062629f212cf7c669ff26b4e2ff3
-c408292487bc349b8a687d73033ff14d
-bf861e1eea23303a5b5d13b1db034799
-13bd120ba372cf961d27db9f65263156
-5f4e8aff4a79e11cfe713833157ecb5d
-cbc02d772967d919f8f06fbee227a664
-dc591932d5b05f4da1c8439702ecfdb1
-
-Public Key Token: 90b24964a3dfb906f86add69004e6885
-```
-
 About LaunchDarkly
 -----------
 

src/LaunchDarkly.Xamarin/Configuration.cs

@@ -2,6 +2,7 @@
 using System.Collections.Generic;
 using System.Net.Http;
 using Common.Logging;
+using LaunchDarkly.Client;
 
 namespace LaunchDarkly.Xamarin
 {
@@ -59,12 +60,6 @@ public class Configuration : IMobileConfiguration
         /// </summary>
         public TimeSpan PollingInterval { get; internal set; }
         /// <summary>
-        /// How long the client constructor will block awaiting a successful connection to
-        /// LaunchDarkly. Setting this to 0 will not block and will cause the constructor to return
-        /// immediately. The default value is 5 seconds.
-        /// </summary>
-        public TimeSpan StartWaitTime { get; internal set; }
-        /// <summary>
         /// The timeout when reading data from the EventSource API. The default value is 5 minutes.
         /// </summary>
         public TimeSpan ReadTimeout { get; internal set; }
@@ -125,15 +120,21 @@ public class Configuration : IMobileConfiguration
 
         internal IFlagCacheManager FlagCacheManager { get; set; }
         internal IConnectionManager ConnectionManager { get; set; }
+        internal IEventProcessor EventProcessor { get; set; }
         internal IMobileUpdateProcessor MobileUpdateProcessor { get; set; }
         internal ISimplePersistance Persister { get; set; }
         internal IDeviceInfo DeviceInfo { get; set; }
         internal IFeatureFlagListenerManager FeatureFlagListenerManager { get; set; }
+        internal IPlatformAdapter PlatformAdapter { get; set; }
 
         /// <summary>
         /// Default value for <see cref="PollingInterval"/>.
         /// </summary>
-        public static TimeSpan DefaultPollingInterval = TimeSpan.FromSeconds(30);
+        public static TimeSpan DefaultPollingInterval = TimeSpan.FromMinutes(5);
+        /// <summary>
+        /// Minimum value for <see cref="PollingInterval"/>.
+        /// </summary>
+        public static TimeSpan MinimumPollingInterval = TimeSpan.FromMinutes(5);
         /// <summary>
         /// Default value for <see cref="BaseUri"/>.
         /// </summary>
@@ -155,10 +156,6 @@ public class Configuration : IMobileConfiguration
         /// </summary>
         private static readonly TimeSpan DefaultEventQueueFrequency = TimeSpan.FromSeconds(5);
         /// <summary>
-        /// Default value for <see cref="StartWaitTime"/>.
-        /// </summary>
-        private static readonly TimeSpan DefaultStartWaitTime = TimeSpan.FromSeconds(5);
-        /// <summary>
         /// Default value for <see cref="ReadTimeout"/>.
         /// </summary>
         private static readonly TimeSpan DefaultReadTimeout = TimeSpan.FromMinutes(5);
@@ -181,7 +178,11 @@ public class Configuration : IMobileConfiguration
         /// <summary>
         /// The default value for <see cref="BackgroundPollingInterval"/>.
         /// </summary>
-        private static readonly TimeSpan DefaultBackgroundPollingInterval = TimeSpan.FromMinutes(3600);
+        private static readonly TimeSpan DefaultBackgroundPollingInterval = TimeSpan.FromMinutes(60);
+        /// <summary>
+        /// The minimum value for <see cref="BackgroundPollingInterval"/>.
+        /// </summary>
+        public static readonly TimeSpan MinimumBackgroundPollingInterval = TimeSpan.FromMinutes(15);
         /// <summary>
         /// The default value for <see cref="ConnectionTimeout"/>.
         /// </summary>
@@ -195,6 +196,10 @@ public class Configuration : IMobileConfiguration
         /// <returns>a <c>Configuration</c> instance</returns>
         public static Configuration Default(string mobileKey)
         {
+            if (String.IsNullOrEmpty(mobileKey))
+            {
+                throw new ArgumentOutOfRangeException("mobileKey", "key is required");
+            }
             var defaultConfiguration = new Configuration
             {
                 BaseUri = DefaultUri,
@@ -203,7 +208,6 @@ public static Configuration Default(string mobileKey)
                 EventQueueCapacity = DefaultEventQueueCapacity,
                 EventQueueFrequency = DefaultEventQueueFrequency,
                 PollingInterval = DefaultPollingInterval,
-                StartWaitTime = DefaultStartWaitTime,
                 ReadTimeout = DefaultReadTimeout,
                 ReconnectTime = DefaultReconnectTime,
                 HttpClientTimeout = DefaultHttpClientTimeout,
@@ -237,7 +241,7 @@ public static class ConfigurationExtensions
         /// <param name="configuration">the configuration</param>
         /// <param name="uri">the base URI as a string</param>
         /// <returns>the same <c>Configuration</c> instance</returns>
-        public static Configuration WithUri(this Configuration configuration, string uri)
+        public static Configuration WithBaseUri(this Configuration configuration, string uri)
         {
             if (uri != null)
                 configuration.BaseUri = new Uri(uri);
@@ -251,7 +255,7 @@ public static Configuration WithUri(this Configuration configuration, string uri
         /// <param name="configuration">the configuration</param>
         /// <param name="uri">the base URI</param>
         /// <returns>the same <c>Configuration</c> instance</returns>
-        public static Configuration WithUri(this Configuration configuration, Uri uri)
+        public static Configuration WithBaseUri(this Configuration configuration, Uri uri)
         {
             if (uri != null)
                 configuration.BaseUri = uri;
@@ -371,29 +375,15 @@ public static Configuration WithEventSamplingInterval(this Configuration configu
         /// <returns>the same <c>Configuration</c> instance</returns>
         public static Configuration WithPollingInterval(this Configuration configuration, TimeSpan pollingInterval)
         {
-            if (pollingInterval.CompareTo(Configuration.DefaultPollingInterval) < 0)
+            if (pollingInterval.CompareTo(Configuration.MinimumPollingInterval) < 0)
             {
-                Log.Warn("PollingInterval cannot be less than the default of 30 seconds.");
-                pollingInterval = Configuration.DefaultPollingInterval;
+                Log.WarnFormat("PollingInterval cannot be less than the default of {0}.");
+                pollingInterval = Configuration.MinimumPollingInterval;
             }
             configuration.PollingInterval = pollingInterval;
             return configuration;
         }
 
-        /// <summary>
-        /// Sets how long the client constructor will block awaiting a successful connection to
-        /// LaunchDarkly. Setting this to 0 will not block and will cause the constructor to return
-        /// immediately. The default value is 5 seconds.
-        /// </summary>
-        /// <param name="configuration">the configuration</param>
-        /// <param name="startWaitTime">the length of time to wait</param>
-        /// <returns>the same <c>Configuration</c> instance</returns>
-        public static Configuration WithStartWaitTime(this Configuration configuration, TimeSpan startWaitTime)
-        {
-            configuration.StartWaitTime = startWaitTime;
-            return configuration;
-        }
-
         /// <summary>
         /// Sets whether or not this client is offline. If true, no calls to Launchdarkly will be made.
         /// </summary>
@@ -567,6 +557,18 @@ public static Configuration WithConnectionManager(this Configuration configurati
             return configuration;
         }
 
+        /// <summary>
+        /// Sets the IEventProcessor instance, used internally for stubbing mock instances.
+        /// </summary>
+        /// <param name="configuration">Configuration.</param>
+        /// <param name="eventProcessor">Event processor.</param>
+        /// <returns>the same <c>Configuration</c> instance</returns>
+        public static Configuration WithEventProcessor(this Configuration configuration, IEventProcessor eventProcessor)
+        {
+            configuration.EventProcessor = eventProcessor;
+            return configuration;
+        }
+
         /// <summary>
         /// Determines whether to use the Report method for networking requests
         /// </summary>
@@ -659,8 +661,25 @@ public static Configuration WithEnableBackgroundUpdating(this Configuration conf
         /// <returns>the same <c>Configuration</c> instance</returns>
         public static Configuration WithBackgroundPollingInterval(this Configuration configuration, TimeSpan backgroundPollingInternal)
         {
+            if (backgroundPollingInternal.CompareTo(Configuration.MinimumBackgroundPollingInterval) < 0)
+            {
+                Log.WarnFormat("BackgroundPollingInterval cannot be less than the default of {0}.", Configuration.MinimumBackgroundPollingInterval);
+                backgroundPollingInternal = Configuration.MinimumBackgroundPollingInterval;
+            }
             configuration.BackgroundPollingInterval = backgroundPollingInternal;
             return configuration;
         }
+
+        /// <summary>
+        /// Specifies a component that provides special functionality for the current mobile platform.
+        /// </summary>
+        /// <param name="configuration">Configuration.</param>
+        /// <param name="adapter">An implementation of <see cref="IPlatformAdapter"/>.</param>
+        /// <returns>the same <c>Configuration</c> instance</returns>
+        public static Configuration WithPlatformAdapter(this Configuration configuration, IPlatformAdapter adapter)
+        {
+            configuration.PlatformAdapter = adapter;
+            return configuration;
+        }
     }
 }

src/LaunchDarkly.Xamarin/Factory.cs

@@ -14,27 +14,21 @@ internal static IFlagCacheManager CreateFlagCacheManager(Configuration configura
                                                                  IFlagListenerUpdater updater,
                                                                  User user)
         {
-            IFlagCacheManager flagCacheManager;
-
             if (configuration.FlagCacheManager != null)
             {
-                flagCacheManager = configuration.FlagCacheManager;
+                return configuration.FlagCacheManager;
             }
             else
             {
                 var inMemoryCache = new UserFlagInMemoryCache();
                 var deviceCache = new UserFlagDeviceCache(persister);
-                flagCacheManager = new FlagCacheManager(inMemoryCache, deviceCache, updater, user);
+                return new FlagCacheManager(inMemoryCache, deviceCache, updater, user);
             }
-
-            return flagCacheManager;
         }
 
         internal static IConnectionManager CreateConnectionManager(Configuration configuration)
         {
-            IConnectionManager connectionManager;
-            connectionManager = configuration.ConnectionManager ?? new MobileConnectionManager();
-            return connectionManager;
+            return configuration.ConnectionManager ?? new MobileConnectionManager();
         }
 
         internal static IMobileUpdateProcessor CreateUpdateProcessor(Configuration configuration,
@@ -47,36 +41,36 @@ internal static IMobileUpdateProcessor CreateUpdateProcessor(Configuration confi
                 return configuration.MobileUpdateProcessor;
             }
 
-            IMobileUpdateProcessor updateProcessor = null;
             if (configuration.Offline)
             {
-                Log.InfoFormat("Was configured to be offline, starting service with NullUpdateProcessor");
+                Log.InfoFormat("Starting LaunchDarkly client in offline mode");
                 return new NullUpdateProcessor();
             }
 
             if (configuration.IsStreamingEnabled)
             {
-                updateProcessor = new MobileStreamingProcessor(configuration,
+                return new MobileStreamingProcessor(configuration,
                                                                flagCacheManager,
                                                                user, source);
             }
             else
             {
                 var featureFlagRequestor = new FeatureFlagRequestor(configuration, user);
-                updateProcessor = new MobilePollingProcessor(featureFlagRequestor,
-                                                             flagCacheManager,
-                                                             user,
-                                                             configuration.PollingInterval);
+                return new MobilePollingProcessor(featureFlagRequestor,
+                                                  flagCacheManager,
+                                                  user,
+                                                  configuration.PollingInterval);
             }
-
-            return updateProcessor;
         }
 
-        internal static IEventProcessor CreateEventProcessor(IBaseConfiguration configuration)
+        internal static IEventProcessor CreateEventProcessor(Configuration configuration)
         {
+            if (configuration.EventProcessor != null)
+            {
+                return configuration.EventProcessor;
+            }
             if (configuration.Offline)
             {
-                Log.InfoFormat("Was configured to be offline, starting service with NullEventProcessor");
                 return new NullEventProcessor();
             }
 
@@ -86,32 +80,22 @@ internal static IEventProcessor CreateEventProcessor(IBaseConfiguration configur
 
         internal static ISimplePersistance CreatePersister(Configuration configuration)
         {
-            if (configuration.Persister != null)
-            {
-                return configuration.Persister;
-            }
-
-            return new SimpleMobileDevicePersistance();
+            return configuration.Persister ?? new SimpleMobileDevicePersistance();
         }
 
         internal static IDeviceInfo CreateDeviceInfo(Configuration configuration)
         {
-            if (configuration.DeviceInfo != null)
-            {
-                return configuration.DeviceInfo;
-            }
-
-            return new DeviceInfo();
+            return configuration.DeviceInfo ?? new DeviceInfo();
         }
 
         internal static IFeatureFlagListenerManager CreateFeatureFlagListenerManager(Configuration configuration)
         {
-            if (configuration.FeatureFlagListenerManager != null)
-            {
-                return configuration.FeatureFlagListenerManager;
-            }
+            return configuration.FeatureFlagListenerManager ?? new FeatureFlagListenerManager();
+        }
 
-            return new FeatureFlagListenerManager();
+        internal static IPlatformAdapter CreatePlatformAdapter(Configuration configuration)
+        {
+            return configuration.PlatformAdapter ?? new NullPlatformAdapter();
         }
     }
 }

src/LaunchDarkly.Xamarin/IBackgroundingState.cs

@@ -0,0 +1,33 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace LaunchDarkly.Xamarin
+{
+    /// <summary>
+    /// An interface that is used internally by implementations of <see cref="IBackgroundingManagerFactory"/>
+    /// to update the state of the LaunchDarkly client in background mode. Application code does not need
+    /// to interact with this interface.
+    /// </summary>
+    public interface IBackgroundingState
+    {
+        /// <summary>
+        /// Tells the LaunchDarkly client that the application is entering background mode. The client will
+        /// suspend the regular streaming or polling process, except when <see cref="BackgroundPollAsync"/>
+        /// is called.
+        /// </summary>
+        Task EnterBackgroundAsync();
+
+        /// <summary>
+        /// Tells the LaunchDarkly client that the application is exiting background mode. The client will
+        /// resume the regular streaming or polling process.
+        /// </summary>
+        Task ExitBackgroundAsync();
+
+        /// <summary>
+        /// Tells the LaunchDarkly client to initiate a request for feature flag updates while in background mode.
+        /// </summary>
+        Task BackgroundUpdateAsync();
+    }
+}