- Added a strict mode debug option;

- Renamed the TaskActivity and TaskFragment to TaskActivityCompat and TaskFragmentCompat;
- Added a android.app.Activity TaskActivity and android.app.Fragment TaskFragment for use on API 11+;
- Minor bug fixes;

Author: Rolf-Smit

README.md

@@ -37,7 +37,7 @@ dependencies {
 In order to, execute a task which modifies the user-interface and to retain it across configuration changes you will need to do three things:
 
 1. Create an implementation of the `Task` class;
-2. Make your Activity extend the `TaskActivity` class (or for Fragments the `TaskFragment` class);
+2. Make your Activity extend the `TaskActivityCompat` class (or for Fragments the `TaskFragmentCompat` class);
 3. Implement the `Callback` interface somewhere and execute the task using the `TaskManager`;
 
 
@@ -70,20 +70,20 @@ private class ExampleTask extends Task<Integer, String> {
 }
 ```
 
-### 1.2 Extending from the TaskActivity class
-The `TaskActivity` class is the most easy way to use this library, make sure your Activity extends from it and it wil take care of retaining all `Tasks` started by the Activity's `TaskManager`.
+### 1.2 Extending from the TaskActivityCompat class
+The `TaskActivityCompat` class is the most easy way to use this library, make sure your Activity extends from it and it wil take care of retaining all `Tasks` started by the Activity's `TaskManager`.
 
 ```java
-public class Main extends TaskActivity {
+public class Main extends TaskActivityCompat {
 
 }
 ```
 
 >**Help, I already extend some custom Activity implementation!** 
->Don't worry, you can easily add the `TaskActivity` behaviour to any Activity or Fragment by using the `TaskManagerLifeCycleProxy` class . Check out [this sample](#using-the-taskmanagerlifecycleproxy-to-mimic-the-taskactivity).
+>Don't worry, you can easily add the `TaskActivityCompat` behaviour to any Activity or Fragment by using the `TaskManagerLifeCycleProxy` class . Check out [this sample](#using-the-taskmanagerlifecycleproxy-to-mimic-the-taskactivity).
 
 ### 1.3 Execute the Task and receive callback
-Before you can execute the `ExampleTask` you first need to get the current Activity's `TaskManager`. A `TaskManager` keeps references to tasks and executes them. You can obtain the current Activity's `TaskManager` using the `TaskActivity.getTaskManager()` method.
+Before you can execute the `ExampleTask` you first need to get the current Activity's `TaskManager`. A `TaskManager` keeps references to tasks and executes them. You can obtain the current Activity's `TaskManager` using the `TaskActivityCompat.getTaskManager()` method.
 
 Then you can execute the task using the `TaskManager.execute()` method. This method needs two arguments, the task to execute and a `Callback` listener to send feedback to. Preferably your activity implements the `Callback` interface, but this isn't necessarily needed. The `TaskManager` currently always executes tasks in parallel *(work in progress to make it a option)*.
 
@@ -112,7 +112,7 @@ public class Main extends AppCompatActivity implements Task.Callback {
 
 
 >**Tip:**
->You can also make your Fragment extend the `TaskFragment` class and use a Fragment to execute and retain your task in. It works exactly the same, but keep in mind that the `Callback` listeners are removed as soon as the Fragments stops (`onStop()`). 
+>You can also make your Fragment extend the `TaskFragmentCompat` class and use a Fragment to execute and retain your task in. It works exactly the same, but keep in mind that the `Callback` listeners are removed as soon as the Fragments stops (`onStop()`). 
 
 
 ### 1.4 Retaining the task
@@ -121,7 +121,7 @@ When the configuration changes (device rotates) the `TaskManager` will automatic
 > **In-depth:**
 > The `TaskManger` (or actually a internal class) will detect when the Activity stops (`onStop()`). and will automatically remove all `Callback` listeners when this happens. At this moment the user-interface has become *"unstable"*,  this means that some user-interface functionality stops working. For example, the `FragmentManager` refuses at this point to add new Fragments because the Activity's `onSaveInstanceState()` method already has been called. If the `Callback` listener is not removed by the `TaskManager` before this point, then a `DialogFragment.show()` call will throw an exception when called in the `onPostExecute()` method. This is why the `Callback` listeners are removed when the Activity stops.
 
-Although tasks are automatically retained, you will still need to provide a new `Callback` listener for each `Task`. You can easily do this by implementing (overriding) the `TaskActivity` (or `TaskFragment`) `onPreAttachTask(Task)` method and return a `Callback` instance. At this point you can also use the `onPreAttachTask(Task)` method to restore the user-interface state according to the `Tasks` state. The `onPreAttachTask(Task)` method will be called for each task that isn't finished (didn't deliver).
+Although tasks are automatically retained, you will still need to provide a new `Callback` listener for each `Task`. You can easily do this by implementing (overriding) the `TaskActivityCompat` (or `TaskFragmentCompat`) `onPreAttachTask(Task)` method and return a `Callback` instance. At this point you can also use the `onPreAttachTask(Task)` method to restore the user-interface state according to the `Tasks` state. The `onPreAttachTask(Task)` method will be called for each task that isn't finished (didn't deliver).
 
 ```java
 public class Main extends AppCompatActivity implements Task.Callback {
@@ -140,8 +140,8 @@ public class Main extends AppCompatActivity implements Task.Callback {
 ####**How are tasks retained?**
 Tasks are are stored in `FragmentManagers` which are stored in a *"no-ui-fragment"* this fragment retained across configuration changes and is added to your Activity's `FragmentManager` the first time you call:
 
- - `TaskActivity.getTaskManager()`;
- - `TaskFragment.getTaskManager()`;
+ - `TaskActivityCompat.getTaskManager()`;
+ - `TaskFragmentCompat.getTaskManager()`;
  - `TaskManager.getActivityTaskManager()` (super-advanced usage);
  - `TaskManager.getFragmentTaskManager()` (super-advanced usage);
 

demo/src/main/AndroidManifest.xml

@@ -16,6 +16,12 @@
             android:theme="@style/AppTheme">
         </activity>
 
+        <activity
+            android:name=".ActivityV11"
+            android:label="@string/app_name"
+            android:theme="@style/AppTheme">
+        </activity>
+
         <activity
             android:name=".Main"
             android:label="@string/app_name"

demo/src/main/java/org/neotech/app/retainabletasksdemo/ActivityV11.java

@@ -0,0 +1,70 @@
+package org.neotech.app.retainabletasksdemo;
+
+import android.os.Bundle;
+import android.support.annotation.NonNull;
+import android.view.Gravity;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.Button;
+import android.widget.FrameLayout;
+
+import org.neotech.app.retainabletasksdemo.tasks.CountDownTask;
+import org.neotech.library.retainabletasks.Task;
+import org.neotech.library.retainabletasks.providers.TaskActivity;
+
+/**
+ * Created by Rolf on 4-3-2016.
+ */
+public class ActivityV11 extends TaskActivity implements View.OnClickListener, Task.AdvancedCallback {
+
+    private static final String TASK_COUNT_DOWN = "count-down";
+    private Button button;
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        FrameLayout root = new FrameLayout(this);
+        button = new Button(this);
+        button.setText(R.string.task_retain_ui_state);
+        button.setOnClickListener(this);
+
+        root.addView(button, new FrameLayout.LayoutParams(ViewGroup.LayoutParams.WRAP_CONTENT, ViewGroup.LayoutParams.WRAP_CONTENT, Gravity.CENTER));
+        setContentView(root);
+    }
+
+    @Override
+    public Task.Callback onPreAttach(@NonNull Task<?, ?> task) {
+        button.setEnabled(false);
+        button.setText("" + task.getLastKnownProgress());
+        return this;
+    }
+
+    @Override
+    public void onClick(View v) {
+        CountDownTask task = new CountDownTask(TASK_COUNT_DOWN, 10);
+        getTaskManager().execute(task, this);
+        button.setEnabled(false);
+    }
+
+    @Override
+    public void onPreExecute(Task<?, ?> task) {
+
+    }
+
+    @Override
+    public void onPostExecute(Task<?, ?> task) {
+        button.setEnabled(true);
+        button.setText(R.string.task_retain_ui_state);
+    }
+
+    @Override
+    public void onCanceled(Task<?, ?> task) {
+
+    }
+
+    @Override
+    public void onProgressUpdate(Task<?, ?> task, Object progress) {
+        button.setText("" + (int) progress);
+    }
+}

demo/src/main/java/org/neotech/app/retainabletasksdemo/Main.java

@@ -15,10 +15,10 @@
 import org.neotech.app.retainabletasksdemo.tasks.SimpleTask;
 import org.neotech.app.retainabletasksdemo.tasks.TaskWithoutCallback;
 import org.neotech.library.retainabletasks.Task;
-import org.neotech.library.retainabletasks.TaskActivity;
+import org.neotech.library.retainabletasks.providers.TaskActivityCompat;
 import org.neotech.library.retainabletasks.TaskExecutor;
 
-public class Main extends TaskActivity implements View.OnClickListener, Task.AdvancedCallback, OnAlertDialogClickListener {
+public class Main extends TaskActivityCompat implements View.OnClickListener, Task.AdvancedCallback, OnAlertDialogClickListener {
 
     private static final String TASK_RETAIN_UI_STATE = "retain-ui-state";
     private static final String TASK_PROGRESS = "progress-dialog";
@@ -35,6 +35,8 @@ protected void onCreate(Bundle savedInstanceState) {
         setSupportActionBar((Toolbar) findViewById(R.id.toolbar));
 
         findViewById(R.id.button_open_fragment_activity).setOnClickListener(this);
+        findViewById(R.id.button_open_v11_activity).setOnClickListener(this);
+
         findViewById(R.id.fab).setOnClickListener(this);
         findViewById(R.id.button_no_ui_task).setOnClickListener(this);
         findViewById(R.id.button_progress_task).setOnClickListener(this);
@@ -83,6 +85,8 @@ public void onClick(View v) {
             retainUserInterfaceButton.setEnabled(false);
         } else if(id == R.id.button_open_fragment_activity){
             startActivity(new Intent(this, ActivityWithFragments.class));
+        } else if(id == R.id.button_open_v11_activity){
+            startActivity(new Intent(this, ActivityV11.class));
         }
     }
 

demo/src/main/java/org/neotech/app/retainabletasksdemo/TestFragment.java

@@ -11,12 +11,12 @@
 
 import org.neotech.app.retainabletasksdemo.tasks.CountDownTask;
 import org.neotech.library.retainabletasks.Task;
-import org.neotech.library.retainabletasks.TaskFragment;
+import org.neotech.library.retainabletasks.providers.TaskFragmentCompat;
 
 /**
  * Created by Rolf on 3-3-2016.
  */
-public class TestFragment extends TaskFragment implements View.OnClickListener, Task.AdvancedCallback {
+public class TestFragment extends TaskFragmentCompat implements View.OnClickListener, Task.AdvancedCallback {
 
     private Button button;
 

demo/src/main/res/layout/content_main.xml

@@ -22,7 +22,14 @@
             android:id="@+id/button_open_fragment_activity"
             android:layout_height="wrap_content"
             android:layout_width="wrap_content"
-            android:text="@string/text_open_fragment_activty" />
+            android:text="@string/text_open_fragment_activity" />
+
+        <Button
+            android:id="@+id/button_open_v11_activity"
+            android:layout_height="wrap_content"
+            android:layout_width="wrap_content"
+            android:text="@string/text_open_v11_activity" />
+
 
         <Button
             android:id="@+id/button_no_ui_task"

demo/src/main/res/values/strings.xml

@@ -17,7 +17,9 @@
     <string name="navigation_drawer_open">Open navigation drawer</string>
     <string name="navigation_drawer_close">Close navigation drawer</string>
 
-    <string name="text_open_fragment_activty">Open fragment test activity</string>
+    <string name="text_open_fragment_activity">Start fragment test activity</string>
+    <string name="text_open_v11_activity">Start non-support library Activity</string>
+
 
     <string name="text_fragment_task_manager_explanation">"This Activity has three Fragments, each Fragment extends the TaskFragment and has its own TaskManager instance.
 

library/src/main/java/org/neotech/library/retainabletasks/Task.java

@@ -531,11 +531,11 @@ public final Result get() throws InterruptedException, ExecutionException {
     }
 
     /**
-     * Returns the currently set callback listener..
+     * Returns the currently set callback listener.
      * @return The currently set callback listener.
      */
     @MainThread
-    Callback getCallback(){
+    public Callback getCallback(){
         return callback;
     }
 

library/src/main/java/org/neotech/library/retainabletasks/TaskManager.java

@@ -78,8 +78,30 @@ public interface TaskAttachListener {
     @MainThread
     public abstract boolean isRunning(@NonNull String tag);
 
+    @MainThread
+    public abstract void assertAllTasksDetached() throws IllegalStateException;
+
     private static volatile BaseTaskManager globalInstance;
+    protected static volatile boolean strictDebug = false;
+
+    /**
+     * Enables or disables the strict debug mode. When this mode is enabled the TaskManager does
+     * some extra checking and throws exceptions if it detects faulty behaviour. You're encouraged
+     * to use this mode when testing your app. Strict mode is disabled by default.
+     * @param strictDebug true if the strict mode should be enabled, false if it should be disabled.
+     */
+    public static void setStrictDebugMode(boolean strictDebug){
+        TaskManager.strictDebug = strictDebug;
+    }
 
+    /**
+     * Returns whether the strict mode is enabled. By default the strict mode is disabled.
+     * @return true if strict mode is enabled, false if not.
+     * @see TaskManager#setStrictDebugMode(boolean)
+     */
+    public static boolean isStrictDebugModeEnabled(){
+        return strictDebug;
+    }
 
     /**
      * Returns the {@link TaskManager} associated with the given Fragment.
@@ -120,7 +142,6 @@ private static String getTaskManagerTag(@Nullable String fragmentTag) {
         throw new IllegalArgumentException("In order to associate a TaskManger with a Fragment the Fragment needs to have a tag.");
     }
 
-
     /**
      * Returns the {@link TaskManager} associated with the Activity the given FragmentManger belongs to. You
      * should never try to supply a child/Fragment FragmentManger here.

library/src/main/java/org/neotech/library/retainabletasks/TaskManagerLifeCycleProxy.java

@@ -18,7 +18,7 @@ public final class TaskManagerLifeCycleProxy {
     private final TaskManagerProvider provider;
 
     public TaskManagerLifeCycleProxy(@NonNull TaskManagerProvider provider){
-        if(!(provider instanceof Activity || provider instanceof Fragment || provider instanceof android.app.Fragment)){
+        if(!(provider instanceof Activity || provider instanceof Fragment || (Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB && provider instanceof android.app.Fragment))){
             throw new IllegalArgumentException("The TaskManagerProvider needs to be an instance of android.app.Activity (including the derived support library activities), android.app.Fragment or android.support.v4.app.Fragment!");
 
             /**
@@ -50,7 +50,7 @@ public TaskManager getTaskManager(){
             fragmentTaskManager = (BaseTaskManager) TaskManager.getFragmentTaskManager((Fragment) provider);
         } else if(provider instanceof Activity){
             fragmentTaskManager = (BaseTaskManager) TaskManager.getActivityTaskManager(((Activity) provider).getFragmentManager());
-        } else if(provider instanceof android.app.Fragment){
+        } else if(Build.VERSION.SDK_INT >= Build.VERSION_CODES.HONEYCOMB && provider instanceof android.app.Fragment){
             fragmentTaskManager = (BaseTaskManager) TaskManager.getFragmentTaskManager((android.app.Fragment) provider);
         } /* else {
             //This should never happen as the constructor checks everything.