Feature - Initialization Sync, Async (#167)

* Features:
Created two new APIs to simplify the initialization process for mobile:
- initializeAsync
- initializeSync

Also Added three unit tests in OptimizelyManager:
-InitializeAsync
-InitializeSync
-InitializeSyncWithEmptyDataFile

* Changes made to catch null pointer exception if given R.raw path of data file is null
added assertnull for optimizelyStartListener in initializeAsync test that on completion it should be null

* Added Empty datafile to pass unit test of check sync with empty datafile

* Changes made to download file on initializing optimizely manager

* - Renamed functions of inititalize sync and async
- Refactored code to look more like ios Initialize methods (Except reading files in SDK instead of asking user to do that)

* Removed unused functions and test cases
Added comments
did code refactoring

* Removed initialize just from cache method.

* - Changes made for asynchronus  initialize to take downloaded file first than cache file
- Added new test cases for empty datafile
- refactored code to get datafile from cache if not available than from Raw data file

* Commented unused loaddatafile variable

* Removed unused function of loaddatafilefromcachetask

* 1) Added boolean variable in initialized method to check if update using download should take place after initialization
2)updated comment in datafileloader.java
3) updated testcases
4) handled if datafile is null

* 1) Added boolean variable in initialized method to check if update using download should take place after initialization (#11)

2)updated comment in datafileloader.java
3) updated testcases
4) handled if datafile is null

* Updated Init test cases and resolved datafile issue of not found resource id

* Bug fix of esspresso test of test app not running

* Updated test cases and resolved bug of Raw id not found on release (#14)

* Updated Init test cases and resolved datafile issue of not found resource id

* Bug fix of esspresso test of test app not running

* Updated comments and Allowed null resource ID in Initialize(Context,Integer,OptimizelyStartListener)

Author: mnoman09

android-sdk/src/androidTest/java/com/optimizely/ab/android/sdk/OptimizelyManagerTest.java

@@ -48,6 +48,7 @@
 import java.util.concurrent.TimeUnit;
 
 import static junit.framework.Assert.assertEquals;
+import static junit.framework.Assert.assertFalse;
 import static junit.framework.Assert.assertNotNull;
 import static junit.framework.Assert.assertNull;
 import static junit.framework.Assert.assertTrue;
@@ -93,23 +94,6 @@ public void setup() {
                 eventHandler, null);
     }
 
