- Added support for android.app.Activity and android.app.Fragment with tasks but only on API 11+ and currently without easy to use TaskActivity or TaskFragment;

- Fixed a critical bug where the CallbackShadow would be wrapped by another CallbackShadow;

Author: Rolf-Smit

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

@@ -459,8 +459,11 @@ protected void onCancelled() {
     private void doCancelled() {
         onCancelled();
         Callback callback = getCallback();
-        if (callback != null && callback instanceof AdvancedCallback) {
+        if (callback instanceof AdvancedCallback) {
+            shouldDeliverResult = false;
             ((AdvancedCallback) callback).onCanceled(this);
+        } else {
+            shouldDeliverResult = true;
         }
     }
 

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

@@ -1,7 +1,10 @@
 package org.neotech.library.retainabletasks;
 
+import android.annotation.TargetApi;
+import android.os.Build;
 import android.support.annotation.MainThread;
 import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
 import android.support.v4.app.Fragment;
 import android.support.v4.app.FragmentManager;
 
@@ -85,8 +88,23 @@ public interface TaskAttachListener {
      */
     @MainThread
     public static TaskManager getFragmentTaskManager(@NonNull Fragment fragment){
-        TaskRetainingFragment taskRetainingFragment = TaskRetainingFragment.getInstance(fragment.getFragmentManager());
-        final String tag = getFragmentTag(fragment);
+        final String tag = getTaskManagerTag(fragment.getTag());
+        return getTaskManager(TaskRetainingFragment.getInstance(fragment.getFragmentManager()), tag);
+    }
+
+    /**
+     * Returns the {@link TaskManager} associated with the given Fragment.
+     * @param fragment The Fragment to get the TaskManager for.
+     * @return The TaskManager instance associated with the given Fragment.
+     */
+    @TargetApi(Build.VERSION_CODES.HONEYCOMB)
+    @MainThread
+    public static TaskManager getFragmentTaskManager(@NonNull android.app.Fragment fragment){
+        final String tag = getTaskManagerTag(fragment.getTag());
+        return getTaskManager(TaskRetainingFragment.getInstance(fragment.getFragmentManager()), tag);
+    }
+
+    private static TaskManager getTaskManager(@NonNull TaskRetainingFragment taskRetainingFragment, @NonNull String tag){
         BaseTaskManager manager = (BaseTaskManager) taskRetainingFragment.findTaskManagerByTag(tag);
         if(manager == null){
             manager = new BaseTaskManager();
@@ -95,9 +113,9 @@ public static TaskManager getFragmentTaskManager(@NonNull Fragment fragment){
         return manager;
     }
 
-    private static String getFragmentTag(@NonNull Fragment fragment) {
-        if (fragment.getTag() != null) {
-            return "tag:" + fragment.getTag();
+    private static String getTaskManagerTag(@Nullable String fragmentTag) {
+        if (fragmentTag != null) {
+            return "tag:" + fragmentTag;
         }
         throw new IllegalArgumentException("In order to associate a TaskManger with a Fragment the Fragment needs to have a tag.");
     }
@@ -114,6 +132,17 @@ public static TaskManager getActivityTaskManager(@NonNull FragmentManager manage
         return TaskRetainingFragment.getInstance(manager).getActivityTaskManager();
     }
 
+    /**
+     * Returns the {@link TaskManager} associated with the Activity the given FragmentManger belongs to. You
+     * should never try to supply a child/Fragment FragmentManger here.
+     * @param manager The FragmentManger of the Activity you would like to get the TaskManager for.
+     * @return The TaskManager instance associated with the given Activity's FragmentManger.
+     */
+    @MainThread
+    public static TaskManager getActivityTaskManager(@NonNull android.app.FragmentManager manager){
+        return TaskRetainingFragment.getInstance(manager).getActivityTaskManager();
+    }
+
     /**
      * Returns the global TaskManager. The global TaskManager isn't bound to the lifecycle of an
      * Activity and won't automatically remove a {@link Task.Callback} listeners set to

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

@@ -1,22 +1,32 @@
 package org.neotech.library.retainabletasks;
 
+import android.annotation.TargetApi;
+import android.app.Activity;
+import android.os.Build;
 import android.support.annotation.NonNull;
 import android.support.v4.app.Fragment;
-import android.support.v7.app.AppCompatActivity;
+import android.support.v4.app.FragmentActivity;
 
 import org.neotech.library.retainabletasks.internal.BaseTaskManager;
 
 /**
  * Created by Rolf on 3-3-2016.
  */
-public class TaskManagerLifeCycleProxy {
+public final class TaskManagerLifeCycleProxy {
 
     private BaseTaskManager fragmentTaskManager;
     private final TaskManagerProvider provider;
 
     public TaskManagerLifeCycleProxy(@NonNull TaskManagerProvider provider){
-        if(!(provider instanceof AppCompatActivity || provider instanceof Fragment)){
-            throw new IllegalArgumentException("The TaskManagerProvider needs to be an instance of android.support.v7.app.AppCompatActivity, or android.support.v4.app.Fragment.");
+        if(!(provider instanceof Activity || provider instanceof Fragment || 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!");
+
+            /**
+             * Checks if the given provider is not an instance of the support library Activity or Fragment and if the API version is lower than API 11.
+             * If so it should throw an exception as on API 11 or below we don't have access to Fragments.
+             */
+        } else if(Build.VERSION.SDK_INT < Build.VERSION_CODES.HONEYCOMB && !(provider instanceof FragmentActivity || provider instanceof Fragment)){
+            throw new IllegalArgumentException("This library doesn't support API level 11 or lower with the default android.app.Activity or android.app.Fragment class, you should use the android.support.v4.app.FragmentActivity or android.support.v4.app.Fragment!");
         }
         this.provider = provider;
     }
@@ -29,15 +39,23 @@ public void onStop(){
         ((BaseTaskManager) getTaskManager()).detach();
     }
 
+    @TargetApi(Build.VERSION_CODES.HONEYCOMB)
     public TaskManager getTaskManager(){
         if(fragmentTaskManager != null) {
             return fragmentTaskManager;
         }
-        if(provider instanceof AppCompatActivity){
-            fragmentTaskManager = (BaseTaskManager) TaskManager.getActivityTaskManager(((AppCompatActivity) provider).getSupportFragmentManager());
+        if(provider instanceof FragmentActivity){
+            fragmentTaskManager = (BaseTaskManager) TaskManager.getActivityTaskManager(((FragmentActivity) provider).getSupportFragmentManager());
         } else if(provider instanceof Fragment){
             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){
+            fragmentTaskManager = (BaseTaskManager) TaskManager.getFragmentTaskManager((android.app.Fragment) provider);
+        } /* else {
+            //This should never happen as the constructor checks everything.
         }
+        */
         return fragmentTaskManager;
     }
 }

library/src/main/java/org/neotech/library/retainabletasks/internal/BaseTaskManager.java

@@ -16,9 +16,9 @@
 /**
  * Created by Rolf on 29-2-2016.
  */
-public class BaseTaskManager extends TaskManager {
+public final class BaseTaskManager extends TaskManager {
 
-    private static final String TAG = "SimpleTaskManager";
+    private static final String TAG = "BaseTaskManager";
 
     protected final HashMap<String, Task<?, ?>> tasks = new HashMap<>();
 
@@ -33,7 +33,7 @@ public void attach(TaskManagerProvider taskManagerProvider){
             if(callback == null){
                 throw new IllegalArgumentException("Could not attach Task '" + task.getKey() + "' because onPreAttach did not return a valid Callback listener! Did you override onPreAttach()?");
             }
-            attach(task.getValue(), new CallbackShadow(callback));
+            attach(task.getValue(), callback);
         }
     }
 
@@ -155,12 +155,12 @@ public void detach(){
     private void removeFinishedTask(Task expectedTask){
         Task task = tasks.get(expectedTask.getTag());
         if(task != expectedTask){
-            Log.i(TAG, "Task '" + expectedTask.getTag() + "' has already been removed, because another task has been added while this task was finishing.");
+            Log.i(TAG, "Task '" + expectedTask.getTag() + "' has already been removed, because another task with the same tag has been added while this task was finishing.");
         }
         tasks.remove(expectedTask.getTag());
     }
 
-    protected final class CallbackShadow implements Task.AdvancedCallback  {
+    private final class CallbackShadow implements Task.AdvancedCallback  {
 
         private final Task.Callback callback;
 

library/src/main/java/org/neotech/library/retainabletasks/internal/TaskRetainingFragment.java

@@ -1,38 +1,51 @@
 package org.neotech.library.retainabletasks.internal;
 
-import android.os.Bundle;
+import android.annotation.TargetApi;
+import android.os.Build;
 import android.support.annotation.MainThread;
 import android.support.annotation.NonNull;
-import android.support.v4.app.Fragment;
 import android.support.v4.app.FragmentManager;
 
 import org.neotech.library.retainabletasks.TaskManager;
 
 import java.util.HashMap;
 
 /**
- * Created by Rolf on 29-2-2016.
+ * Created by Rolf on 4-3-2016.
  */
-public class TaskRetainingFragment extends Fragment {
+public final class TaskRetainingFragment {
 
-    private static final String FRAGMENT_TAG = "org.neotech.library.retainabletasks.TaskRetainingFragment";
-
-    private HashMap<String, TaskManager> fragmentTaskManagers = new HashMap<>();
+    public static final String FRAGMENT_TAG = "org.neotech.library.retainabletasks.TaskRetainingFragment";
 
+    private final HashMap<String, TaskManager> fragmentTaskManagers = new HashMap<>();
 
     private final BaseTaskManager taskManager = new BaseTaskManager();
 
     public static TaskRetainingFragment getInstance(FragmentManager fragmentManager){
-        TaskRetainingFragment taskFragment = (TaskRetainingFragment) fragmentManager.findFragmentByTag(FRAGMENT_TAG);
+        TaskRetainingFragmentCompat taskFragment = (TaskRetainingFragmentCompat) fragmentManager.findFragmentByTag(FRAGMENT_TAG);
+        if(taskFragment == null){
+            taskFragment = new TaskRetainingFragmentCompat();
+        }
+        if(!taskFragment.isAdded()) {
+            fragmentManager.beginTransaction().add(taskFragment, FRAGMENT_TAG).commit();
+        }
+        return taskFragment.logic;
+    }
+
+    @TargetApi(Build.VERSION_CODES.HONEYCOMB)
+    public static TaskRetainingFragment getInstance(android.app.FragmentManager fragmentManager){
+        TaskRetainingFragmentV11 taskFragment = (TaskRetainingFragmentV11) fragmentManager.findFragmentByTag(FRAGMENT_TAG);
         if(taskFragment == null){
-            taskFragment = new TaskRetainingFragment();
+            taskFragment = new TaskRetainingFragmentV11();
         }
         if(!taskFragment.isAdded()) {
             fragmentManager.beginTransaction().add(taskFragment, FRAGMENT_TAG).commit();
         }
-        return taskFragment;
+        return taskFragment.logic;
     }
 
+
+
     @MainThread
     public void registerTaskManager(@NonNull String tag, @NonNull TaskManager manager){
         if(fragmentTaskManagers.containsKey(tag)){
@@ -46,33 +59,7 @@ public TaskManager findTaskManagerByTag(@NonNull String tag){
         return fragmentTaskManagers.get(tag);
     }
 
-    public TaskManager getActivityTaskManager(){
+    public BaseTaskManager getActivityTaskManager(){
         return taskManager;
     }
-    @Override
-    public void onCreate(Bundle savedInstanceState) {
-        super.onCreate(savedInstanceState);
-        setRetainInstance(true);
-    }
-
-    @Override
-    public void onStop() {
-        super.onStop();
-        //As soon as the activity is stopped the UI should not be touched.
-        taskManager.detach();
-    }
-
-    @Override
-    public void onDestroy() {
-        /**
-         * The activity is destroyed, this method WON'T be called when the fragment is being
-         * propagated between activity instances.
-         *
-         * Cleanup, but let the tasks finish as they might do something important.
-         * The references to the tasks are lost at this point.
-         */
-
-        taskManager.detach();
-        super.onDestroy();
-    }
 }

library/src/main/java/org/neotech/library/retainabletasks/internal/TaskRetainingFragmentCompat.java

@@ -0,0 +1,39 @@
+package org.neotech.library.retainabletasks.internal;
+
+import android.os.Bundle;
+import android.support.v4.app.Fragment;
+
+/**
+ * Created by Rolf on 29-2-2016.
+ */
+public final class TaskRetainingFragmentCompat extends Fragment {
+
+    final TaskRetainingFragment logic = new TaskRetainingFragment();
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setRetainInstance(true);
+    }
+
+    @Override
+    public void onStop() {
+        super.onStop();
+        //As soon as the activity is stopped the UI should not be touched.
+        logic.getActivityTaskManager().detach();
+    }
+
+    @Override
+    public void onDestroy() {
+        /**
+         * The activity is destroyed, this method WON'T be called when the fragment is being
+         * propagated between activity instances.
+         *
+         * Cleanup, but let the tasks finish as they might do something important.
+         * The references to the tasks are lost at this point.
+         */
+
+        logic.getActivityTaskManager().detach();
+        super.onDestroy();
+    }
+}

library/src/main/java/org/neotech/library/retainabletasks/internal/TaskRetainingFragmentV11.java

@@ -0,0 +1,42 @@
+package org.neotech.library.retainabletasks.internal;
+
+import android.annotation.TargetApi;
+import android.app.Fragment;
+import android.os.Build;
+import android.os.Bundle;
+
+/**
+ * Created by Rolf on 4-3-2016.
+ */
+@TargetApi(Build.VERSION_CODES.HONEYCOMB)
+public final class TaskRetainingFragmentV11 extends Fragment {
+
+    final TaskRetainingFragment logic = new TaskRetainingFragment();
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setRetainInstance(true);
+    }
+
+    @Override
+    public void onStop() {
+        super.onStop();
+        //As soon as the activity is stopped the UI should not be touched.
+        logic.getActivityTaskManager().detach();
+    }
+
+    @Override
+    public void onDestroy() {
+        /**
+         * The activity is destroyed, this method WON'T be called when the fragment is being
+         * propagated between activity instances.
+         *
+         * Cleanup, but let the tasks finish as they might do something important.
+         * The references to the tasks are lost at this point.
+         */
+
+        logic.getActivityTaskManager().detach();
+        super.onDestroy();
+    }
+}