make android sdk configurable for logger, EventHandler, DatafileHandler, and ErrorHandler (#118)

* initial commit to refactor datafile-handler into its own package.

* fix all the unit tests and gradle build version name.

* update so that default attributes is always passed in

* refactor out any dependencies with android-sdk.  use reflection to load classes and call methods for default modules.  THIS IS A WORK IN PROGRESS

* make sure tests are working using reflection

* update to not use reflection for tests. cleanup manager. create a data file handler interface which will be the sole way to interact with the datafile-handler package

* create default DatafileHandler. create AndroidUserProfileService interface and default implementation derives from it

* refactor to allow datafile handler to be used. along with android user profile service and event handler. next add build options

* fix event handler

* remove the evidence of reflection used.:)

* add tests for DatafileHandler.  cleanup tests

* cleanup unit tests

* fix broken espresso test. we stop the service in the app right now

* rename everything to Datafile from DataFile

* cleanup comments and use DatafileService.EXTRA_PROJECT_ID

* cleanup comments

* allow override of datafilehandler, logger, event handler, and error handler.

* fix elliot comments.

* remove empty application tag from android-sdk manifest

* refactor background cache so that it is enabled and disabled with background updates for data files.

* refactor to remove AndroidUserProfileService interface in place of UserProfileService and cleanup background watchers cache

* refactor to use -1 dispatch interval to not do backgrounding

* refactor out completeInject

* fix unit tests after refactor

* Update and add licenses

* Rename dataFile to datafile
Remove time units for intervals

* remove connection change from itent filter

* Rename DatafileHandlerDefault to DefaultDatafileHandler

* Rename OptlyEventHandler to DefaultEventHandler

* Rename DefaultAndroidUserProfileService to DefaultUserProfileService

* slight refactor for creating user profile service and better java docs

* cleanup and fix unit tests

* some cleanup.  canidate for 1.4.0-alpha

* update change log

* fix version in change log

* fix changelog message

* intents are still defined in the appropriate manifest.  but, intent filters have all been taken out and must be declared in the application manifest if wanted

* update changelog

* change java core version to release 1.7.0

Author: thomaszurkan-optimizely

CHANGELOG.md

@@ -1,4 +1,21 @@
 # Optimizely Android X SDK Changelog
+### 1.4.0-alpha
+July 11, 2017
+
+- Allow configure background tasks to run or not.
+
+*Bug Fixes*
+
+- Close cursor on SQLlite.
+
+*Breaking Changes*
+
+- Must include intent filter for EventRescheduler and DatafileRescheduler in the application manifest if the devloper wants to use them (see the test-app manifest for an example).
+- Pass context into OptimizelyManager.Builder.
+- UserProfileService added.
+- Background processes are not running by default.
+- Various handlers (EventHandler, DatafileHandler, ErrorHandler) can be overridden.
+
 ### 1.3.1
 April 25, 2017
 

android-sdk/build.gradle