-    @SuppressWarnings("WrongConstant")
-    @Test
-    public void initialize() {
-        OptimizelyStartListener startListener = mock(OptimizelyStartListener.class);
-        Context context = mock(Context.class);
-        Context appContext = mock(Context.class);
-        when(context.getApplicationContext()).thenReturn(appContext);
-        when(appContext.getPackageName()).thenReturn("com.optly");
-        ArgumentCaptor<Intent> captor = ArgumentCaptor.forClass(Intent.class);
-
-        optimizelyManager.initialize(appContext, startListener);
-
-        assertNotNull(optimizelyManager.getOptimizelyStartListener());
-        assertNotNull(optimizelyManager.getDatafileHandler());
-
-    }
-
     @Test
     public void initializeIntUseForcedVariation() {
         optimizelyManager.initialize(InstrumentationRegistry.getTargetContext(), R.raw.datafile);
@@ -132,6 +116,79 @@ public void initializeInt() {
         assertNotNull(optimizelyManager.getOptimizely());
         assertNotNull(optimizelyManager.getDatafileHandler());
 
+    }
+    @Test
+    public void initializeSync() {
+        /*
+         * Scenario#1: when datafile is not Empty
+         * Scenario#2: when datafile is Empty
+        */
+        optimizelyManager.initialize(InstrumentationRegistry.getTargetContext(), R.raw.datafile);
+
+        assertEquals(optimizelyManager.isDatafileCached(InstrumentationRegistry.getTargetContext()), false);
+
+        assertEquals(OptimizelyManager.getDatafileUrl("1"), "https://cdn.optimizely.com/public/1/datafile_v3.json" );
+
+        assertNotNull(optimizelyManager.getOptimizely());
+        assertNotNull(optimizelyManager.getDatafileHandler());
+
+        optimizelyManager.initialize(InstrumentationRegistry.getTargetContext(),(Integer) null);
+        verify(logger).error(eq("Invalid datafile resource ID."));
+    }
+    @Test
+    public void initializeSyncWithEmptyDatafile() {
+        //for this case to pass empty the data file or enter any garbage data given on R.raw.emptydatafile this path
+        Context context = mock(Context.class);
+        Context appContext = mock(Context.class);
+        when(context.getApplicationContext()).thenReturn(appContext);
+        when(appContext.getPackageName()).thenReturn("com.optly");
+        optimizelyManager.initialize(InstrumentationRegistry.getTargetContext(), R.raw.emptydatafile);
+        verify(logger).error(eq("Unable to parse compiled data file"), any(ConfigParseException.class));
+        assertFalse(optimizelyManager.getOptimizely().isValid());
+    }
+    @Test
+    public void getEmptyDatafile() {
+        //for this case to pass empty the data file or enter any garbage data given on R.raw.emptydatafile this path
+        Context context = mock(Context.class);
+        Context appContext = mock(Context.class);
+        when(context.getApplicationContext()).thenReturn(appContext);
+        when(appContext.getPackageName()).thenReturn("com.optly");
+
+        String datafile= optimizelyManager.getDatafile(InstrumentationRegistry.getTargetContext(), R.raw.emptydatafile);
+        assertNotNull(datafile,"");
+    }
+    @Test
+    public void getDatafile() {
+        /*
+         * Scenario#1: when datafile is Cached
+         *  Scenario#2: when datafile is not cached and raw datafile is not empty
+        */
+        assertEquals(optimizelyManager.isDatafileCached(InstrumentationRegistry.getTargetContext()), false);
+        String datafile =  optimizelyManager.getDatafile(InstrumentationRegistry.getTargetContext(), R.raw.datafile);
+        assertEquals(OptimizelyManager.getDatafileUrl("1"), "https://cdn.optimizely.com/public/1/datafile_v3.json" );
+        assertNotNull(datafile);
+        assertNotNull(optimizelyManager.getDatafileHandler());
+    }
+    @Test
+    public void initializeAsync() {
+        /*
+         * Scenario#1: when datafile is not Empty
+         * Scenario#2: when datafile is Empty
+        */
+        optimizelyManager.initialize(InstrumentationRegistry.getContext(), R.raw.datafile, new OptimizelyStartListener() {
+            @Override
+            public void onStart(OptimizelyClient optimizely) {
+                assertNotNull(optimizelyManager.getOptimizely());
+                assertNotNull(optimizelyManager.getDatafileHandler());
+                assertNull(optimizelyManager.getOptimizelyStartListener());
+            }
+        });
+
+        assertEquals(optimizelyManager.isDatafileCached(InstrumentationRegistry.getTargetContext()), false);
+
+        assertEquals(OptimizelyManager.getDatafileUrl("1"), "https://cdn.optimizely.com/public/1/datafile_v3.json" );
+
+
     }
     @Test
     public void initializeWithEmptyDatafile() {
@@ -169,7 +226,7 @@ public void initializeWithNullDatafile() {
         String emptyString = null;
 
         optimizelyManager.initialize(context, emptyString);
-        verify(logger).error(eq("Unable to parse compiled data file"), any(ConfigParseException.class));
+        verify(logger).error(eq("Invalid datafile"));
     }
 
     @Test
@@ -182,7 +239,7 @@ public void load() {
         String emptyString = null;
 
         optimizelyManager.initialize(context, emptyString);
-        verify(logger).error(eq("Unable to parse compiled data file"), any(ConfigParseException.class));
+        verify(logger).error(eq("Invalid datafile"));
     }
 
     @Test

android-sdk/src/debug/res/raw/emptydatafile

@@ -16,7 +16,7 @@
 
 package com.optimizely.ab.android.sdk;
 
-import android.app.Activity;
+import android.content.Context;
 import android.support.annotation.NonNull;
 import android.support.annotation.Nullable;
 
@@ -29,15 +29,14 @@
 
 import org.slf4j.Logger;
 
-import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
 
 /**
  * Wraps {@link Optimizely} instances
  *
  * This proxy ensures that the Android SDK will not crash if the inner Optimizely SDK
- * failed to start.  When Optimizely fails to start via {@link OptimizelyManager#initialize(Activity, OptimizelyStartListener)}
+ * failed to start.  When Optimizely fails to start via {@link OptimizelyManager#initialize(Context,Integer, OptimizelyStartListener)}
  * there will be no cached instance returned from {@link OptimizelyManager#getOptimizely()}.  By accessing
  * Optimizely through this interface checking for null is not required.  If Optimizely is null warnings
  * will be logged.

android-sdk/src/main/java/com/optimizely/ab/android/sdk/OptimizelyClient.java

@@ -132,73 +132,97 @@ private void notifyStartListener() {
      * @return an {@link OptimizelyClient} instance
      */
     public OptimizelyClient initialize(@NonNull Context context, @NonNull String datafile) {
+        initialize(context, datafile,true);
+        return optimizelyClient;
+    }
+
+    /**
+     * Initialize Optimizely Synchronously using the datafile passed in while downloading the latest datafile in the background from the CDN to cache.
+     * It should be noted that even though it initiates a download of the datafile to cache, this method does not use that cached datafile.
+     * You can always test if a datafile exists in cache with {@link #isDatafileCached(Context)}.
+     * <p>
+     * Instantiates and returns an {@link OptimizelyClient} instance. It will also cache the instance
+     * for future lookups via getClient
+     *
+     * @param context  any {@link Context} instance
+     * @param datafile the datafile used to initialize the OptimizelyClient.
+     * @param downloadToCache to check if datafile should get updated in cache after initialization.
+     * @return an {@link OptimizelyClient} instance
+     */
+    protected OptimizelyClient initialize(@NonNull Context context,@Nullable String datafile,boolean downloadToCache) {
         if (!isAndroidVersionSupported()) {
             return optimizelyClient;
         }
-
         try {
-            optimizelyClient = buildOptimizely(context, datafile);
+            if(datafile!=null)
+                optimizelyClient = buildOptimizely(context, datafile);
+            else
+                logger.error("Invalid datafile");
         } catch (ConfigParseException e) {
             logger.error("Unable to parse compiled data file", e);
         } catch (Exception e) {
             logger.error("Unable to build OptimizelyClient instance", e);
         } catch (Error e) {
             logger.error("Unable to build OptimizelyClient instance", e);
         }
-
-        datafileHandler.downloadDatafile(context, projectId, null);
+        if(downloadToCache){
+            datafileHandler.downloadDatafile(context, projectId, null);
+        }
 
         return optimizelyClient;
     }
 
     /**
      * Initialize Optimizely Synchronously by loading the resource, use it to initialize Optimizely,
      * and downloading the latest datafile from the CDN in the background to cache.
-     * It should be noted that even though it initiates a download of the datafile to cache, this method does not use that cached datafile.
-     * You can always test if a datafile exists in cache with {@link #isDatafileCached(Context)}.
      * <p>
-     * Instantiates and returns an {@link OptimizelyClient} instance. Will also cache the instance
+     * Instantiates and returns an {@link OptimizelyClient}  instance using the datafile cached on disk
+     * if not available then it will expect that raw data file should exist on given id.
+     * and initialize using raw file. Will also cache the instance
      * for future lookups via getClient. The datafile should be stored in res/raw.
      *
      * @param context     any {@link Context} instance
      * @param datafileRes the R id that the data file is located under.
      * @return an {@link OptimizelyClient} instance
      */
     @NonNull
-    public OptimizelyClient initialize(@NonNull Context context, @RawRes int datafileRes) {
+    public OptimizelyClient initialize(@NonNull Context context, @RawRes Integer datafileRes) {
         try {
-            String datafile = loadRawResource(context, datafileRes);
-            return initialize(context, datafile);
-        } catch (IOException e) {
-            logger.error("Unable to load compiled data file", e);
+
+            String datafile;
+            datafile = getDatafile(context, datafileRes);
+            optimizelyClient = initialize(context, datafile, true);
+        }catch (NullPointerException e){
+            logger.error("Unable to find compiled data file in raw resource",e);
         }
 
         // return dummy client if not able to initialize a valid one
         return optimizelyClient;
     }
 
-    /**
-     * Initialize Optimizely Synchronously. This one uses the cached datafile and expects it to exist.
-     * You can use {@link #isDatafileCached(Context)} to see if the datafile exists in cache prior to this call.
-     * <p>
-     * Instantiates and returns an {@link OptimizelyClient} instance using the datafile cached on disk
-     * if not available then it will return a dummy instance.
-     *
-     * @param context any {@link Context} instance
-     * @return an {@link OptimizelyClient} instance
+    /** This function will first try to get datafile from Cache, if file is not cached yet
+     * than it will read from Raw file
+     * @param context
+     * @param datafileRes
+     * @return datafile
      */
-    public OptimizelyClient initialize(@NonNull Context context) {
-
-        String datafile = datafileHandler.loadSavedDatafile(context, projectId);
-
-        if (datafile != null) {
-            return initialize(context, datafile);
-        }
-
-        // return dummy client if not able to initialize a valid one
-        return optimizelyClient;
+    public String getDatafile(Context context,@RawRes Integer datafileRes){
+     try {
+        if (isDatafileCached(context)) {
+            return datafileHandler.loadSavedDatafile(context, projectId);
+        } else if (datafileRes!=null) {
+            return loadRawResource(context, datafileRes);
+        }else{
+            logger.error("Invalid datafile resource ID.");
+            return null;
+        }
+    } catch (IOException e) {
+        logger.error("Unable to load compiled data file", e);
+    }catch (NullPointerException e){
+        logger.error("Unable to find compiled data file in raw resource",e);
+    }
+    return null;
     }
-
     /**
      * Starts Optimizely asynchronously
      * <p>
@@ -207,53 +231,39 @@ public OptimizelyClient initialize(@NonNull Context context) {
      * once.  If there is a cached datafile the returned instance will be built from it.  The cached
      * datafile will be updated from network if it is different from the cache.  If there is no
      * cached datafile the returned instance will always be built from the remote datafile.
-     *
-     * @param activity                an Activity, used to automatically unbind {@link DatafileService}
-     * @param optimizelyStartListener callback that {@link OptimizelyClient} instances are sent to.
-     */
-    @TargetApi(Build.VERSION_CODES.ICE_CREAM_SANDWICH)
-    public void initialize(@NonNull Activity activity, @NonNull OptimizelyStartListener optimizelyStartListener) {
-        if (!isAndroidVersionSupported()) {
-            return;
-        }
-        activity.getApplication().registerActivityLifecycleCallbacks(new OptlyActivityLifecycleCallbacks(this));
-        initialize(activity.getApplicationContext(), optimizelyStartListener);
-    }
-
-    /**
      * This method does the same thing except it can be used with a generic {@link Context}.
      * @param context                 any type of context instance
+     * @param datafileRes             Null is allowed here if user don't want to put datafile in res. Null handling is done in {@link #getDatafile(Context,Integer)}
      * @param optimizelyStartListener callback that {@link OptimizelyClient} instances are sent to.
-     * @see #initialize(Activity, OptimizelyStartListener)
+     * @see #initialize(Context, Integer, OptimizelyStartListener)
      */
-    public void initialize(@NonNull Context context, @NonNull OptimizelyStartListener optimizelyStartListener) {
+    @TargetApi(Build.VERSION_CODES.ICE_CREAM_SANDWICH)
+    public void initialize(@NonNull final Context context, @RawRes final Integer datafileRes, @NonNull OptimizelyStartListener optimizelyStartListener) {
         if (!isAndroidVersionSupported()) {
             return;
         }
-        this.optimizelyStartListener = optimizelyStartListener;
-        datafileHandler.downloadDatafile(context, projectId, getDatafileLoadedListener(context));
+        setOptimizelyStartListener(optimizelyStartListener);
+        datafileHandler.downloadDatafile(context, projectId,getDatafileLoadedListener(context,datafileRes));
     }
 
-    DatafileLoadedListener getDatafileLoadedListener(final Context context) {
+    DatafileLoadedListener getDatafileLoadedListener(final Context context, @RawRes final Integer datafileRes) {
         return new DatafileLoadedListener() {
             @RequiresApi(api = Build.VERSION_CODES.HONEYCOMB)
             @Override
             public void onDatafileLoaded(@Nullable String datafile) {
                 // App is being used, i.e. in the foreground
-                if (datafile != null) {
+                if (datafile != null && !datafile.isEmpty()) {
                     injectOptimizely(context, userProfileService, datafile);
                 } else {
-                    // We should always call the callback even with the dummy
-                    // instances.  Devs might gate the rest of their app
-                    // based on the loading of Optimizely
+                    //if datafile is null than it should be able to take from cache and if not present
+                    //in Cache than should be able to get from raw data file
+                    optimizelyClient = initialize(context,getDatafile(context,datafileRes),false);
                     notifyStartListener();
                 }
             }
 
             @Override
-            public void onStop(Context context) {
-
-            }
+            public void onStop(Context context) {}
         };
     }
 
@@ -281,11 +291,11 @@ public void stop(@NonNull Context context) {
     /**
      * Gets a cached Optimizely instance
      * <p>
-     * If {@link #initialize(Activity, OptimizelyStartListener)} or {@link #initialize(Context, OptimizelyStartListener)}
+     * If {@link #initialize(Context,Integer, OptimizelyStartListener)} or {@link #initialize(Context, Integer)}
      * has not been called yet the returned {@link OptimizelyClient} instance will be a dummy instance
      * that logs warnings in order to prevent {@link NullPointerException}.
      * <p>
-     * Using {@link #initialize(Activity, OptimizelyStartListener)} or {@link #initialize(Context, OptimizelyStartListener)}
+     * Using {@link #initialize(Context,Integer, OptimizelyStartListener)} or {@link #initialize(Context, Integer)}
      * will update the cached instance with a new {@link OptimizelyClient} built from a cached local
      * datafile on disk or a remote datafile on the CDN.
      *
@@ -527,7 +537,6 @@ public static class Builder {
         @Nullable private EventHandler eventHandler = null;
         @Nullable private ErrorHandler errorHandler = null;
         @Nullable private UserProfileService userProfileService = null;
-
         Builder(@NonNull String projectId) {
             this.projectId = projectId;
         }

android-sdk/src/main/java/com/optimizely/ab/android/sdk/OptimizelyManager.java

@@ -21,7 +21,7 @@
 
 /**
  * Listens for new instances of {@link OptimizelyClient} that are built after calling
- * {@link OptimizelyManager#initialize(Activity, OptimizelyStartListener)} or {@link OptimizelyManager#initialize(Context, OptimizelyStartListener)}
+ *{@link OptimizelyManager#initialize(Context, Integer,OptimizelyStartListener)}
  */
 public interface OptimizelyStartListener {
     /**