@@ -57,8 +57,11 @@ android {
 }
 
 dependencies {
+    compile project(':shared')
+    compile project(':datafile-handler')
     compile project(':event-handler')
     compile project(':user-profile')
+    compile "com.optimizely.ab:core-api:$java_core_ver"
     provided "com.android.support:support-annotations:$support_annotations_ver"
 
     testCompile "junit:junit:$junit_ver"
@@ -79,7 +82,7 @@ dependencies {
 
 uploadArchives {
     dependsOn = [':android-sdk:clean', ':android-sdk:releaseJavadocJar', ':android-sdk:releaseSourcesJar']
-    shouldRunAfter = [':event-handler:uploadArchives', ':user-profile:uploadArchives']
+    shouldRunAfter = [':datafile-handler:uploadArchives', ':event-handler:uploadArchives', ':user-profile:uploadArchives']
     repositories {
         mavenDeployer {
             repository(url: "https://api.bintray.com/maven/optimizely/optimizely/optimizely-sdk-android") {

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

@@ -16,18 +16,28 @@
 
 package com.optimizely.ab.android.sdk;
 
+import android.app.AlarmManager;
 import android.content.Context;
 import android.content.Intent;
+import android.content.pm.PackageInfo;
+import android.content.pm.PackageManager;
 import android.os.Build;
 import android.support.annotation.RequiresApi;
 import android.support.test.espresso.core.deps.guava.util.concurrent.ListeningExecutorService;
 import android.support.test.espresso.core.deps.guava.util.concurrent.MoreExecutors;
 import android.support.test.runner.AndroidJUnit4;
 
+import com.optimizely.ab.android.datafile_handler.DatafileHandler;
+import com.optimizely.ab.android.datafile_handler.DefaultDatafileHandler;
+import com.optimizely.ab.android.datafile_handler.DatafileService;
+import com.optimizely.ab.android.event_handler.DefaultEventHandler;
 import com.optimizely.ab.android.shared.ServiceScheduler;
-import com.optimizely.ab.android.user_profile.AndroidUserProfileService;
+import com.optimizely.ab.android.user_profile.DefaultUserProfileService;
 import com.optimizely.ab.config.parser.ConfigParseException;
 
+import com.optimizely.ab.bucketing.UserProfileService;
+import com.optimizely.ab.event.EventHandler;
+
 import org.junit.Before;
 import org.junit.Test;
 import org.junit.runner.RunWith;
@@ -58,7 +68,7 @@ public class OptimizelyManagerTest {
     private Logger logger;
     private OptimizelyManager optimizelyManager;
 
-    private String minDataFile = "{\n" +
+    private String minDatafile = "{\n" +
             "experiments: [ ],\n" +
             "version: \"2\",\n" +
             "audiences: [ ],\n" +
@@ -74,7 +84,10 @@ public class OptimizelyManagerTest {
     public void setup() {
         logger = mock(Logger.class);
         executor = MoreExecutors.newDirectExecutorService();
-        optimizelyManager = new OptimizelyManager(testProjectId, 1L, TimeUnit.HOURS, 1L, TimeUnit.HOURS, executor, logger);
+        DatafileHandler datafileHandler = mock(DefaultDatafileHandler.class);
+        EventHandler eventHandler = mock(DefaultEventHandler.class);
+        optimizelyManager = new OptimizelyManager(testProjectId, logger, 3600L, datafileHandler, null, 3600L,
+                eventHandler, null);
     }
 
     @SuppressWarnings("WrongConstant")
@@ -87,15 +100,11 @@ public void initialize() {
         when(appContext.getPackageName()).thenReturn("com.optly");
         ArgumentCaptor<Intent> captor = ArgumentCaptor.forClass(Intent.class);
 
-        optimizelyManager.initialize(context, startListener);
+        optimizelyManager.initialize(appContext, startListener);
 
         assertNotNull(optimizelyManager.getOptimizelyStartListener());
-        assertNotNull(optimizelyManager.getDataFileServiceConnection());
-
-        verify(appContext).bindService(captor.capture(), any(OptimizelyManager.DataFileServiceConnection.class), eq(Context.BIND_AUTO_CREATE));
+        assertNotNull(optimizelyManager.getDatafileHandler());
 
-        Intent intent = captor.getValue();
-        assertTrue(intent.getComponent().getShortClassName().contains("DataFileService"));
     }
 
     @Test
@@ -143,34 +152,28 @@ public void stop() {
         Context appContext = mock(Context.class);
         when(context.getApplicationContext()).thenReturn(appContext);
 
-        OptimizelyManager.DataFileServiceConnection dataFileServiceConnection = new OptimizelyManager.DataFileServiceConnection(optimizelyManager, context);
-        dataFileServiceConnection.setBound(true);
-        optimizelyManager.setDataFileServiceConnection(dataFileServiceConnection);
+        optimizelyManager.getDatafileHandler().downloadDatafile(context, optimizelyManager.getProjectId(), null);
 
         optimizelyManager.stop(context);
 
         assertNull(optimizelyManager.getOptimizelyStartListener());
-        verify(appContext).unbindService(dataFileServiceConnection);
     }
 
     @RequiresApi(api = Build.VERSION_CODES.HONEYCOMB)
     @Test
     public void injectOptimizely() {
         Context context = mock(Context.class);
-        AndroidUserProfileService userProfileService = mock(AndroidUserProfileService.class);
-        ServiceScheduler serviceScheduler = mock(ServiceScheduler.class);
-        ArgumentCaptor<Intent> captor = ArgumentCaptor.forClass(Intent.class);
+        UserProfileService userProfileService = mock(UserProfileService.class);
         OptimizelyStartListener startListener = mock(OptimizelyStartListener.class);
+
         optimizelyManager.setOptimizelyStartListener(startListener);
-        optimizelyManager.injectOptimizely(context, userProfileService, serviceScheduler, minDataFile);
+        optimizelyManager.injectOptimizely(context, userProfileService, minDatafile);
         try {
             executor.awaitTermination(5, TimeUnit.SECONDS);
         } catch (InterruptedException e) {
             fail("Timed out");
         }
 
-        verify(userProfileService).start();
-        verify(serviceScheduler).schedule(captor.capture(), eq(TimeUnit.HOURS.toMillis(1L)));
         verify(logger).info("Sending Optimizely instance to listener");
         verify(startListener).onStart(any(OptimizelyClient.class));
     }
@@ -179,80 +182,105 @@ public void injectOptimizely() {
     @Test
     public void injectOptimizelyNullListener() {
         Context context = mock(Context.class);
+        PackageManager packageManager = mock(PackageManager.class);
+
         when(context.getPackageName()).thenReturn("com.optly");
-        AndroidUserProfileService userProfileService = mock(AndroidUserProfileService.class);
+        when(context.getApplicationContext()).thenReturn(context);
+        when(context.getApplicationContext().getPackageManager()).thenReturn(packageManager);
+        try {
+            when(packageManager.getPackageInfo("com.optly", 0)).thenReturn(mock(PackageInfo.class));
+        } catch (PackageManager.NameNotFoundException e) {
+            e.printStackTrace();
+        }
+        UserProfileService userProfileService = mock(UserProfileService.class);
         ServiceScheduler serviceScheduler = mock(ServiceScheduler.class);
         ArgumentCaptor<Intent> captor = ArgumentCaptor.forClass(Intent.class);
+        ArgumentCaptor<DefaultUserProfileService.StartCallback> callbackArgumentCaptor =
+                ArgumentCaptor.forClass(DefaultUserProfileService.StartCallback.class);
         optimizelyManager.setOptimizelyStartListener(null);
-        optimizelyManager.injectOptimizely(context, userProfileService, serviceScheduler, minDataFile);
+
+        optimizelyManager.injectOptimizely(context, userProfileService, minDatafile);
+        AlarmManager alarmManager = (AlarmManager) context
+                .getSystemService(Context.ALARM_SERVICE);
+        ServiceScheduler.PendingIntentFactory pendingIntentFactory = new ServiceScheduler
+                .PendingIntentFactory(context);
+
+        Intent intent = new Intent(context, DatafileService.class);
+        intent.putExtra(DatafileService.EXTRA_PROJECT_ID, optimizelyManager.getProjectId());
+        serviceScheduler.schedule(intent, optimizelyManager.getDatafileDownloadInterval() * 1000);
+
         try {
             executor.awaitTermination(5, TimeUnit.SECONDS);
         } catch (InterruptedException e) {
             fail("Timed out");
         }
 
-        verify(userProfileService).start();
-        verify(serviceScheduler).schedule(captor.capture(), eq(TimeUnit.HOURS.toMillis(1L)));
         verify(logger).info("No listener to send Optimizely to");
+        verify(serviceScheduler).schedule(captor.capture(), eq(TimeUnit.HOURS.toMillis(1L)));
 
-        Intent intent = captor.getValue();
-        assertTrue(intent.getComponent().getShortClassName().contains("DataFileService"));
-        assertEquals(optimizelyManager.getProjectId(), intent.getStringExtra(DataFileService.EXTRA_PROJECT_ID));
+        Intent intent2 = captor.getValue();
+        assertTrue(intent2.getComponent().getShortClassName().contains("DatafileService"));
+        assertEquals(optimizelyManager.getProjectId(), intent2.getStringExtra(DatafileService.EXTRA_PROJECT_ID));
     }
 
     @RequiresApi(api = Build.VERSION_CODES.HONEYCOMB)
     @Test
-    public void injectOptimizelyHandlesInvalidDataFile() {
+    public void injectOptimizelyHandlesInvalidDatafile() {
         Context context = mock(Context.class);
+        PackageManager packageManager = mock(PackageManager.class);
+
         when(context.getPackageName()).thenReturn("com.optly");
-        AndroidUserProfileService userProfileService = mock(AndroidUserProfileService.class);
-        ServiceScheduler serviceScheduler = mock(ServiceScheduler.class);
+        when(context.getApplicationContext()).thenReturn(context);
+        when(context.getApplicationContext().getPackageManager()).thenReturn(packageManager);
+        try {
+            when(packageManager.getPackageInfo("com.optly", 0)).thenReturn(mock(PackageInfo.class));
+        } catch (PackageManager.NameNotFoundException e) {
+            e.printStackTrace();
+        }
+        DefaultUserProfileService userProfileService = mock(DefaultUserProfileService.class);
         ArgumentCaptor<Intent> captor = ArgumentCaptor.forClass(Intent.class);
+        ArgumentCaptor<DefaultUserProfileService.StartCallback> callbackArgumentCaptor =
+                ArgumentCaptor.forClass(DefaultUserProfileService.StartCallback.class);
+
         optimizelyManager.setOptimizelyStartListener(null);
-        optimizelyManager.injectOptimizely(context, userProfileService, serviceScheduler, "{}");
+        optimizelyManager.injectOptimizely(context, userProfileService, "{}");
         try {
             executor.awaitTermination(5, TimeUnit.SECONDS);
         } catch (InterruptedException e) {
             fail("Timed out");
         }
 
-        verify(userProfileService).start();
-        verify(serviceScheduler).schedule(captor.capture(), eq(TimeUnit.HOURS.toMillis(1L)));
         verify(logger).error(eq("Unable to build optimizely instance"), any(Exception.class));
 
-        Intent intent = captor.getValue();
-        assertTrue(intent.getComponent().getShortClassName().contains("DataFileService"));
-        assertEquals(optimizelyManager.getProjectId(), intent.getStringExtra(DataFileService.EXTRA_PROJECT_ID));
     }
 
     @RequiresApi(api = Build.VERSION_CODES.HONEYCOMB)
     @Test
     public void injectOptimizelyDoesNotDuplicateCallback() {
         Context context = mock(Context.class);
+        PackageManager packageManager = mock(PackageManager.class);
+
         when(context.getPackageName()).thenReturn("com.optly");
-        AndroidUserProfileService userProfileService = mock(AndroidUserProfileService.class);
-        ServiceScheduler serviceScheduler = mock(ServiceScheduler.class);
-        ArgumentCaptor<Intent> captor = ArgumentCaptor.forClass(Intent.class);
+        when(context.getApplicationContext()).thenReturn(context);
+        when(context.getApplicationContext().getPackageManager()).thenReturn(packageManager);
+        try {
+            when(packageManager.getPackageInfo("com.optly", 0)).thenReturn(mock(PackageInfo.class));
+        } catch (PackageManager.NameNotFoundException e) {
+            e.printStackTrace();
+        }
+
+        UserProfileService userProfileService = mock(UserProfileService.class);
+
         OptimizelyStartListener startListener = mock(OptimizelyStartListener.class);
         optimizelyManager.setOptimizelyStartListener(startListener);
-        optimizelyManager.injectOptimizely(context, userProfileService, serviceScheduler, minDataFile);
+        optimizelyManager.injectOptimizely(context, userProfileService, minDatafile);
         try {
             executor.awaitTermination(5, TimeUnit.SECONDS);
         } catch (InterruptedException e) {
             fail("Timed out");
         }
 
-        verify(userProfileService).start();
-        verify(serviceScheduler).schedule(captor.capture(), eq(TimeUnit.HOURS.toMillis(1L)));
-
         verify(logger).info("Sending Optimizely instance to listener");
         verify(startListener).onStart(any(OptimizelyClient.class));
-
-        optimizelyManager.injectOptimizely(context, userProfileService, serviceScheduler, minDataFile);
-        try {
-            executor.awaitTermination(5, TimeUnit.SECONDS);
-        } catch (InterruptedException e) {
-            fail("Timed out");
-        }
     }
 }

android-sdk/src/main/AndroidManifest.xml

@@ -1,25 +1,25 @@
 <?xml version="1.0" encoding="utf-8"?>
-<manifest package="com.optimizely.ab.android.sdk"
-          xmlns:android="http://schemas.android.com/apk/res/android">
+<!--
+/****************************************************************************
+ * Copyright 2017, Optimizely, Inc. and contributors                        *
+ *                                                                          *
+ * Licensed under the Apache License, Version 2.0 (the "License");          *
+ * you may not use this file except in compliance with the License.         *
+ * You may obtain a copy of the License at                                  *
+ *                                                                          *
+ *    http://www.apache.org/licenses/LICENSE-2.0                            *
+ *                                                                          *
+ * Unless required by applicable law or agreed to in writing, software      *
+ * distributed under the License is distributed on an "AS IS" BASIS,        *
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. *
+ * See the License for the specific language governing permissions and      *
+ * limitations under the License.                                           *
+ ***************************************************************************/
+-->
 
-    <uses-permission android:name="android.permission.INTERNET"/>
-
-    <application>
-        <service
-            android:name=".DataFileService"
-            android:enabled="true"
-            android:exported="false">
-        </service>
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+          package="com.optimizely.ab.android.sdk">
 
-        <receiver
-            android:name=".DataFileRescheduler"
-            android:enabled="true"
-            android:exported="false">
-            <intent-filter>
-                <action android:name="android.intent.action.MY_PACKAGE_REPLACED" />
-                <action android:name="android.intent.action.BOOT_COMPLETED" />
-            </intent-filter>
-        </receiver>
-    </application>
+    <uses-permission android:name="android.permission.INTERNET"/>
 
-</manifest>
+</manifest>