diff --git a/README.md b/README.md
index 821adfbf..b673634b 100644
--- a/README.md
+++ b/README.md
@@ -172,7 +172,6 @@ public class HelloWorldPresenter extends TiPresenter<HelloWorldView> {
     public static final TiConfiguration PRESENTER_CONFIG = 
             new TiConfiguration.Builder()
                 .setRetainPresenterEnabled(true) 
-                .setUseStaticSaviorToRetain(true)
                 .setCallOnMainThreadInterceptorEnabled(true)
                 .setDistinctUntilChangedInterceptorEnabled(true)
                 .build();
diff --git a/plugin/src/main/java/net/grandcentrix/thirtyinch/plugin/TiActivityPlugin.java b/plugin/src/main/java/net/grandcentrix/thirtyinch/plugin/TiActivityPlugin.java
index 142cdf29..29e569f4 100644
--- a/plugin/src/main/java/net/grandcentrix/thirtyinch/plugin/TiActivityPlugin.java
+++ b/plugin/src/main/java/net/grandcentrix/thirtyinch/plugin/TiActivityPlugin.java
@@ -32,7 +32,6 @@
 import net.grandcentrix.thirtyinch.internal.TiPresenterProvider;
 import net.grandcentrix.thirtyinch.internal.TiViewProvider;
 import net.grandcentrix.thirtyinch.internal.UiThreadExecutor;
-import net.grandcentrix.thirtyinch.util.AndroidDeveloperOptions;
 import net.grandcentrix.thirtyinch.util.AnnotationUtil;
 
 import android.app.Activity;
@@ -77,7 +76,7 @@ public class TiActivityPlugin<P extends TiPresenter<V>, V extends TiView> extend
      */
     public TiActivityPlugin(@NonNull final TiPresenterProvider<P> presenterProvider) {
         mDelegate = new TiActivityDelegate<>(this, this, presenterProvider, this,
-                PresenterSavior.INSTANCE);
+                PresenterSavior.getInstance());
     }
 
     @NonNull
@@ -116,17 +115,6 @@ public final P getPresenter() {
         return mDelegate.getPresenter();
     }
 
-    @SuppressWarnings("unchecked")
-    @Nullable
-    @Override
-    public final P getRetainedPresenter() {
-        final Object nci = getLastNonConfigurationInstance(NCI_KEY_PRESENTER);
-        if (nci != null) {
-            return (P) nci;
-        }
-        return null;
-    }
-
     @Override
     public final Executor getUiThreadExecutor() {
         return mUiThreadExecutor;
@@ -152,8 +140,8 @@ public final boolean isActivityFinishing() {
     }
 
     @Override
-    public final boolean isDontKeepActivitiesEnabled() {
-        return AndroidDeveloperOptions.isDontKeepActivitiesEnabled(getActivity());
+    public Activity getHostingActivity() {
+        return getActivity();
     }
 
     @CallSuper
diff --git a/plugin/src/main/java/net/grandcentrix/thirtyinch/plugin/TiFragmentPlugin.java b/plugin/src/main/java/net/grandcentrix/thirtyinch/plugin/TiFragmentPlugin.java
index 5deec439..28e90687 100644
--- a/plugin/src/main/java/net/grandcentrix/thirtyinch/plugin/TiFragmentPlugin.java
+++ b/plugin/src/main/java/net/grandcentrix/thirtyinch/plugin/TiFragmentPlugin.java
@@ -32,13 +32,14 @@
 import net.grandcentrix.thirtyinch.internal.TiPresenterProvider;
 import net.grandcentrix.thirtyinch.internal.TiViewProvider;
 import net.grandcentrix.thirtyinch.internal.UiThreadExecutor;
-import net.grandcentrix.thirtyinch.util.AndroidDeveloperOptions;
 import net.grandcentrix.thirtyinch.util.AnnotationUtil;
 
+import android.app.Activity;
 import android.os.Bundle;
 import android.support.annotation.CallSuper;
 import android.support.annotation.NonNull;
 import android.support.annotation.Nullable;
+import android.support.v4.app.BackstackReader;
 import android.support.v4.app.Fragment;
 import android.view.LayoutInflater;
 import android.view.View;
@@ -78,7 +79,7 @@ public class TiFragmentPlugin<P extends TiPresenter<V>, V extends TiView> extend
      */
     public TiFragmentPlugin(@NonNull final TiPresenterProvider<P> presenterProvider) {
         mDelegate = new TiFragmentDelegate<>(this, this, presenterProvider, this,
-                PresenterSavior.INSTANCE);
+                PresenterSavior.getInstance());
     }
 
     @NonNull
@@ -87,12 +88,17 @@ public final Removable addBindViewInterceptor(@NonNull final BindViewInterceptor
         return mDelegate.addBindViewInterceptor(interceptor);
     }
 
+    @Override
+    public Activity getHostingActivity() {
+        return getFragment().getActivity();
+    }
+
     /**
      * @return the cached result of {@link BindViewInterceptor#intercept(TiView)}
      */
     @Nullable
     @Override
-    public final  V getInterceptedViewOf(@NonNull final BindViewInterceptor interceptor) {
+    public final V getInterceptedViewOf(@NonNull final BindViewInterceptor interceptor) {
         return mDelegate.getInterceptedViewOf(interceptor);
     }
 
@@ -131,11 +137,6 @@ public final void invalidateView() {
         mDelegate.invalidateView();
     }
 
-    @Override
-    public final boolean isDontKeepActivitiesEnabled() {
-        return AndroidDeveloperOptions.isDontKeepActivitiesEnabled(getFragment().getActivity());
-    }
-
     @Override
     public final boolean isFragmentAdded() {
         return getFragment().isAdded();
@@ -146,6 +147,11 @@ public final boolean isFragmentDetached() {
         return getFragment().isDetached();
     }
 
+    @Override
+    public boolean isFragmentRemoving() {
+        return getFragment().isRemoving();
+    }
+
     @Override
     public final boolean isHostingActivityChangingConfigurations() {
         return getFragment().getActivity().isChangingConfigurations();
@@ -156,6 +162,11 @@ public final boolean isHostingActivityFinishing() {
         return getFragment().getActivity().isFinishing();
     }
 
+    @Override
+    public boolean isFragmentInBackstack() {
+        return BackstackReader.isInBackStack(getFragment());
+    }
+
     @CallSuper
     @Override
     public void onCreate(final Bundle savedInstanceState) {
@@ -236,11 +247,6 @@ public V provideView() {
         }
     }
 
-    @Override
-    public final void setFragmentRetainInstance(final boolean retain) {
-        getFragment().setRetainInstance(retain);
-    }
-
     @Override
     public String toString() {
         String presenter = mDelegate.getPresenter() == null ? "null" :
diff --git a/sample/src/main/AndroidManifest.xml b/sample/src/main/AndroidManifest.xml
index 37fda4c0..0f75b76a 100644
--- a/sample/src/main/AndroidManifest.xml
+++ b/sample/src/main/AndroidManifest.xml
@@ -16,6 +16,10 @@
             </intent-filter>
         </activity>
 
+        <activity android:name=".fragmentlifecycle.FragmentLifecycleActivity" />
+
+        <activity android:name=".fragmentlifecycle.viewpager.LifecycleViewPagerActivity" />
+
     </application>
 
 </manifest>
diff --git a/sample/src/main/java/net/grandcentrix/thirtyinch/sample/HelloWorldActivity.java b/sample/src/main/java/net/grandcentrix/thirtyinch/sample/HelloWorldActivity.java
index 0566822d..5e62f821 100644
--- a/sample/src/main/java/net/grandcentrix/thirtyinch/sample/HelloWorldActivity.java
+++ b/sample/src/main/java/net/grandcentrix/thirtyinch/sample/HelloWorldActivity.java
@@ -19,9 +19,14 @@
 import com.jakewharton.rxbinding.view.RxView;
 
 import net.grandcentrix.thirtyinch.TiActivity;
+import net.grandcentrix.thirtyinch.sample.fragmentlifecycle.FragmentLifecycleActivity;
+import net.grandcentrix.thirtyinch.sample.fragmentlifecycle.viewpager.LifecycleViewPagerActivity;
 
+import android.content.Intent;
 import android.os.Bundle;
 import android.support.annotation.NonNull;
+import android.view.Menu;
+import android.view.MenuItem;
 import android.view.View;
 import android.widget.Button;
 import android.widget.TextView;
@@ -42,6 +47,25 @@ public Observable<Void> onButtonClicked() {
         return RxView.clicks(mButton);
     }
 
+    @Override
+    public boolean onCreateOptionsMenu(final Menu menu) {
+        getMenuInflater().inflate(R.menu.menu_hello_world, menu);
+        return true;
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(final MenuItem item) {
+        switch (item.getItemId()) {
+            case R.id.start_fragment_lifecycle_test:
+                startActivity(new Intent(this, FragmentLifecycleActivity.class));
+                return true;
+            case R.id.start_viewpager_test:
+                startActivity(new Intent(this, LifecycleViewPagerActivity.class));
+                return true;
+        }
+        return false;
+    }
+
     @NonNull
     @Override
     public HelloWorldPresenter providePresenter() {
@@ -80,4 +104,5 @@ public void onClick(final View v) {
             }
         });
     }
+
 }
diff --git a/sample/src/main/java/net/grandcentrix/thirtyinch/sample/fragmentlifecycle/FragmentLifecycleActivity.java b/sample/src/main/java/net/grandcentrix/thirtyinch/sample/fragmentlifecycle/FragmentLifecycleActivity.java
new file mode 100644
index 00000000..96833a87
--- /dev/null
+++ b/sample/src/main/java/net/grandcentrix/thirtyinch/sample/fragmentlifecycle/FragmentLifecycleActivity.java
@@ -0,0 +1,183 @@
+package net.grandcentrix.thirtyinch.sample.fragmentlifecycle;
+
+import net.grandcentrix.thirtyinch.sample.R;
+import net.grandcentrix.thirtyinch.sample.util.AndroidDeveloperOptions;
+
+import android.os.Bundle;
+import android.support.v4.app.Fragment;
+import android.support.v4.app.FragmentManager;
+import android.support.v4.app.FragmentTransaction;
+import android.support.v7.app.AppCompatActivity;
+import android.support.v7.widget.SwitchCompat;
+import android.util.Log;
+import android.view.View;
+import android.widget.TextView;
+import android.widget.Toast;
+
+import java.util.concurrent.TimeUnit;
+
+import rx.Observable;
+
+public class FragmentLifecycleActivity extends AppCompatActivity {
+
+    static int fragmentLifecycleActivityInstanceCount = -1;
+
+    private final String TAG = this.getClass().getSimpleName()
+            + "@" + Integer.toHexString(this.hashCode());
+
+    private SwitchCompat mSwitchAddToBackStack;
+
+    private SwitchCompat mSwitchRetainPresenterInstance;
+
+    public void addFragmentA(View view) {
+        final TestFragmentA fragment = new TestFragmentA();
+        Log.v(TAG, "adding FragmentA");
+        addFragment(fragment);
+    }
+
+    public void addFragmentB(View view) {
+        final TestFragmentB fragment = new TestFragmentB();
+        Log.v(TAG, "adding FragmentB");
+        addFragment(fragment);
+    }
+
+    public void detachFragmentAndAddAgain(View view) {
+        final Fragment fragment = getSupportFragmentManager()
+                .findFragmentById(R.id.fragment_placeholder);
+        if (fragment != null) {
+            //remove fragment
+            Log.v(TAG, "// When the Fragment is removed.");
+            getSupportFragmentManager().beginTransaction().remove(fragment).commitNow();
+
+            Log.v(TAG, "// When the Fragment get added again to the Activity.");
+            //add after delay again. Don't use the same transaction
+            Observable.just(null).delay(1, TimeUnit.SECONDS)
+                    .subscribe(o -> addFragment(fragment));
+        } else {
+            Toast.makeText(this, "no fragment found", Toast.LENGTH_SHORT).show();
+        }
+    }
+
+    @Override
+    public void finish() {
+        super.finish();
+        Log.v(TAG, "// When the Activity gets finished");
+    }
+
+    public void finishActivity(View view) {
+        Log.v(TAG, "finishing Activity");
+        finish();
+    }
+
+    @Override
+    public void onBackPressed() {
+        Log.v(TAG, "// When the back button gets pressed");
+        final FragmentManager fragmentManager = getSupportFragmentManager();
+        if (fragmentManager.getBackStackEntryCount() > 0) {
+            Log.v(TAG, "// When the top most fragment gets popped");
+            fragmentManager.popBackStack();
+        } else {
+            super.onBackPressed();
+        }
+    }
+
+    public void recreateActivity(View view) {
+        Log.v(TAG, "// And when the Activity is changing its configurations.");
+        recreate();
+    }
+
+    public void removeFragmentA(View view) {
+        final Fragment fragment = getSupportFragmentManager()
+                .findFragmentById(R.id.fragment_placeholder);
+        if (fragment instanceof TestFragmentA) {
+            Log.v(TAG, "remove FragmentA");
+            getSupportFragmentManager().beginTransaction()
+                    .remove(fragment)
+                    .commitNow();
+        }
+    }
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        if (savedInstanceState == null) {
+            //started for the first time, reset all counters
+            fragmentLifecycleActivityInstanceCount = -1;
+            TestFragment.testFragmentInstanceCount = -1;
+        }
+
+        fragmentLifecycleActivityInstanceCount++;
+        setContentView(R.layout.activity_fragment_lifecycle);
+        FragmentManager.enableDebugLogging(true);
+        Log.v(TAG, "onCreate of " + this);
+
+        mSwitchAddToBackStack = (SwitchCompat) findViewById(R.id.switch_add_back_stack);
+        mSwitchRetainPresenterInstance = (SwitchCompat) findViewById(
+                R.id.switch_retain_presenter_instance);
+        final TextView textDontKeepActivities = (TextView) findViewById(
+                R.id.text_dont_keep_activities);
+        textDontKeepActivities.setText(
+                isDontKeepActivities() ? R.string.dont_keep_activities_enabled
+                        : R.string.dont_keep_activities_disabled);
+
+        Log.v(TAG, "// A new Activity gets created by the Android Framework.");
+        Log.v(TAG, "final HostingActivity hostingActivity" + fragmentLifecycleActivityInstanceCount
+                + " = new HostingActivity();");
+    }
+
+    @Override
+    protected void onDestroy() {
+        super.onDestroy();
+
+        Log.v(TAG, "onDestroy");
+
+        Log.v(TAG, "// hostingActivity" + fragmentLifecycleActivityInstanceCount
+                + " got destroyed.");
+    }
+
+    @Override
+    protected void onPause() {
+        super.onPause();
+        Log.d(TAG, "onPause()");
+    }
+
+    @Override
+    protected void onSaveInstanceState(final Bundle outState) {
+        super.onSaveInstanceState(outState);
+        Log.d(TAG, "onSaveInstanceState(Bundle)");
+    }
+
+    private void addFragment(final Fragment fragment) {
+        final FragmentManager fragmentManager = getSupportFragmentManager();
+        final FragmentTransaction fragmentTransaction = fragmentManager.beginTransaction();
+        boolean retain = isRetainPresenterInstance();
+        if (retain) {
+            Log.v(TAG, "retaining presenter");
+        }
+        final Bundle bundle = new Bundle();
+        bundle.putBoolean(TestFragment.RETAIN_PRESENTER, retain);
+        fragment.setArguments(bundle);
+
+        fragmentTransaction.replace(R.id.fragment_placeholder, fragment);
+        if (isAddToBackStack()) {
+            Log.v(TAG, "adding transaction to the back stack");
+            fragmentTransaction.addToBackStack(null);
+        }
+        final int backStackId = fragmentTransaction.commit();
+        if (backStackId >= 0) {
+            Log.v(TAG, "Back stack ID: " + String.valueOf(backStackId));
+        }
+    }
+
+    private boolean isAddToBackStack() {
+        return mSwitchAddToBackStack.isChecked();
+    }
+
+    private boolean isDontKeepActivities() {
+        return AndroidDeveloperOptions.isDontKeepActivitiesEnabled(this);
+    }
+
+    private boolean isRetainPresenterInstance() {
+        return mSwitchRetainPresenterInstance.isChecked();
+    }
+}
diff --git a/sample/src/main/java/net/grandcentrix/thirtyinch/sample/fragmentlifecycle/TestFragment.java b/sample/src/main/java/net/grandcentrix/thirtyinch/sample/fragmentlifecycle/TestFragment.java
new file mode 100644
index 00000000..23975a44
--- /dev/null
+++ b/sample/src/main/java/net/grandcentrix/thirtyinch/sample/fragmentlifecycle/TestFragment.java
@@ -0,0 +1,398 @@
+package net.grandcentrix.thirtyinch.sample.fragmentlifecycle;
+
+import net.grandcentrix.thirtyinch.TiConfiguration;
+import net.grandcentrix.thirtyinch.TiFragment;
+import net.grandcentrix.thirtyinch.sample.R;
+
+import android.content.Context;
+import android.content.Intent;
+import android.content.res.Configuration;
+import android.os.Bundle;
+import android.support.annotation.LayoutRes;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.support.v4.app.BackstackReader;
+import android.support.v4.app.Fragment;
+import android.support.v4.app.FragmentActivity;
+import android.util.AttributeSet;
+import android.util.Log;
+import android.view.ContextMenu;
+import android.view.LayoutInflater;
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.ViewGroup;
+import android.view.animation.Animation;
+import android.widget.TextView;
+
+import java.util.UUID;
+
+import rx.subjects.PublishSubject;
+
+import static net.grandcentrix.thirtyinch.sample.fragmentlifecycle.FragmentLifecycleActivity.fragmentLifecycleActivityInstanceCount;
+
+public abstract class TestFragment
+        extends TiFragment<TestPresenter, TestPresenter.TestView>
+        implements TestPresenter.TestView {
+
+    public static final String RETAIN_PRESENTER = "retain";
+
+    static int testFragmentInstanceCount = -1;
+
+    private final String TAG = this.getClass().getSimpleName()
+            + "@" + Integer.toHexString(this.hashCode());
+
+    private int instanceNum = Integer.MIN_VALUE;
+
+    private PublishSubject<Boolean> mAddedState = PublishSubject.create();
+
+    private PublishSubject<Boolean> mDetachedState = PublishSubject.create();
+
+    private PublishSubject<Boolean> mInBackstackState = PublishSubject.create();
+
+    private PublishSubject<Boolean> mIsActivityChangingConfigState = PublishSubject.create();
+
+    private PublishSubject<Boolean> mIsActivityFinishingState = PublishSubject.create();
+
+    private PublishSubject<Boolean> mRemovingState = PublishSubject.create();
+
+    private String mUuid;
+
+    public TestFragment() {
+        Log.v(TAG, this + " constructor called");
+
+        testFragmentInstanceCount++;
+        instanceNum = testFragmentInstanceCount;
+    }
+
+    @Override
+    public void onActivityCreated(@Nullable final Bundle savedInstanceState) {
+        super.onActivityCreated(savedInstanceState);
+        Log.v(TAG, "onActivityCreated");
+    }
+
+    @Override
+    public void onActivityResult(final int requestCode, final int resultCode, final Intent data) {
+        super.onActivityResult(requestCode, resultCode, data);
+        Log.v(TAG, "onActivityResult");
+    }
+
+    @Override
+    public void onAttach(final Context context) {
+        mAddedState.startWith(false).distinctUntilChanged().skip(1).subscribe(added -> {
+            Log.d(TAG, "fragment" + instanceNum + ".setAdded(" + added + ")");
+        });
+        mDetachedState.startWith(false).distinctUntilChanged().skip(1).subscribe(detached -> {
+            Log.d(TAG, "fragment" + instanceNum + ".setDetached(" + detached + ")");
+        });
+        mRemovingState.startWith(false).distinctUntilChanged().skip(1).subscribe(removing -> {
+            Log.d(TAG, "fragment" + instanceNum + ".setRemoving(" + removing + ")");
+        });
+        mInBackstackState.startWith(false).distinctUntilChanged().skip(1).subscribe(inBackstack -> {
+            Log.d(TAG,
+                    "fragment" + instanceNum + ".setInBackstack(" + inBackstack + ")");
+        });
+
+        mIsActivityChangingConfigState.startWith(false).distinctUntilChanged().skip(1)
+                .subscribe(changing -> {
+                    Log.d(TAG,
+                            "hostingActivity" + fragmentLifecycleActivityInstanceCount + ""
+                                    + ".setChangingConfiguration(" + changing + ");");
+                });
+        mIsActivityFinishingState.startWith(false).distinctUntilChanged().skip(1)
+                .subscribe(finishing -> {
+                    Log.d(TAG,
+                            "hostingActivity" + fragmentLifecycleActivityInstanceCount + ""
+                                    + ".setFinishing(" + finishing + ");");
+                });
+
+        printState();
+        super.onAttach(context);
+        Log.v(TAG, "onAttach(" + context + ")");
+        printState();
+    }
+
+    @Override
+    public void onAttachFragment(final Fragment childFragment) {
+        super.onAttachFragment(childFragment);
+        printState();
+        Log.v(TAG, "onAttachFragment");
+    }
+
+    @Override
+    public void onConfigurationChanged(final Configuration newConfig) {
+        super.onConfigurationChanged(newConfig);
+        Log.v(TAG, "onConfigurationChanged");
+    }
+
+    @Override
+    public boolean onContextItemSelected(final MenuItem item) {
+        Log.v(TAG, "onContextItemSelected");
+        return super.onContextItemSelected(item);
+    }
+
+    @Override
+    public void onCreate(@Nullable final Bundle savedInstanceState) {
+        printState();
+        super.onCreate(savedInstanceState);
+        Log.v(TAG, "onCreate(" + savedInstanceState + ")");
+        printState();
+        if (savedInstanceState != null) {
+            mUuid = savedInstanceState.getString("uuid");
+            Log.v(TAG, "RESTORED " + mUuid);
+        }
+        if (mUuid == null) {
+            mUuid = UUID.randomUUID().toString();
+            Log.v(TAG, "CREATED " + mUuid);
+        }
+
+        if (savedInstanceState == null) {
+            Log.d(TAG, "fragment" + instanceNum + ".onCreate(null);");
+        } else {
+            Log.d(TAG, "fragment" + instanceNum
+                    + ".onCreate(savedInstanceState);");
+        }
+    }
+
+    @Override
+    public Animation onCreateAnimation(final int transit, final boolean enter, final int nextAnim) {
+        Log.v(TAG, "onCreateAnimation");
+        return super.onCreateAnimation(transit, enter, nextAnim);
+    }
+
+    @Override
+    public void onCreateContextMenu(final ContextMenu menu, final View v,
+            final ContextMenu.ContextMenuInfo menuInfo) {
+        super.onCreateContextMenu(menu, v, menuInfo);
+        Log.v(TAG, "onCreateContextMenu");
+    }
+
+    @Override
+    public void onCreateOptionsMenu(final Menu menu, final MenuInflater inflater) {
+        super.onCreateOptionsMenu(menu, inflater);
+        Log.v(TAG, "onCreateOptionsMenu");
+    }
+
+    @Nullable
+    @Override
+    public View onCreateView(final LayoutInflater inflater, @Nullable final ViewGroup container,
+            @Nullable final Bundle savedInstanceState) {
+        super.onCreateView(inflater, container, savedInstanceState);
+        printState();
+        Log.v(TAG,
+                "onCreateView() called with: inflater = [" + inflater + "], container = ["
+                        + container + "], savedInstanceState = [" + savedInstanceState + "]");
+        if (savedInstanceState == null) {
+            Log.d(TAG, "fragment" + instanceNum
+                    + ".onCreateView(inflater, null, null);");
+        } else {
+            Log.d(TAG, "fragment" + instanceNum
+                    + ".onCreateView(inflater, null, savedInstanceState);");
+        }
+
+        return inflater.inflate(getLayoutResId(), container, false);
+    }
+
+    @Override
+    public void onDestroy() {
+        printState();
+        super.onDestroy();
+        Log.v(TAG, "onDestroy");
+        Log.d(TAG, "fragment" + instanceNum + ".onDestroy();");
+        printState();
+        Log.v("FragmentManager", "DESTROYED " + mUuid);
+    }
+
+    @Override
+    public void onDestroyOptionsMenu() {
+        super.onDestroyOptionsMenu();
+        Log.v(TAG, "onDestroyOptionsMenu");
+    }
+
+    @Override
+    public void onDestroyView() {
+        printState();
+        super.onDestroyView();
+        Log.v(TAG, "onDestroyView");
+        printState();
+
+        Log.d(TAG, "fragment" + instanceNum + ".onDestroyView();");
+    }
+
+    @Override
+    public void onDetach() {
+        super.onDetach();
+        printState();
+        Log.v(TAG, "onDetach");
+        printState();
+
+        mAddedState.onCompleted();
+        mDetachedState.onCompleted();
+        mRemovingState.onCompleted();
+        mIsActivityChangingConfigState.onCompleted();
+        mIsActivityFinishingState.onCompleted();
+    }
+
+    @Override
+    public void onHiddenChanged(final boolean hidden) {
+        super.onHiddenChanged(hidden);
+        Log.v(TAG, "onHiddenChanged");
+    }
+
+    @Override
+    public void onInflate(final Context context, final AttributeSet attrs,
+            final Bundle savedInstanceState) {
+        super.onInflate(context, attrs, savedInstanceState);
+        Log.v(TAG, "onInflate");
+    }
+
+    @Override
+    public void onLowMemory() {
+        super.onLowMemory();
+        Log.v(TAG, "onLowMemory");
+        printState();
+    }
+
+    @Override
+    public void onMultiWindowModeChanged(final boolean isInMultiWindowMode) {
+        super.onMultiWindowModeChanged(isInMultiWindowMode);
+        Log.v(TAG, "onMultiWindowModeChanged");
+        printState();
+    }
+
+    @Override
+    public boolean onOptionsItemSelected(final MenuItem item) {
+        Log.v(TAG, "onOptionsItemSelected");
+        return super.onOptionsItemSelected(item);
+    }
+
+    @Override
+    public void onOptionsMenuClosed(final Menu menu) {
+        super.onOptionsMenuClosed(menu);
+        Log.v(TAG, "onOptionsMenuClosed");
+    }
+
+    @Override
+    public void onPause() {
+        printState();
+        super.onPause();
+        Log.v(TAG, "onPause()");
+        printState();
+    }
+
+    @Override
+    public void onPictureInPictureModeChanged(final boolean isInPictureInPictureMode) {
+        super.onPictureInPictureModeChanged(isInPictureInPictureMode);
+        Log.v(TAG, "onPictureInPictureModeChanged");
+        printState();
+    }
+
+    @Override
+    public void onPrepareOptionsMenu(final Menu menu) {
+        super.onPrepareOptionsMenu(menu);
+        Log.v(TAG, "onPrepareOptionsMenu");
+    }
+
+    @Override
+    public void onRequestPermissionsResult(final int requestCode,
+            @NonNull final String[] permissions,
+            @NonNull final int[] grantResults) {
+        super.onRequestPermissionsResult(requestCode, permissions, grantResults);
+        Log.v(TAG, "onRequestPermissionsResult");
+        printState();
+    }
+
+    @Override
+    public void onResume() {
+        printState();
+        super.onResume();
+        Log.v(TAG, "onResume");
+        printState();
+    }
+
+    @Override
+    public void onSaveInstanceState(final Bundle outState) {
+        super.onSaveInstanceState(outState);
+        printState();
+
+        outState.putString("uuid", mUuid);
+
+        Log.d(TAG, "fragment" + instanceNum + ".onSaveInstanceState(outState);");
+        printState();
+    }
+
+    @Override
+    public void onStart() {
+        printState();
+        super.onStart();
+        Log.d(TAG, "fragment" + instanceNum + ".onStart();");
+        printState();
+    }
+
+    @Override
+    public void onStop() {
+        printState();
+        super.onStop();
+        Log.d(TAG, "fragment" + instanceNum + ".onStop();");
+        printState();
+    }
+
+    @Override
+    public void onViewCreated(final View view, @Nullable final Bundle savedInstanceState) {
+        printState();
+        super.onViewCreated(view, savedInstanceState);
+        Log.v(TAG, "onViewCreated");
+        printState();
+
+        final TextView fragmentTag = (TextView) view.findViewById(R.id.sample_text);
+        fragmentTag.setText(TAG);
+    }
+
+    @Override
+    public void onViewStateRestored(@Nullable final Bundle savedInstanceState) {
+        super.onViewStateRestored(savedInstanceState);
+        Log.v(TAG, "onViewStateRestored");
+    }
+
+    @NonNull
+    @Override
+    public TestPresenter providePresenter() {
+        boolean retain = false;
+        if (getArguments() != null) {
+            retain = getArguments().getBoolean(RETAIN_PRESENTER, false);
+        }
+
+        final TiConfiguration config = new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(retain)
+                .build();
+
+        final TestPresenter presenter = new TestPresenter(config, getClass().getSimpleName());
+        Log.d(TAG, "created " + presenter);
+        Log.v(TAG, "retain presenter " + retain + ", " + presenter);
+
+        return presenter;
+    }
+
+    @Override
+    protected void finalize() throws Throwable {
+        super.finalize();
+        Log.v(TAG, "GCed " + this + ", uuid: " + this.mUuid);
+    }
+
+    @LayoutRes
+    abstract int getLayoutResId();
+
+    private void printState() {
+        mAddedState.onNext(isAdded());
+        mDetachedState.onNext(isDetached());
+        mRemovingState.onNext(isRemoving());
+        mInBackstackState.onNext(BackstackReader.isInBackStack(this));
+
+        final FragmentActivity activity = getActivity();
+        if (activity != null) {
+            mIsActivityFinishingState.onNext(activity.isFinishing());
+            mIsActivityChangingConfigState.onNext(activity.isChangingConfigurations());
+        }
+    }
+}
diff --git a/sample/src/main/java/net/grandcentrix/thirtyinch/sample/fragmentlifecycle/TestFragmentA.java b/sample/src/main/java/net/grandcentrix/thirtyinch/sample/fragmentlifecycle/TestFragmentA.java
new file mode 100644
index 00000000..2027fcfa
--- /dev/null
+++ b/sample/src/main/java/net/grandcentrix/thirtyinch/sample/fragmentlifecycle/TestFragmentA.java
@@ -0,0 +1,11 @@
+package net.grandcentrix.thirtyinch.sample.fragmentlifecycle;
+
+import net.grandcentrix.thirtyinch.sample.R;
+
+public class TestFragmentA extends TestFragment {
+
+    @Override
+    int getLayoutResId() {
+        return R.layout.fragment_a_test;
+    }
+}
diff --git a/sample/src/main/java/net/grandcentrix/thirtyinch/sample/fragmentlifecycle/TestFragmentB.java b/sample/src/main/java/net/grandcentrix/thirtyinch/sample/fragmentlifecycle/TestFragmentB.java
new file mode 100644
index 00000000..91dcef92
--- /dev/null
+++ b/sample/src/main/java/net/grandcentrix/thirtyinch/sample/fragmentlifecycle/TestFragmentB.java
@@ -0,0 +1,11 @@
+package net.grandcentrix.thirtyinch.sample.fragmentlifecycle;
+
+import net.grandcentrix.thirtyinch.sample.R;
+
+public class TestFragmentB extends TestFragment {
+
+    @Override
+    int getLayoutResId() {
+        return R.layout.fragment_b_test;
+    }
+}
diff --git a/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/internal/PresenterNonConfigurationInstance.java b/sample/src/main/java/net/grandcentrix/thirtyinch/sample/fragmentlifecycle/TestPresenter.java
similarity index 53%
rename from thirtyinch/src/main/java/net/grandcentrix/thirtyinch/internal/PresenterNonConfigurationInstance.java
rename to sample/src/main/java/net/grandcentrix/thirtyinch/sample/fragmentlifecycle/TestPresenter.java
index a9d2bdaa..bd86b2ca 100644
--- a/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/internal/PresenterNonConfigurationInstance.java
+++ b/sample/src/main/java/net/grandcentrix/thirtyinch/sample/fragmentlifecycle/TestPresenter.java
@@ -13,27 +13,33 @@
  * limitations under the License.
  */
 
-package net.grandcentrix.thirtyinch.internal;
+package net.grandcentrix.thirtyinch.sample.fragmentlifecycle;
 
+
+import net.grandcentrix.thirtyinch.TiConfiguration;
 import net.grandcentrix.thirtyinch.TiPresenter;
+import net.grandcentrix.thirtyinch.TiView;
+
+public class TestPresenter extends TiPresenter<TestPresenter.TestView> {
 
-public class PresenterNonConfigurationInstance<P extends TiPresenter> {
+    public interface TestView extends TiView {
 
-    private Object OtherNonConfigurationInstance;
+    }
 
-    private P mPresenter;
+    private final String mName;
 
-    public PresenterNonConfigurationInstance(final P presenter,
-            final Object otherNonConfigurationInstance) {
-        mPresenter = presenter;
-        OtherNonConfigurationInstance = otherNonConfigurationInstance;
+    public TestPresenter(final String name) {
+        mName = name;
     }
 
-    public Object getOtherNonConfigurationInstance() {
-        return OtherNonConfigurationInstance;
+    public TestPresenter(final TiConfiguration config, final String name) {
+        super(config);
+
+        mName = name;
     }
 
-    public P getPresenter() {
-        return mPresenter;
+    @Override
+    public String toString() {
+        return mName + "#" + super.toString();
     }
 }
diff --git a/sample/src/main/java/net/grandcentrix/thirtyinch/sample/fragmentlifecycle/viewpager/LifecycleViewPagerActivity.java b/sample/src/main/java/net/grandcentrix/thirtyinch/sample/fragmentlifecycle/viewpager/LifecycleViewPagerActivity.java
new file mode 100644
index 00000000..6e24b44a
--- /dev/null
+++ b/sample/src/main/java/net/grandcentrix/thirtyinch/sample/fragmentlifecycle/viewpager/LifecycleViewPagerActivity.java
@@ -0,0 +1,20 @@
+package net.grandcentrix.thirtyinch.sample.fragmentlifecycle.viewpager;
+
+import android.os.Bundle;
+import android.support.annotation.Nullable;
+import android.support.v4.view.ViewPager;
+import android.support.v7.app.AppCompatActivity;
+import android.view.View;
+
+public class LifecycleViewPagerActivity extends AppCompatActivity {
+
+    @Override
+    public void onCreate(@Nullable final Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        final ViewPager viewPager = new ViewPager(this);
+        viewPager.setId(View.generateViewId());
+        setContentView(viewPager);
+
+        viewPager.setAdapter(new PagerAdapter(getSupportFragmentManager()));
+    }
+}
diff --git a/sample/src/main/java/net/grandcentrix/thirtyinch/sample/fragmentlifecycle/viewpager/PagerAdapter.java b/sample/src/main/java/net/grandcentrix/thirtyinch/sample/fragmentlifecycle/viewpager/PagerAdapter.java
new file mode 100644
index 00000000..cc8c4e59
--- /dev/null
+++ b/sample/src/main/java/net/grandcentrix/thirtyinch/sample/fragmentlifecycle/viewpager/PagerAdapter.java
@@ -0,0 +1,24 @@
+package net.grandcentrix.thirtyinch.sample.fragmentlifecycle.viewpager;
+
+import net.grandcentrix.thirtyinch.sample.fragmentlifecycle.TestFragmentA;
+
+import android.support.v4.app.Fragment;
+import android.support.v4.app.FragmentManager;
+import android.support.v4.app.FragmentPagerAdapter;
+
+class PagerAdapter extends FragmentPagerAdapter {
+
+    public PagerAdapter(final FragmentManager fm) {
+        super(fm);
+    }
+
+    @Override
+    public int getCount() {
+        return 4;
+    }
+
+    @Override
+    public Fragment getItem(final int position) {
+        return new TestFragmentA();
+    }
+}
diff --git a/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/util/AndroidDeveloperOptions.java b/sample/src/main/java/net/grandcentrix/thirtyinch/sample/util/AndroidDeveloperOptions.java
similarity index 96%
rename from thirtyinch/src/main/java/net/grandcentrix/thirtyinch/util/AndroidDeveloperOptions.java
rename to sample/src/main/java/net/grandcentrix/thirtyinch/sample/util/AndroidDeveloperOptions.java
index e1667836..072b8a31 100644
--- a/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/util/AndroidDeveloperOptions.java
+++ b/sample/src/main/java/net/grandcentrix/thirtyinch/sample/util/AndroidDeveloperOptions.java
@@ -13,7 +13,7 @@
  * limitations under the License.
  */
 
-package net.grandcentrix.thirtyinch.util;
+package net.grandcentrix.thirtyinch.sample.util;
 
 import android.content.Context;
 import android.os.Build;
diff --git a/sample/src/main/res/layout/activity_fragment_lifecycle.xml b/sample/src/main/res/layout/activity_fragment_lifecycle.xml
new file mode 100644
index 00000000..5e3c598a
--- /dev/null
+++ b/sample/src/main/res/layout/activity_fragment_lifecycle.xml
@@ -0,0 +1,105 @@
+<?xml version="1.0" encoding="utf-8"?>
+<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    tools:context="net.grandcentrix.thirtyinch.sample.fragmentlifecycle.FragmentLifecycleActivity">
+
+    <FrameLayout
+        android:id="@+id/fragment_placeholder"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent" />
+
+    <LinearLayout
+        android:layout_width="match_parent"
+        android:layout_height="wrap_content"
+        android:layout_alignParentBottom="true"
+        android:orientation="vertical">
+
+        <TextView
+            android:id="@+id/text_dont_keep_activities"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:padding="16dp"
+            tools:text="@string/dont_keep_activities_enabled" />
+
+        <android.support.v7.widget.SwitchCompat
+            android:id="@+id/switch_retain_presenter_instance"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:padding="16dp"
+            android:text="@string/retain_presenter_instance" />
+
+        <android.support.v7.widget.SwitchCompat
+            android:id="@+id/switch_add_back_stack"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:padding="16dp"
+            android:text="@string/add_transaction_to_back_stack" />
+
+        <LinearLayout
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:orientation="horizontal">
+
+            <Button
+                android:layout_width="0dp"
+                android:layout_height="wrap_content"
+                android:layout_weight="0.5"
+                android:onClick="addFragmentA"
+                android:text="@string/add_fragment_a" />
+
+            <Button
+                android:layout_width="0dp"
+                android:layout_height="wrap_content"
+                android:layout_weight="0.5"
+                android:onClick="removeFragmentA"
+                android:text="@string/remove_fragment_a" />
+
+        </LinearLayout>
+
+        <Button
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:onClick="addFragmentB"
+            android:text="@string/add_fragment_b" />
+
+        <LinearLayout
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:orientation="horizontal">
+
+            <Button
+                android:layout_width="0dp"
+                android:layout_height="wrap_content"
+                android:layout_weight="0.5"
+                android:onClick="detachFragmentAndAddAgain"
+                android:text="@string/detach_attach_again" />
+
+        </LinearLayout>
+
+
+        <LinearLayout
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:orientation="horizontal">
+
+            <Button
+                android:layout_width="0dp"
+                android:layout_height="wrap_content"
+                android:layout_weight="0.5"
+                android:onClick="recreateActivity"
+                android:text="@string/recreate_activity" />
+
+            <Button
+                android:layout_width="0dp"
+                android:layout_height="wrap_content"
+                android:layout_weight="0.5"
+                android:onClick="finishActivity"
+                android:text="@string/finish_activity" />
+
+        </LinearLayout>
+
+    </LinearLayout>
+
+</RelativeLayout>
\ No newline at end of file
diff --git a/sample/src/main/res/layout/fragment_a_test.xml b/sample/src/main/res/layout/fragment_a_test.xml
new file mode 100644
index 00000000..52edd2a4
--- /dev/null
+++ b/sample/src/main/res/layout/fragment_a_test.xml
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:background="@android:color/holo_green_dark"
+    android:orientation="vertical">
+
+    <TextView
+        android:id="@+id/sample_text"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:gravity="center|top"
+        tools:text="FragmentA@12345" />
+
+</FrameLayout>
\ No newline at end of file
diff --git a/sample/src/main/res/layout/fragment_b_test.xml b/sample/src/main/res/layout/fragment_b_test.xml
new file mode 100644
index 00000000..0205e78c
--- /dev/null
+++ b/sample/src/main/res/layout/fragment_b_test.xml
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+<FrameLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    android:background="@android:color/holo_red_dark"
+    android:orientation="vertical">
+
+    <TextView
+        android:id="@+id/sample_text"
+        android:layout_width="match_parent"
+        android:layout_height="match_parent"
+        android:gravity="center|top"
+        tools:text="FragmentB@12345" />
+
+</FrameLayout>
\ No newline at end of file
diff --git a/sample/src/main/res/menu/menu_hello_world.xml b/sample/src/main/res/menu/menu_hello_world.xml
new file mode 100644
index 00000000..6c67dad2
--- /dev/null
+++ b/sample/src/main/res/menu/menu_hello_world.xml
@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<menu xmlns:android="http://schemas.android.com/apk/res/android">
+    <item
+        android:id="@+id/start_fragment_lifecycle_test"
+        android:title="@string/start_fragment_lifecycle_test" />
+    <item
+        android:id="@+id/start_viewpager_test"
+        android:title="Start viewpager test" />
+</menu>
\ No newline at end of file
diff --git a/sample/src/main/res/values/strings.xml b/sample/src/main/res/values/strings.xml
index 1ad8c299..e2d33c97 100644
--- a/sample/src/main/res/values/strings.xml
+++ b/sample/src/main/res/values/strings.xml
@@ -1,3 +1,16 @@
 <resources>
-    <string name="app_name">Sample</string>
+    <string name="app_name">ThirtyInch Sample</string>
+
+    <!-- Fragment lifecycle -->
+    <string name="start_fragment_lifecycle_test">Start fragment lifecycle test</string>
+    <string name="add_fragment_a">Add Fragment A</string>
+    <string name="remove_fragment_a">Remove Fragment A</string>
+    <string name="add_fragment_b">Add Fragment B</string>
+    <string name="detach_attach_again">Fragment Detach/Attach again</string>
+    <string name="recreate_activity">Recreate Activity</string>
+    <string name="finish_activity">Finish Activity</string>
+    <string name="dont_keep_activities_enabled">Don\'t keep activities enabled</string>
+    <string name="dont_keep_activities_disabled">Don\'t keep activities disabled</string>
+    <string name="retain_presenter_instance">Retain presenter instance</string>
+    <string name="add_transaction_to_back_stack">Add transaction to back stack</string>
 </resources>
diff --git a/thirtyinch/src/androidTest/java/net/grandcentrix/thirtyinch/internal/TiActivityDelegateTest.java b/thirtyinch/src/androidTest/java/net/grandcentrix/thirtyinch/internal/TiActivityDelegateTest.java
deleted file mode 100644
index 257df224..00000000
--- a/thirtyinch/src/androidTest/java/net/grandcentrix/thirtyinch/internal/TiActivityDelegateTest.java
+++ /dev/null
@@ -1,276 +0,0 @@
-/*
- * Copyright (C) 2017 grandcentrix GmbH
- * 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.
- */
-
-package net.grandcentrix.thirtyinch.internal;
-
-import net.grandcentrix.thirtyinch.TiConfiguration;
-import net.grandcentrix.thirtyinch.TiPresenter;
-import net.grandcentrix.thirtyinch.TiView;
-
-import org.junit.Before;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-
-import android.os.Bundle;
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
-import android.support.test.runner.AndroidJUnit4;
-import android.test.suitebuilder.annotation.SmallTest;
-
-import java.util.concurrent.Executor;
-
-import static junit.framework.Assert.assertEquals;
-
-@RunWith(AndroidJUnit4.class)
-@SmallTest
-public class TiActivityDelegateTest {
-
-    private TiActivityDelegate mDelegate;
-
-    private boolean mIsActivityChangingConfigurations = false;
-
-    private boolean mIsActivityFinishing = false;
-
-    private boolean mIsDontKeepActivitiesEnabled = false;
-
-    private TiPresenter<TiView> mPresenter;
-
-    private TiPresenter<TiView> mRetainedPresenter;
-
-    @Before
-    public void setUp() throws Exception {
-        mDelegate = newDelegate();
-
-        mIsActivityFinishing = false;
-        mIsActivityChangingConfigurations = false;
-        mIsDontKeepActivitiesEnabled = false;
-    }
-
-    @Test
-    public void testDontKeepActivities_DontRecoverWithSavior() throws Exception {
-        mIsDontKeepActivitiesEnabled = true;
-
-        final TiPresenter firstPresenter = new TiPresenter(new TiConfiguration.Builder()
-                .setUseStaticSaviorToRetain(false)
-                .build()) {
-        };
-        final TiPresenter secondPresenter = new TiPresenter(new TiConfiguration.Builder()
-                .setUseStaticSaviorToRetain(false)
-                .build()) {
-        };
-        mPresenter = firstPresenter;
-
-        mDelegate.onCreate_afterSuper(null);
-
-        assertEquals(TiPresenter.State.VIEW_DETACHED, mPresenter.getState());
-
-        mDelegate.onDestroy_afterSuper();
-        assertEquals(TiPresenter.State.DESTROYED, mPresenter.getState());
-
-        // don't reuse the old presenter
-        mPresenter = secondPresenter;
-        mDelegate = newDelegate();
-        mDelegate.onCreate_afterSuper(new Bundle());
-        assertEquals(secondPresenter, mDelegate.getPresenter());
-    }
-
-    @Test
-    public void testDontKeepActivities_RecoverWithSavior() throws Exception {
-        mIsDontKeepActivitiesEnabled = true;
-
-        final TiPresenter firstPresenter = new TiPresenter(new TiConfiguration.Builder()
-                .setUseStaticSaviorToRetain(true)
-                .build()) {
-        };
-        final TiPresenter secondPresenter = new TiPresenter(new TiConfiguration.Builder()
-                .setUseStaticSaviorToRetain(true)
-                .build()) {
-        };
-        mPresenter = firstPresenter;
-        mDelegate.onCreate_afterSuper(null);
-
-        assertEquals(TiPresenter.State.VIEW_DETACHED, mPresenter.getState());
-
-        final Bundle bundle = new Bundle();
-        mDelegate.onSaveInstanceState_afterSuper(bundle);
-
-        mDelegate.onDestroy_afterSuper();
-        assertEquals(TiPresenter.State.VIEW_DETACHED, mPresenter.getState());
-
-        mPresenter = secondPresenter;
-        mDelegate = newDelegate();
-
-        // check reuse of old presenter
-        mDelegate.onCreate_afterSuper(bundle);
-        assertEquals(firstPresenter, mDelegate.getPresenter());
-    }
-
-    @Test
-    public void testRestorePresenter_withNonConfigurationInstance() throws Exception {
-        final TiPresenter firstPresenter = new TiPresenter(new TiConfiguration.Builder()
-                .setUseStaticSaviorToRetain(false)
-                .build()) {
-        };
-        final TiPresenter secondPresenter = new TiPresenter(new TiConfiguration.Builder()
-                .setUseStaticSaviorToRetain(false)
-                .build()) {
-        };
-        mPresenter = firstPresenter;
-
-        mDelegate.onCreate_afterSuper(null);
-
-        assertEquals(TiPresenter.State.VIEW_DETACHED, mPresenter.getState());
-
-        final Bundle bundle = new Bundle();
-        mDelegate.onSaveInstanceState_afterSuper(bundle);
-
-        mDelegate.onDestroy_afterSuper();
-        assertEquals(TiPresenter.State.VIEW_DETACHED, mPresenter.getState());
-
-        mPresenter = secondPresenter;
-        mDelegate = newDelegate();
-
-        // set presenter to retain
-        mRetainedPresenter = firstPresenter;
-
-        // check reuse of old presenter
-        mDelegate.onCreate_afterSuper(bundle);
-        assertEquals(firstPresenter, mDelegate.getPresenter());
-    }
-
-    @Test
-    public void testRestorePresenter_withSavior() throws Exception {
-        final TiPresenter firstPresenter = new TiPresenter(new TiConfiguration.Builder()
-                .setUseStaticSaviorToRetain(true)
-                .build()) {
-        };
-        final TiPresenter secondPresenter = new TiPresenter(new TiConfiguration.Builder()
-                .setUseStaticSaviorToRetain(true)
-                .build()) {
-        };
-        mPresenter = firstPresenter;
-
-        mDelegate.onCreate_afterSuper(null);
-
-        assertEquals(TiPresenter.State.VIEW_DETACHED, mPresenter.getState());
-
-        final Bundle bundle = new Bundle();
-        mDelegate.onSaveInstanceState_afterSuper(bundle);
-
-        mDelegate.onDestroy_afterSuper();
-        assertEquals(TiPresenter.State.VIEW_DETACHED, mPresenter.getState());
-
-        mPresenter = secondPresenter;
-
-        // check reuse of old presenter
-        mDelegate.onCreate_afterSuper(bundle);
-        assertEquals(firstPresenter, mDelegate.getPresenter());
-
-        // new one got NOT created
-        assertEquals(TiPresenter.State.INITIALIZED, mPresenter.getState());
-    }
-
-    @Test
-    public void testRestorePresenter_withSavior_whichIsDisabled() throws Exception {
-        final TiPresenter firstPresenter = new TiPresenter(new TiConfiguration.Builder()
-                .setUseStaticSaviorToRetain(false)
-                .build()) {
-        };
-        final TiPresenter secondPresenter = new TiPresenter(new TiConfiguration.Builder()
-                .setUseStaticSaviorToRetain(false)
-                .build()) {
-        };
-        mPresenter = firstPresenter;
-
-        mDelegate.onCreate_afterSuper(null);
-
-        assertEquals(TiPresenter.State.VIEW_DETACHED, mPresenter.getState());
-
-        final Bundle bundle = new Bundle();
-        mDelegate.onSaveInstanceState_afterSuper(bundle);
-
-        mDelegate.onDestroy_afterSuper();
-        assertEquals(TiPresenter.State.VIEW_DETACHED, mPresenter.getState());
-
-        mPresenter = secondPresenter;
-
-        // check reuse of old presenter
-        mDelegate.onCreate_afterSuper(bundle);
-        assertEquals(secondPresenter, mDelegate.getPresenter());
-
-        // new one got created
-        assertEquals(TiPresenter.State.VIEW_DETACHED, mPresenter.getState());
-    }
-
-    @NonNull
-    private TiActivityDelegate newDelegate() {
-        return new TiActivityDelegate<>(
-                new DelegatedTiActivity<TiPresenter<TiView>>() {
-
-                    @Nullable
-                    @Override
-                    public TiPresenter<TiView> getRetainedPresenter() {
-                        return mRetainedPresenter;
-                    }
-
-                    @Override
-                    public boolean isActivityChangingConfigurations() {
-                        return mIsActivityChangingConfigurations;
-                    }
-
-                    @Override
-                    public boolean isActivityFinishing() {
-                        return mIsActivityFinishing;
-                    }
-
-                    @Override
-                    public boolean isDontKeepActivitiesEnabled() {
-                        return mIsDontKeepActivitiesEnabled;
-                    }
-
-                    @Override
-                    public Executor getUiThreadExecutor() {
-                        return new Executor() {
-                            @Override
-                            public void execute(@NonNull final Runnable action) {
-                                action.run();
-                            }
-                        };
-                    }
-                },
-                new TiViewProvider<TiView>() {
-                    @NonNull
-                    @Override
-                    public TiView provideView() {
-                        return new TiView() {
-                        };
-                    }
-                },
-                new TiPresenterProvider<TiPresenter<TiView>>() {
-                    @NonNull
-                    @Override
-                    public TiPresenter<TiView> providePresenter() {
-                        return mPresenter;
-                    }
-                },
-                new TiLoggingTagProvider() {
-                    @Override
-                    public String getLoggingTag() {
-                        return "TestTag";
-                    }
-                },
-        PresenterSavior.INSTANCE);
-    }
-}
diff --git a/thirtyinch/src/main/java/android/support/v4/app/BackstackReader.java b/thirtyinch/src/main/java/android/support/v4/app/BackstackReader.java
new file mode 100644
index 00000000..da3a3396
--- /dev/null
+++ b/thirtyinch/src/main/java/android/support/v4/app/BackstackReader.java
@@ -0,0 +1,21 @@
+package android.support.v4.app;
+
+/**
+ * Reads package private information about the {@link FragmentManager} backstack
+ *
+ * Thanks Hannes ;)
+ */
+public class BackstackReader {
+
+    /**
+     * Checks whether or not a given fragment is on the backstack of the fragment manager (could
+     * also be on top of the backstack and hence visible)
+     *
+     * @param fragment The fragment you want to check if its on the back stack
+     * @return true, if the given Fragment is on the back stack, otherwise false (not on the back
+     * stack)
+     */
+    public static boolean isInBackStack(final Fragment fragment) {
+        return fragment.isInBackStack();
+    }
+}
diff --git a/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/TiActivity.java b/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/TiActivity.java
index 2cbe5932..c971060f 100644
--- a/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/TiActivity.java
+++ b/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/TiActivity.java
@@ -18,16 +18,15 @@
 import net.grandcentrix.thirtyinch.internal.DelegatedTiActivity;
 import net.grandcentrix.thirtyinch.internal.InterceptableViewBinder;
 import net.grandcentrix.thirtyinch.internal.PresenterAccessor;
-import net.grandcentrix.thirtyinch.internal.PresenterNonConfigurationInstance;
 import net.grandcentrix.thirtyinch.internal.PresenterSavior;
 import net.grandcentrix.thirtyinch.internal.TiActivityDelegate;
 import net.grandcentrix.thirtyinch.internal.TiLoggingTagProvider;
 import net.grandcentrix.thirtyinch.internal.TiPresenterProvider;
 import net.grandcentrix.thirtyinch.internal.TiViewProvider;
 import net.grandcentrix.thirtyinch.internal.UiThreadExecutor;
-import net.grandcentrix.thirtyinch.util.AndroidDeveloperOptions;
 import net.grandcentrix.thirtyinch.util.AnnotationUtil;
 
+import android.app.Activity;
 import android.content.res.Configuration;
 import android.os.Bundle;
 import android.support.annotation.CallSuper;
@@ -39,7 +38,53 @@
 import java.util.concurrent.Executor;
 
 /**
- * Created by pascalwelsch on 9/8/15.
+ * An Activity which has a {@link TiPresenter} to build the Model View Presenter architecture on
+ * Android.
+ *
+ * <p>
+ * The {@link TiPresenter} will be created in {@link #providePresenter()} called in
+ * {@link #onCreate(Bundle)}. Depending on the {@link TiConfiguration} passed into the
+ * {@link TiPresenter#TiPresenter(TiConfiguration)} constructor the {@link TiPresenter} survives
+ * orientation changes (default).
+ * </p>
+ * <p>
+ * The {@link TiPresenter} requires a interface to communicate with the View. Normally the Activity
+ * implements the View interface (which must extend {@link TiView}) and is returned by default
+ * from {@link #provideView()}.
+ * </p>
+ *
+ * <p>
+ * Example:
+ * <code>
+ * <pre>
+ * public class MyActivity extends TiActivity&lt;MyPresenter, MyView&gt; implements MyView {
+ *
+ *     &#064;Override
+ *     public MyPresenter providePresenter() {
+ *         return new MyPresenter();
+ *     }
+ * }
+ *
+ * public class MyPresenter extends TiPresenter&lt;MyView&gt; {
+ *
+ *     &#064;Override
+ *     protected void onCreate() {
+ *         super.onCreate();
+ *     }
+ * }
+ *
+ * public interface MyView extends TiView {
+ *
+ *     // void showItems(List&lt;Item&gt; items);
+ *
+ *     // Observable&lt;Item&gt; onItemClicked();
+ * }
+ * </pre>
+ * </code>
+ * </p>
+ *
+ * @param <V> the View type, must implement {@link TiView}
+ * @param <P> the Presenter type, must extend {@link TiPresenter<V>}
  */
 public abstract class TiActivity<P extends TiPresenter<V>, V extends TiView>
         extends AppCompatActivity
@@ -51,7 +96,7 @@ public abstract class TiActivity<P extends TiPresenter<V>, V extends TiView>
             + "@" + Integer.toHexString(this.hashCode());
 
     private final TiActivityDelegate<P, V> mDelegate
-            = new TiActivityDelegate<>(this, this, this, this, PresenterSavior.INSTANCE);
+            = new TiActivityDelegate<>(this, this, this, this, PresenterSavior.getInstance());
 
     private final UiThreadExecutor mUiThreadExecutor = new UiThreadExecutor();
 
@@ -61,6 +106,11 @@ public final Removable addBindViewInterceptor(@NonNull final BindViewInterceptor
         return mDelegate.addBindViewInterceptor(interceptor);
     }
 
+    @Override
+    public Activity getHostingActivity() {
+        return this;
+    }
+
     @Nullable
     @Override
     public final V getInterceptedViewOf(@NonNull final BindViewInterceptor interceptor) {
@@ -87,20 +137,6 @@ public final P getPresenter() {
         return mDelegate.getPresenter();
     }
 
-    @SuppressWarnings("unchecked")
-    @Nullable
-    @Override
-    public final P getRetainedPresenter() {
-        // try recover presenter via lastNonConfigurationInstance
-        // this works most of the time
-        final Object nci = getLastCustomNonConfigurationInstance();
-        if (nci instanceof PresenterNonConfigurationInstance) {
-            final PresenterNonConfigurationInstance pnci = (PresenterNonConfigurationInstance) nci;
-            return (P) pnci.getPresenter();
-        }
-        return null;
-    }
-
     @Override
     public final Executor getUiThreadExecutor() {
         return mUiThreadExecutor;
@@ -125,11 +161,6 @@ public final boolean isActivityFinishing() {
         return isFinishing();
     }
 
-    @Override
-    public final boolean isDontKeepActivitiesEnabled() {
-        return AndroidDeveloperOptions.isDontKeepActivitiesEnabled(this);
-    }
-
     @CallSuper
     @Override
     public void onConfigurationChanged(final Configuration newConfig) {
@@ -137,23 +168,6 @@ public void onConfigurationChanged(final Configuration newConfig) {
         mDelegate.onConfigurationChanged_afterSuper(newConfig);
     }
 
-    @Nullable
-    @CallSuper
-    @Override
-    public Object onRetainCustomNonConfigurationInstance() {
-        final P presenter = mDelegate.getPresenter();
-        if (presenter == null) {
-            return null;
-        }
-
-        if (presenter.getConfig().shouldRetainPresenter()) {
-            return new PresenterNonConfigurationInstance<>(presenter,
-                    super.onRetainCustomNonConfigurationInstance());
-        }
-
-        return null;
-    }
-
     @SuppressWarnings("unchecked")
     @NonNull
     @Override
diff --git a/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/TiConfiguration.java b/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/TiConfiguration.java
index 7caecc61..9ec7ddf5 100644
--- a/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/TiConfiguration.java
+++ b/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/TiConfiguration.java
@@ -23,7 +23,6 @@
 import android.app.Activity;
 import android.app.Application;
 import android.os.Bundle;
-import android.support.v7.app.AppCompatActivity;
 
 /**
  * Configure how ThirtyInch should handle the {@link TiPresenter}.
@@ -37,7 +36,6 @@
  *     super(new TiConfiguration.Builder()
  *     .setCallOnMainThreadInterceptorEnabled(true)
  *     .setDistinctUntilChangedInterceptorEnabled(true)
- *     .setUseStaticSaviorToRetain(true)
  *     .setRetainPresenterEnabled(true)
  *     .build());
  * }
@@ -173,28 +171,15 @@ public Builder setRetainPresenterEnabled(final boolean enabled) {
         }
 
         /**
-         * Sets whether the {@link PresenterSavior} singleton should be used to restore the {@link
-         * TiPresenter}. This was a workaround targeting the "Don't keep
-         * activities" option in the Android Developer options destroying every activity as soon as
-         * the user leaves it.
-         * The "good" android way of saving the {@link TiPresenter} with {@link
-         * AppCompatActivity#onRetainCustomNonConfigurationInstance()} does not work when the
-         * option is enabled.
-         * The {@link PresenterSavior} works even if the option is enabled.
+         * Deprecated: The savior will be always used when {@code setRetainPresenterEnabled(true)}.
+         * Setting this property has no effect and will removed in the next version
          * <p>
-         * Some people argue that singletons are bad and want to be a good android citizen. This
-         * method is for you.
-         * Set it to <code>false</code> and the singleton will not be used. You
-         * are responsible when you lose data because a new {@link TiPresenter} instance will be
-         * created.
-         * <p>
-         * This option will not be used when {@link #setRetainPresenterEnabled(boolean)} is set to
-         * <code>false</code>.
-         * <p>
-         * default <code>true</code>
+         * Was a property whether the {@link PresenterSavior} singleton should be used to restore
+         * the {@link TiPresenter}.
+         * </p>
          */
+        @Deprecated
         public Builder setUseStaticSaviorToRetain(final boolean enabled) {
-            mConfig.mUseStaticSaviorToRetain = enabled;
             return this;
         }
 
@@ -208,14 +193,42 @@ public Builder setUseStaticSaviorToRetain(final boolean enabled) {
 
     private boolean mRetainPresenter = true;
 
-    private boolean mUseStaticSaviorToRetain = true;
-
     /**
      * use {@link Builder} to construct a configuration.
      */
     private TiConfiguration() {
     }
 
+    @Override
+    public boolean equals(final Object o) {
+        if (this == o) {
+            return true;
+        }
+        if (!(o instanceof TiConfiguration)) {
+            return false;
+        }
+
+        final TiConfiguration that = (TiConfiguration) o;
+
+        if (mCallOnMainThreadInterceptorEnabled != that.mCallOnMainThreadInterceptorEnabled) {
+            return false;
+        }
+        if (mDistinctUntilChangedInterceptorEnabled
+                != that.mDistinctUntilChangedInterceptorEnabled) {
+            return false;
+        }
+        return mRetainPresenter == that.mRetainPresenter;
+
+    }
+
+    @Override
+    public int hashCode() {
+        int result = (mCallOnMainThreadInterceptorEnabled ? 1 : 0);
+        result = 31 * result + (mDistinctUntilChangedInterceptorEnabled ? 1 : 0);
+        result = 31 * result + (mRetainPresenter ? 1 : 0);
+        return result;
+    }
+
     public boolean isCallOnMainThreadInterceptorEnabled() {
         return mCallOnMainThreadInterceptorEnabled;
     }
@@ -227,8 +240,4 @@ public boolean isDistinctUntilChangedInterceptorEnabled() {
     public boolean shouldRetainPresenter() {
         return mRetainPresenter;
     }
-
-    public boolean useStaticSaviorToRetain() {
-        return mUseStaticSaviorToRetain;
-    }
 }
diff --git a/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/TiDialogFragment.java b/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/TiDialogFragment.java
index d558d6ca..5738de56 100644
--- a/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/TiDialogFragment.java
+++ b/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/TiDialogFragment.java
@@ -24,7 +24,6 @@
 import net.grandcentrix.thirtyinch.internal.TiPresenterProvider;
 import net.grandcentrix.thirtyinch.internal.TiViewProvider;
 import net.grandcentrix.thirtyinch.internal.UiThreadExecutor;
-import net.grandcentrix.thirtyinch.util.AndroidDeveloperOptions;
 import net.grandcentrix.thirtyinch.util.AnnotationUtil;
 
 import android.os.Bundle;
@@ -49,7 +48,7 @@ public abstract class TiDialogFragment<P extends TiPresenter<V>, V extends TiVie
             + "@" + Integer.toHexString(this.hashCode());
 
     private final TiFragmentDelegate<P, V> mDelegate =
-            new TiFragmentDelegate<>(this, this, this, this, PresenterSavior.INSTANCE);
+            new TiFragmentDelegate<>(this, this, this, this, PresenterSavior.getInstance());
 
     @NonNull
     @Override
@@ -94,11 +93,6 @@ public final void invalidateView() {
         mDelegate.invalidateView();
     }
 
-    @Override
-    public final boolean isDontKeepActivitiesEnabled() {
-        return AndroidDeveloperOptions.isDontKeepActivitiesEnabled(getActivity());
-    }
-
     @Override
     public final boolean isFragmentAdded() {
         return isAdded();
@@ -199,11 +193,6 @@ public V provideView() {
         }
     }
 
-    @Override
-    public final void setFragmentRetainInstance(final boolean retain) {
-        setRetainInstance(retain);
-    }
-
     @Override
     public String toString() {
         String presenter = getPresenter() == null ? "null" :
diff --git a/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/TiFragment.java b/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/TiFragment.java
index 8f5b9216..10fcde9e 100644
--- a/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/TiFragment.java
+++ b/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/TiFragment.java
@@ -24,14 +24,17 @@
 import net.grandcentrix.thirtyinch.internal.TiPresenterProvider;
 import net.grandcentrix.thirtyinch.internal.TiViewProvider;
 import net.grandcentrix.thirtyinch.internal.UiThreadExecutor;
-import net.grandcentrix.thirtyinch.util.AndroidDeveloperOptions;
 import net.grandcentrix.thirtyinch.util.AnnotationUtil;
 
+import android.app.Activity;
 import android.os.Bundle;
 import android.support.annotation.CallSuper;
 import android.support.annotation.NonNull;
 import android.support.annotation.Nullable;
+import android.support.v4.app.BackstackReader;
 import android.support.v4.app.Fragment;
+import android.support.v4.app.FragmentManager;
+import android.support.v4.app.FragmentTransaction;
 import android.view.LayoutInflater;
 import android.view.View;
 import android.view.ViewGroup;
@@ -39,6 +42,72 @@
 import java.util.List;
 import java.util.concurrent.Executor;
 
+/**
+ * An Fragment which has a {@link TiPresenter} to build the Model View Presenter architecture on
+ * Android.
+ *
+ * <p>
+ * The {@link TiPresenter} will be created in {@link #providePresenter()} called in
+ * {@link #onCreate(Bundle)}. Depending on the {@link TiConfiguration} passed into the
+ * {@link TiPresenter#TiPresenter(TiConfiguration)} constructor the {@link TiPresenter} survives
+ * orientation changes (default).
+ * </p>
+ * <p>
+ * The {@link TiPresenter} requires a interface to communicate with the View. Normally the Activity
+ * implements the View interface (which must extend {@link TiView}) and is returned by default
+ * from {@link #provideView()}.
+ * </p>
+ * <p>
+ * The associated {@link TiPresenter} only lives when the {@link TiFragment} is added to the
+ * {@link FragmentManager}. When {@link FragmentTransaction#remove(Fragment)} or {@link
+ * FragmentTransaction#replace(int, Fragment)} results in removing this {@link TiFragment} from the
+ * {@link FragmentManager} the {@link TiPresenter} gets destroyed. When the same {@link TiFragment}
+ * instance will be added again a new {@link TiPresenter} will be created by calling {@link
+ * #providePresenter()}.
+ * </p>
+ * <p>
+ * The {@link TiPresenter} even survives when the {@link TiFragment} is in the
+ * {@link FragmentManager} backstack. When the hosting Activity gets finished the
+ * {@link TiPresenter} will be destroyed accordingly.
+ * </p>
+ * <p>
+ * Using {@code setRetainInstance(true)} is not allowed as it causes many troubles. You should favor
+ * the dumb view pattern and move all your state into the {@link TiPresenter}.
+ * </p>
+ *
+ * <p>
+ * Example:
+ * <code>
+ * <pre>
+ * public class MyFragment extends TiFragment&lt;MyPresenter, MyView&gt; implements MyView {
+ *
+ *     &#064;Override
+ *     public MyPresenter providePresenter() {
+ *         return new MyPresenter();
+ *     }
+ * }
+ *
+ * public class MyPresenter extends TiPresenter&lt;MyView&gt; {
+ *
+ *     &#064;Override
+ *     protected void onCreate() {
+ *         super.onCreate();
+ *     }
+ * }
+ *
+ * public interface MyView extends TiView {
+ *
+ *     // void showItems(List&lt;Item&gt; items);
+ *
+ *     // Observable&lt;Item&gt; onItemClicked();
+ * }
+ * </pre>
+ * </code>
+ * </p>
+ *
+ * @param <V> the View type, must implement {@link TiView}
+ * @param <P> the Presenter type, must extend {@link TiPresenter<V>}
+ */
 public abstract class TiFragment<P extends TiPresenter<V>, V extends TiView> extends Fragment
         implements DelegatedTiFragment, TiPresenterProvider<P>, TiLoggingTagProvider,
         TiViewProvider<V>, InterceptableViewBinder<V>, PresenterAccessor<P, V> {
@@ -48,7 +117,7 @@ public abstract class TiFragment<P extends TiPresenter<V>, V extends TiView> ext
             + "@" + Integer.toHexString(this.hashCode());
 
     private final TiFragmentDelegate<P, V> mDelegate =
-            new TiFragmentDelegate<>(this, this, this, this, PresenterSavior.INSTANCE);
+            new TiFragmentDelegate<>(this, this, this, this, PresenterSavior.getInstance());
 
     private final UiThreadExecutor mUiThreadExecutor = new UiThreadExecutor();
 
@@ -58,6 +127,11 @@ public final Removable addBindViewInterceptor(@NonNull final BindViewInterceptor
         return mDelegate.addBindViewInterceptor(interceptor);
     }
 
+    @Override
+    public Activity getHostingActivity() {
+        return getActivity();
+    }
+
     @Nullable
     @Override
     public final V getInterceptedViewOf(@NonNull final BindViewInterceptor interceptor) {
@@ -98,11 +172,6 @@ public final void invalidateView() {
         mDelegate.invalidateView();
     }
 
-    @Override
-    public final boolean isDontKeepActivitiesEnabled() {
-        return AndroidDeveloperOptions.isDontKeepActivitiesEnabled(getActivity());
-    }
-
     @Override
     public final boolean isFragmentAdded() {
         return isAdded();
@@ -113,6 +182,11 @@ public final boolean isFragmentDetached() {
         return isDetached();
     }
 
+    @Override
+    public boolean isFragmentRemoving() {
+        return isRemoving();
+    }
+
     @Override
     public final boolean isHostingActivityChangingConfigurations() {
         return getActivity().isChangingConfigurations();
@@ -123,6 +197,11 @@ public final boolean isHostingActivityFinishing() {
         return getActivity().isFinishing();
     }
 
+    @Override
+    public boolean isFragmentInBackstack() {
+        return BackstackReader.isInBackStack(this);
+    }
+
     @CallSuper
     @Override
     public void onCreate(final Bundle savedInstanceState) {
@@ -203,9 +282,17 @@ public V provideView() {
         }
     }
 
+    /**
+     * Don't use <code>setRetainInstance(true)</code>, it's designed for headless Fragments only.
+     */
     @Override
-    public final void setFragmentRetainInstance(final boolean retain) {
-        setRetainInstance(retain);
+    public void setRetainInstance(final boolean retain) {
+        if (retain) {
+            throw new IllegalStateException("Retaining TiFragment is not allowed. "
+                    + "setRetainInstance(true) should only be used for headless Fragments. "
+                    + "Move your state into the TiPresenter which survives recreation of TiFragment");
+        }
+        super.setRetainInstance(retain);
     }
 
     @Override
diff --git a/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/TiPresenter.java b/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/TiPresenter.java
index 4ff8ca00..7b8d90b3 100644
--- a/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/TiPresenter.java
+++ b/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/TiPresenter.java
@@ -232,7 +232,7 @@ public final void create() {
      */
     public final void destroy() {
         if (!isInitialized() || isDestroyed()) {
-            TiLog.w(TAG, "not calling onDestroy(), destroy was already called");
+            TiLog.v(TAG, "not calling onDestroy(), destroy was already called");
             return;
         }
 
diff --git a/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/internal/ActivityInstanceObserver.java b/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/internal/ActivityInstanceObserver.java
new file mode 100644
index 00000000..132b7cfb
--- /dev/null
+++ b/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/internal/ActivityInstanceObserver.java
@@ -0,0 +1,147 @@
+/*
+ * Copyright (C) 2017 grandcentrix GmbH
+ * 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.
+ */
+
+package net.grandcentrix.thirtyinch.internal;
+
+
+import net.grandcentrix.thirtyinch.TiLog;
+
+import android.app.Activity;
+import android.app.Application;
+import android.os.Bundle;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.support.annotation.VisibleForTesting;
+
+import java.util.HashMap;
+import java.util.UUID;
+
+/**
+ * Keeps track of {@link Activity}s across orientation changes using a unique id when added via
+ * {@link #startTracking(Activity)}. When the {@link Activity} finishes the {@link Listener} is
+ * triggered.
+ */
+public class ActivityInstanceObserver implements Application.ActivityLifecycleCallbacks {
+
+    /**
+     * Callback when an {@link Activity} will be completely destroyed
+     */
+    public interface Listener {
+
+        /**
+         * called when the {@link Activity} finishes completely. Doesn't get called when the
+         * Activity changes its configuration
+         */
+        void onActivityFinished(final Activity activity, final String activityId);
+    }
+
+    @VisibleForTesting
+    static final String TI_ACTIVITY_ID_KEY = "ThirtyInch_Activity_id";
+
+    private static final String TAG = ActivityInstanceObserver.class.getSimpleName();
+
+    private Listener mListener;
+
+    private final HashMap<Activity, String> mScopeIdForActivity = new HashMap<>();
+
+    public ActivityInstanceObserver(@NonNull final Listener listener) {
+        mListener = listener;
+    }
+
+    /**
+     * Returns the id created with {@link #startTracking(Activity)}
+     *
+     * @return a unique id for each {@link Activity} which doesn't change when the {@link Activity}
+     * changes its configuration
+     */
+    @Nullable
+    public String getActivityId(final Activity activity) {
+        return mScopeIdForActivity.get(activity);
+    }
+
+    @Override
+    public void onActivityCreated(final Activity activity, final Bundle savedInstanceState) {
+        if (savedInstanceState != null) {
+            final String scopeId = savedInstanceState.getString(TI_ACTIVITY_ID_KEY);
+            if (scopeId != null) {
+                // refresh mapping
+                mScopeIdForActivity.put(activity, scopeId);
+            }
+        }
+    }
+
+    @Override
+    public void onActivityDestroyed(final Activity activity) {
+        TiLog.v(TAG, "destroying " + activity);
+        TiLog.v(TAG, "isFinishing = " + activity.isFinishing());
+        TiLog.v(TAG, "isChangingConfigurations = " + activity.isChangingConfigurations());
+
+        if (activity.isFinishing() && !activity.isChangingConfigurations()) {
+            // detected Activity finish, no new Activity instance will be created
+            // with savedInstanceState, clear saved presenters
+            final String scopeId = mScopeIdForActivity.remove(activity);
+            mListener.onActivityFinished(activity, scopeId);
+        } else {
+            // don't leak old activity instances
+            // scopeId is saved in savedInstanceState of finishing Activity.
+            mScopeIdForActivity.remove(activity);
+        }
+    }
+
+    @Override
+    public void onActivityPaused(final Activity activity) {
+        // noop
+    }
+
+    @Override
+    public void onActivityResumed(final Activity activity) {
+        // noop
+    }
+
+    @Override
+    public void onActivitySaveInstanceState(final Activity activity, final Bundle outState) {
+        String id = mScopeIdForActivity.get(activity);
+        if (id == null) {
+            // activity not managed, don't add an id.
+            return;
+        }
+        outState.putString(TI_ACTIVITY_ID_KEY, id);
+    }
+
+    @Override
+    public void onActivityStarted(final Activity activity) {
+        // noop
+    }
+
+    @Override
+    public void onActivityStopped(final Activity activity) {
+        // noop
+    }
+
+    /**
+     * tracks the Activity over orientation changes using a unique id. Use
+     * {@link #getActivityId(Activity)} to get the current Activity instance with the id returned
+     * from this method
+     *
+     * @param activity to be tracked {@link Activity}
+     * @return a unique id for this Activity
+     * @see #getActivityId(Activity)
+     */
+    public String startTracking(final Activity activity) {
+        final String activityId = UUID.randomUUID().toString();
+        mScopeIdForActivity.put(activity, activityId);
+        return activityId;
+    }
+}
diff --git a/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/internal/ActivityScopedPresenters.java b/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/internal/ActivityScopedPresenters.java
new file mode 100644
index 00000000..b6728791
--- /dev/null
+++ b/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/internal/ActivityScopedPresenters.java
@@ -0,0 +1,72 @@
+/*
+ * Copyright (C) 2017 grandcentrix GmbH
+ * 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.
+ */
+
+package net.grandcentrix.thirtyinch.internal;
+
+
+import net.grandcentrix.thirtyinch.TiLog;
+import net.grandcentrix.thirtyinch.TiPresenter;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+/**
+ * Simple wrapper around a {@link HashMap} to save {@link TiPresenter} by id. For every {@link
+ * android.app.Activity} containing a {@link TiPresenter} a corresponding {@link
+ * ActivityScopedPresenters} will be created. It contains the {@link TiPresenter} of the Activity
+ * itself and of all of its Fragments.
+ */
+public class ActivityScopedPresenters {
+
+    private final String TAG = ActivityScopedPresenters.class.getSimpleName()
+            + "@" + Integer.toHexString(hashCode());
+
+    private final HashMap<String, TiPresenter> mStore = new HashMap<>();
+
+    public TiPresenter get(final String id) {
+        return mStore.get(id);
+    }
+
+    public List<TiPresenter> getAll() {
+        return Collections.unmodifiableList(new ArrayList<>(mStore.values()));
+    }
+
+    public List<Map.Entry<String, TiPresenter>> getAllMappings() {
+        return Collections.unmodifiableList(new ArrayList<>(mStore.entrySet()));
+    }
+
+    public boolean isEmpty() {
+        return mStore.isEmpty();
+    }
+
+    public TiPresenter remove(final String id) {
+        final TiPresenter presenter = mStore.remove(id);
+        TiLog.d(TAG, "remove " + id + " " + presenter);
+        return presenter;
+    }
+
+    public void save(final String id, final TiPresenter presenter) {
+        TiLog.d(TAG, "save " + id + " " + presenter);
+        mStore.put(id, presenter);
+    }
+
+    public int size() {
+        return mStore.size();
+    }
+
+}
diff --git a/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/internal/DelegatedTiActivity.java b/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/internal/DelegatedTiActivity.java
index 00f76680..560ca3be 100644
--- a/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/internal/DelegatedTiActivity.java
+++ b/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/internal/DelegatedTiActivity.java
@@ -16,8 +16,6 @@
 package net.grandcentrix.thirtyinch.internal;
 
 import android.app.Activity;
-import android.support.annotation.Nullable;
-import android.support.v7.app.AppCompatActivity;
 
 import java.util.concurrent.Executor;
 
@@ -27,13 +25,6 @@
  */
 public interface DelegatedTiActivity<P> {
 
-    /**
-     * @return the retained presenter from {@link AppCompatActivity#getLastCustomNonConfigurationInstance()}
-     * or equivalent implementations
-     */
-    @Nullable
-    P getRetainedPresenter();
-
     /**
      * @return {@link UiThreadExecutor}
      */
@@ -50,7 +41,7 @@ public interface DelegatedTiActivity<P> {
     boolean isActivityFinishing();
 
     /**
-     * @return true when the developer option "Don't keep Activities" is enabled
+     * @return the Activity itself instance
      */
-    boolean isDontKeepActivitiesEnabled();
+    Activity getHostingActivity();
 }
diff --git a/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/internal/DelegatedTiFragment.java b/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/internal/DelegatedTiFragment.java
index c8c636b8..b70576dd 100644
--- a/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/internal/DelegatedTiFragment.java
+++ b/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/internal/DelegatedTiFragment.java
@@ -27,11 +27,6 @@ public interface DelegatedTiFragment {
      */
     Executor getUiThreadExecutor();
 
-    /**
-     * @return true when the developer option "Don't keep Activities" is enabled
-     */
-    boolean isDontKeepActivitiesEnabled();
-
     /**
      * @return {@link Fragment#isAdded()}
      */
@@ -42,6 +37,11 @@ public interface DelegatedTiFragment {
      */
     boolean isFragmentDetached();
 
+    /**
+     * @return {@link Fragment#isRemoving()}
+     */
+    boolean isFragmentRemoving();
+
     /**
      * @return {@link Activity#isChangingConfigurations()}
      */
@@ -53,7 +53,13 @@ public interface DelegatedTiFragment {
     boolean isHostingActivityFinishing();
 
     /**
-     * Call {@link Fragment#setRetainInstance(boolean)}
+     * @return {@link Fragment#isInBackStack()}
      */
-    void setFragmentRetainInstance(final boolean retain);
+    boolean isFragmentInBackstack();
+
+    /**
+     * @return the hosting Activity
+     */
+    Activity getHostingActivity();
+
 }
diff --git a/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/internal/PresenterSavior.java b/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/internal/PresenterSavior.java
index 3ca76398..a682e18e 100644
--- a/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/internal/PresenterSavior.java
+++ b/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/internal/PresenterSavior.java
@@ -15,53 +15,235 @@
 
 package net.grandcentrix.thirtyinch.internal;
 
-import net.grandcentrix.thirtyinch.TiActivity;
 import net.grandcentrix.thirtyinch.TiLog;
 import net.grandcentrix.thirtyinch.TiPresenter;
 
+import android.app.Activity;
 import android.support.annotation.NonNull;
 import android.support.annotation.Nullable;
+import android.support.annotation.VisibleForTesting;
 
+import java.util.ArrayList;
 import java.util.HashMap;
+import java.util.Map;
 
 /**
- * Activities can be destroyed when the device runs out of memory. Sometimes it doesn't work to
- * save objects via {@code Activity#onRetainNonConfigurationInstance()} for example when the user
- * has enabled "Do not keep activities" in the developer options. This singleton holds strong
- * references to those presenters and returns them when needed.
- *
- * {@link TiActivity} is responsible to manage the references
+ * When a {@link TiPresenter} is created with
+ * {@link net.grandcentrix.thirtyinch.TiConfiguration.Builder#setRetainPresenterEnabled(boolean)}
+ * set to {@code true} this singleton is responsible to save the presenter across orientation
+ * changes. This works far better than {@link Activity#onRetainNonConfigurationInstance()} which
+ * doesn't work when "Don't keep Activities" is on.
+ * <p>
+ * {@link net.grandcentrix.thirtyinch.TiActivity} is able to detect when its presenter should be
+ * destroyed and tells this savior when to free a presenter instance.
+ * </p>
+ * <p>
+ * {@link net.grandcentrix.thirtyinch.TiFragment} can't detect on its own when its hosting Activity
+ * is about to finish to free its presenter. For example when the Presenter is in the backstack.
+ * This savior uses {@link android.app.Application.ActivityLifecycleCallbacks} to detect those
+ * cases
+ * and destroys and cleans the presenters to prevents leaks.
+ * </p>
  */
-public enum PresenterSavior implements TiPresenterSavior {
+public class PresenterSavior implements TiPresenterSavior, ActivityInstanceObserver.Listener {
 
-    INSTANCE;
+    private static PresenterSavior INSTANCE;
 
     private static final String TAG = PresenterSavior.class.getSimpleName();
 
-    private final HashMap<String, TiPresenter> mPresenters = new HashMap<>();
+    /**
+     * enable debug logging for testing
+     */
+    private static final boolean DEBUG = false;
+
+    @VisibleForTesting
+    ActivityInstanceObserver mActivityInstanceObserver;
+
+    /**
+     * Holds a scope for every Activity with one or more presenters. There is no direct mapping for
+     * {@link Activity} to {@link ActivityScopedPresenters} because Activity instances can be
+     * destroyed. The {@link ActivityInstanceObserver} takes care to manage unique Ids for each
+     * Activity which are used as keys here.
+     */
+    @VisibleForTesting
+    final HashMap<String, ActivityScopedPresenters> mScopes = new HashMap<>();
+
+    /**
+     * Access to the {@link PresenterSavior} singleton to save presenters across orientation changes
+     */
+    public static synchronized PresenterSavior getInstance() {
+        if (INSTANCE == null) {
+            INSTANCE = new PresenterSavior();
+        }
+        return INSTANCE;
+    }
+
+    @VisibleForTesting
+    PresenterSavior() {
+
+    }
 
     @Override
-    public void free(final String presenterId) {
-        mPresenters.remove(presenterId);
+    public void free(final String presenterId, @NonNull final Activity activity) {
+        final ActivityScopedPresenters scope = getScope(activity);
+        if (scope != null) {
+            scope.remove(presenterId);
+            if (scope.isEmpty()) {
+                String scopeId = mActivityInstanceObserver.getActivityId(activity);
+                if (scopeId != null) {
+                    mScopes.remove(scopeId);
+                }
+            }
+        }
+        unregisterActivityObserver(activity);
+
+        printRemainingPresenter();
+    }
+
+    @Override
+    public void onActivityFinished(final Activity activity, final String activityId) {
+        // First remove the scope, and don't leak it when the Activity got finished
+        final ActivityScopedPresenters scope = mScopes.remove(activityId);
+        unregisterActivityObserver(activity);
+
+        TiLog.d(TAG, "Activity is finishing, free remaining presenters " + activity);
+        if (scope != null) {
+            for (final Map.Entry<String, TiPresenter> entry : scope.getAllMappings()) {
+                final String presenterId = entry.getKey();
+                final TiPresenter presenter = entry.getValue();
+
+                // when the presenter is not destroyed yet, destroy it.
+                if (!presenter.isDestroyed()) {
+                    presenter.destroy();
+                }
+                scope.remove(presenterId);
+            }
+        }
+
+        printRemainingPresenter();
     }
 
     @Override
     @Nullable
-    public TiPresenter recover(final String presenterId) {
-        return mPresenters.get(presenterId);
+    public TiPresenter recover(final String presenterId, @NonNull final Activity activity) {
+        final ActivityScopedPresenters scope = getScope(activity);
+        if (scope == null) {
+            return null;
+        }
+        return scope.get(presenterId);
     }
 
     @Override
-    public String save(@NonNull final TiPresenter presenter) {
-        final String id = generateId(presenter);
-        TiLog.v(TAG, "save presenter with id " + id + " " + presenter);
-        mPresenters.put(id, presenter);
+    public String save(@NonNull final TiPresenter presenter, @NonNull final Activity activity) {
+        final String id = generatePresenterId(presenter);
+
+        final ActivityScopedPresenters scope = getScopeOrCreate(activity);
+        scope.save(id, presenter);
+        printRemainingPresenter();
+
         return id;
     }
 
-    private String generateId(@NonNull final TiPresenter presenter) {
+    private String generatePresenterId(@NonNull final TiPresenter presenter) {
         return presenter.getClass().getSimpleName()
                 + ":" + presenter.hashCode()
                 + ":" + System.nanoTime();
     }
+
+    /**
+     * retrieves an existing scope for a {@link Activity} but doesn't create on when the scope
+     * doesn't exist
+     */
+    @Nullable
+    private synchronized ActivityScopedPresenters getScope(final Activity activity) {
+        final ActivityInstanceObserver detector = mActivityInstanceObserver;
+        if (detector == null) {
+            return null;
+        }
+
+        final String scopeId = detector.getActivityId(activity);
+        if (scopeId == null) {
+            return null;
+        }
+
+        return mScopes.get(scopeId);
+    }
+
+    /**
+     * Returns an existing scope or creates a new one for the given Activity. Registers a callback
+     * so the scope will be cleaned up when the Activity finishes
+     *
+     * @return an existing or new created scope for presenters
+     */
+    @NonNull
+    private synchronized ActivityScopedPresenters getScopeOrCreate(final Activity activity) {
+        registerActivityObserver(activity);
+
+        final String scopeId = mActivityInstanceObserver.getActivityId(activity);
+        final ActivityScopedPresenters scope;
+
+        if (scopeId == null) {
+            final String newScopeId = mActivityInstanceObserver.startTracking(activity);
+            scope = new ActivityScopedPresenters();
+            mScopes.put(newScopeId, scope);
+        } else {
+            final ActivityScopedPresenters savedScope = mScopes.get(scopeId);
+            if (savedScope == null) {
+                scope = new ActivityScopedPresenters();
+                mScopes.put(scopeId, scope);
+            } else {
+                scope = savedScope;
+            }
+        }
+
+        return scope;
+    }
+
+    /**
+     * print all presenters saved in the savior for debug
+     *
+     * @see #DEBUG
+     */
+    private void printRemainingPresenter() {
+        if (DEBUG) {
+            final ArrayList<TiPresenter> presenters = new ArrayList<>();
+            for (final Map.Entry<String, ActivityScopedPresenters> entry : mScopes.entrySet()) {
+                presenters.addAll(entry.getValue().getAll());
+            }
+
+            TiLog.d(TAG, "presenter count: " + presenters.size());
+            for (final TiPresenter presenter : presenters) {
+                TiLog.v(TAG, " - " + presenter);
+            }
+        }
+    }
+
+    /**
+     * registers the {@link #mActivityInstanceObserver}
+     */
+    private void registerActivityObserver(final Activity activity) {
+        if (mActivityInstanceObserver == null) {
+            mActivityInstanceObserver = new ActivityInstanceObserver(this);
+            TiLog.v(TAG, "registering lifecycle callback");
+            activity.getApplication().registerActivityLifecycleCallbacks(mActivityInstanceObserver);
+        }
+    }
+
+    /**
+     * unregister {@link #mActivityInstanceObserver} when scopes are empty
+     */
+    private void unregisterActivityObserver(final Activity activity) {
+        if (mScopes.isEmpty()) {
+            // unregister detector because there are no presenters which could be recovered.
+            // next #save call will create a new one
+            if (mActivityInstanceObserver != null) {
+                if (DEBUG) {
+                    TiLog.v(TAG, "unregistering lifecycle callback");
+                }
+                activity.getApplication()
+                        .unregisterActivityLifecycleCallbacks(mActivityInstanceObserver);
+                mActivityInstanceObserver = null;
+            }
+        }
+    }
 }
diff --git a/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/internal/TiActivityDelegate.java b/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/internal/TiActivityDelegate.java
index 682c2c36..bd26d537 100644
--- a/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/internal/TiActivityDelegate.java
+++ b/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/internal/TiActivityDelegate.java
@@ -69,14 +69,14 @@ public class TiActivityDelegate<P extends TiPresenter<V>, V extends TiView>
 
     private final TiPresenterProvider<P> mPresenterProvider;
 
+    private final TiPresenterSavior mSavior;
+
     private final DelegatedTiActivity<P> mTiActivity;
 
     private Removable mUiThreadBinderRemovable;
 
     private final PresenterViewBinder<V> mViewBinder;
 
-    private final TiPresenterSavior mSavior;
-
     private final TiViewProvider<V> mViewProvider;
 
     public TiActivityDelegate(final DelegatedTiActivity<P> activityProvider,
@@ -133,21 +133,10 @@ public void onConfigurationChanged_afterSuper(final Configuration newConfig) {
     @SuppressWarnings("unchecked")
     public void onCreate_afterSuper(final Bundle savedInstanceState) {
 
-        // try recover presenter via lastNonConfigurationInstance
-        // this works most of the time
-        mPresenter = mTiActivity.getRetainedPresenter();
-        if (mPresenter == null) {
-            TiLog.v(mLogTag.getLoggingTag(),
-                    "could not recover a Presenter from getLastNonConfigurationInstance()");
-        } else {
-            TiLog.v(mLogTag.getLoggingTag(),
-                    "recovered Presenter from lastCustomNonConfigurationInstance " + mPresenter);
-        }
-
         // try to recover with the PresenterSavior
         if (savedInstanceState != null) {
-            final String recoveredPresenterId = savedInstanceState
-                    .getString(SAVED_STATE_PRESENTER_ID);
+            final String recoveredPresenterId =
+                    savedInstanceState.getString(SAVED_STATE_PRESENTER_ID);
 
             if (mPresenter == null) {
                 if (recoveredPresenterId != null) {
@@ -155,7 +144,8 @@ public void onCreate_afterSuper(final Bundle savedInstanceState) {
                     // this should always work.
                     TiLog.v(mLogTag.getLoggingTag(),
                             "try to recover Presenter with id: " + recoveredPresenterId);
-                    mPresenter = (P) mSavior.recover(recoveredPresenterId);
+                    mPresenter = (P) mSavior
+                            .recover(recoveredPresenterId, mTiActivity.getHostingActivity());
                     TiLog.v(mLogTag.getLoggingTag(),
                             "recovered Presenter from savior " + mPresenter);
                 } else {
@@ -171,18 +161,24 @@ public void onCreate_afterSuper(final Bundle savedInstanceState) {
                 // save recovered presenter with new id. No other instance of this activity,
                 // holding the presenter before, is now able to remove the reference to
                 // this presenter from the savior
-                mSavior.free(recoveredPresenterId);
-                mPresenterId = mSavior.save(mPresenter);
+                mSavior.free(recoveredPresenterId, mTiActivity.getHostingActivity());
+                mPresenterId = mSavior.save(mPresenter, mTiActivity.getHostingActivity());
             }
         }
 
         if (mPresenter == null) {
             // could not recover, create a new presenter
             mPresenter = mPresenterProvider.providePresenter();
+            if (mPresenter.getState() != TiPresenter.State.INITIALIZED) {
+                throw new IllegalStateException("Presenter not in initialized state. "
+                        + "Current state is " + mPresenter.getState() + ". "
+                        + "Presenter provided with #providePresenter() cannot be reused. "
+                        + "Always return a fresh instance!");
+            }
             TiLog.v(mLogTag.getLoggingTag(), "created Presenter: " + mPresenter);
             final TiConfiguration config = mPresenter.getConfig();
-            if (config.shouldRetainPresenter() && config.useStaticSaviorToRetain()) {
-                mPresenterId = mSavior.save(mPresenter);
+            if (config.shouldRetainPresenter()) {
+                mPresenterId = mSavior.save(mPresenter, mTiActivity.getHostingActivity());
             }
             mPresenter.create();
         }
@@ -212,11 +208,9 @@ public void onDestroy_afterSuper() {
             mUiThreadBinderRemovable = null;
         }
 
-        // destroy the presenter based on configuration
-        final TiConfiguration config = mPresenter.getConfig();
-
         boolean destroyPresenter = false;
-        if (mTiActivity.isActivityFinishing()) {
+        if (mTiActivity.isActivityFinishing()
+                && !mTiActivity.isActivityChangingConfigurations()) {
             // Probably a backpress and not a configuration change
             // Activity will not be recreated and finally destroyed, also destroyed the presenter
             destroyPresenter = true;
@@ -225,7 +219,7 @@ public void onDestroy_afterSuper() {
         }
 
         if (!destroyPresenter &&
-                !config.shouldRetainPresenter()) {
+                !mPresenter.getConfig().shouldRetainPresenter()) {
             // configuration says the presenter should not be retained, a new presenter instance
             // will be created and the current presenter should be destroyed
             destroyPresenter = true;
@@ -233,23 +227,9 @@ public void onDestroy_afterSuper() {
                     "presenter configured as not retaining, destroying " + mPresenter);
         }
 
-        if (!destroyPresenter
-                && !config.useStaticSaviorToRetain()
-                && !mTiActivity.isActivityChangingConfigurations()
-                && mTiActivity.isDontKeepActivitiesEnabled()) {
-            // configuration says the PresenterSavior should not be used. Retaining the presenter
-            // relays on the Activity nonConfigurationInstance which is always null when
-            // "don't keep activities" is enabled.
-            // a new presenter instance will be created and the current presenter should be destroyed
-            destroyPresenter = true;
-            TiLog.v(mLogTag.getLoggingTag(),
-                    "the PresenterSavior is disabled and \"don\'t keep activities\" is activated. "
-                            + "The presenter can't be retained. Destroying " + mPresenter);
-        }
-
         if (destroyPresenter) {
             mPresenter.destroy();
-            mSavior.free(mPresenterId);
+            mSavior.free(mPresenterId, mTiActivity.getHostingActivity());
         } else {
             TiLog.v(mLogTag.getLoggingTag(), "not destroying " + mPresenter
                     + " which will be reused by the next Activity instance, recreating...");
diff --git a/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/internal/TiFragmentDelegate.java b/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/internal/TiFragmentDelegate.java
index 052cd6b6..68dd5e7f 100644
--- a/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/internal/TiFragmentDelegate.java
+++ b/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/internal/TiFragmentDelegate.java
@@ -29,6 +29,7 @@
 import android.os.Bundle;
 import android.support.annotation.NonNull;
 import android.support.annotation.Nullable;
+import android.support.annotation.VisibleForTesting;
 import android.view.LayoutInflater;
 import android.view.ViewGroup;
 
@@ -43,7 +44,8 @@
 public class TiFragmentDelegate<P extends TiPresenter<V>, V extends TiView>
         implements InterceptableViewBinder<V>, PresenterAccessor<P, V> {
 
-    private static final String SAVED_STATE_PRESENTER_ID = "presenter_id";
+    @VisibleForTesting
+    static final String SAVED_STATE_PRESENTER_ID = "presenter_id";
 
     /**
      * enables debug logging during development
@@ -60,14 +62,14 @@ public class TiFragmentDelegate<P extends TiPresenter<V>, V extends TiView>
 
     private final TiPresenterProvider<P> mPresenterProvider;
 
+    private final TiPresenterSavior mSavior;
+
     private final DelegatedTiFragment mTiFragment;
 
     private Removable mUiThreadBinderRemovable;
 
     private final PresenterViewBinder<V> mViewBinder;
 
-    private final TiPresenterSavior mSavior;
-
     private final TiViewProvider<V> mViewProvider;
 
     public TiFragmentDelegate(final DelegatedTiFragment fragmentProvider,
@@ -125,6 +127,14 @@ public void onCreateView_beforeSuper(final LayoutInflater inflater,
 
     @SuppressWarnings("unchecked")
     public void onCreate_afterSuper(final Bundle savedInstanceState) {
+
+        if (mPresenter != null && mPresenter.isDestroyed()) {
+            // let a new Presenter be created
+            TiLog.v(mLogTag.getLoggingTag(),
+                    "detected destroyed presenter, discard it " + mPresenter);
+            mPresenter = null;
+        }
+
         if (mPresenter == null && savedInstanceState != null) {
             // recover with Savior
             // this should always work.
@@ -133,13 +143,14 @@ public void onCreate_afterSuper(final Bundle savedInstanceState) {
             if (recoveredPresenterId != null) {
                 TiLog.v(mLogTag.getLoggingTag(),
                         "try to recover Presenter with id: " + recoveredPresenterId);
-                mPresenter = (P) mSavior.recover(recoveredPresenterId);
+                mPresenter = (P) mSavior
+                        .recover(recoveredPresenterId, mTiFragment.getHostingActivity());
                 if (mPresenter != null) {
                     // save recovered presenter with new id. No other instance of this activity,
                     // holding the presenter before, is now able to remove the reference to
                     // this presenter from the savior
-                    mSavior.free(recoveredPresenterId);
-                    mPresenterId = mSavior.save(mPresenter);
+                    mSavior.free(recoveredPresenterId, mTiFragment.getHostingActivity());
+                    mPresenterId = mSavior.save(mPresenter, mTiFragment.getHostingActivity());
                 }
                 TiLog.v(mLogTag.getLoggingTag(), "recovered Presenter " + mPresenter);
             }
@@ -147,10 +158,16 @@ public void onCreate_afterSuper(final Bundle savedInstanceState) {
 
         if (mPresenter == null) {
             mPresenter = mPresenterProvider.providePresenter();
+            if (mPresenter.getState() != TiPresenter.State.INITIALIZED) {
+                throw new IllegalStateException("Presenter not in initialized state. "
+                        + "Current state is " + mPresenter.getState() + ". "
+                        + "Presenter provided with #providePresenter() cannot be reused. "
+                        + "Always return a fresh instance!");
+            }
             TiLog.v(mLogTag.getLoggingTag(), "created Presenter: " + mPresenter);
             final TiConfiguration config = mPresenter.getConfig();
-            if (config.shouldRetainPresenter() && config.useStaticSaviorToRetain()) {
-                mPresenterId = mSavior.save(mPresenter);
+            if (config.shouldRetainPresenter()) {
+                mPresenterId = mSavior.save(mPresenter, mTiFragment.getHostingActivity());
             }
             mPresenter.create();
         }
@@ -164,10 +181,6 @@ public void onCreate_afterSuper(final Bundle savedInstanceState) {
             addBindViewInterceptor(new DistinctUntilChangedInterceptor());
         }
 
-        if (config.shouldRetainPresenter()) {
-            mTiFragment.setFragmentRetainInstance(true);
-        }
-
         //noinspection unchecked
         final UiThreadExecutorAutoBinder uiThreadAutoBinder =
                 new UiThreadExecutorAutoBinder(mPresenter, mTiFragment.getUiThreadExecutor());
@@ -181,7 +194,6 @@ public void onDestroyView_beforeSuper() {
     }
 
     public void onDestroy_afterSuper() {
-        //FIXME handle attach/detach state
 
         // unregister observer and don't leak it
         if (mUiThreadBinderRemovable != null) {
@@ -189,20 +201,32 @@ public void onDestroy_afterSuper() {
             mUiThreadBinderRemovable = null;
         }
 
-        logState();
-
         boolean destroyPresenter = false;
-        if (mTiFragment.isHostingActivityFinishing()) {
+
+        if (!mTiFragment.isFragmentInBackstack()) {
+
+            if (mTiFragment.isFragmentRemoving()) {
+                // fragment was removed with remove() or replace()
+                destroyPresenter = true;
+                TiLog.v(mLogTag.getLoggingTag(),
+                        "Fragment was removed and is not managed by the FragmentManager anymore."
+                                + " Also destroy " + mPresenter);
+            }
+        } else {
+            TiLog.v(mLogTag.getLoggingTag(), "fragment is in backstack");
+        }
+
+        if (mTiFragment.isHostingActivityFinishing()
+                && !mTiFragment.isHostingActivityChangingConfigurations()) {
             // Probably a backpress and not a configuration change
             // Activity will not be recreated and finally destroyed, also destroyed the presenter
             destroyPresenter = true;
             TiLog.v(mLogTag.getLoggingTag(),
-                    "Activity is finishing, destroying presenter " + mPresenter);
+                    "Hosting Activity is finishing, destroying presenter " + mPresenter);
         }
 
-        final TiConfiguration config = mPresenter.getConfig();
         if (!destroyPresenter &&
-                !config.shouldRetainPresenter()) {
+                !mPresenter.getConfig().shouldRetainPresenter()) {
             // configuration says the presenter should not be retained, a new presenter instance
             // will be created and the current presenter should be destroyed
             destroyPresenter = true;
@@ -210,25 +234,12 @@ public void onDestroy_afterSuper() {
                     "presenter configured as not retaining, destroying " + mPresenter);
         }
 
-        if (!destroyPresenter &&
-                !config.useStaticSaviorToRetain() && mTiFragment.isDontKeepActivitiesEnabled()) {
-            // configuration says the PresenterSavior should not be used. Retaining the presenter
-            // relays on the Activity nonConfigurationInstance which is always null when
-            // "don't keep activities" is enabled.
-            // a new presenter instance will be created and the current presenter should be destroyed
-            destroyPresenter = true;
-            TiLog.v(mLogTag.getLoggingTag(),
-                    "the PresenterSavior is disabled and \"don\'t keep activities\" is "
-                            + "activated. The presenter can't be retained. Destroying "
-                            + mPresenter);
-        }
-
         if (destroyPresenter) {
             mPresenter.destroy();
-            mSavior.free(mPresenterId);
+            mSavior.free(mPresenterId, mTiFragment.getHostingActivity());
         } else {
             TiLog.v(mLogTag.getLoggingTag(), "not destroying " + mPresenter
-                    + " which will be reused by the next Activity instance, recreating...");
+                    + " which will be reused by a future Fragment instance");
         }
     }
 
@@ -272,24 +283,4 @@ private boolean isUiPossible() {
         return mTiFragment.isFragmentAdded() && !mTiFragment.isFragmentDetached();
     }
 
-    private void logState() {
-        if (ENABLE_DEBUG_LOGGING) {
-            TiLog.v(mLogTag.getLoggingTag(), "isChangingConfigurations = "
-                    + mTiFragment.isHostingActivityChangingConfigurations());
-            TiLog.v(mLogTag.getLoggingTag(),
-                    "isHostingActivityFinishing = " + mTiFragment.isHostingActivityFinishing());
-            TiLog.v(mLogTag.getLoggingTag(),
-                    "isAdded = " + mTiFragment.isFragmentAdded());
-            TiLog.v(mLogTag.getLoggingTag(),
-                    "isDetached = " + mTiFragment.isFragmentDetached());
-            TiLog.v(mLogTag.getLoggingTag(),
-                    "isDontKeepActivitiesEnabled = " + mTiFragment.isDontKeepActivitiesEnabled());
-
-            final TiConfiguration config = mPresenter.getConfig();
-            TiLog.v(mLogTag.getLoggingTag(),
-                    "shouldRetain = " + config.shouldRetainPresenter());
-            TiLog.v(mLogTag.getLoggingTag(),
-                    "useStaticSavior = " + config.useStaticSaviorToRetain());
-        }
-    }
 }
\ No newline at end of file
diff --git a/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/internal/TiPresenterProvider.java b/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/internal/TiPresenterProvider.java
index aa53b980..46a0de99 100644
--- a/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/internal/TiPresenterProvider.java
+++ b/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/internal/TiPresenterProvider.java
@@ -17,16 +17,29 @@
 
 import net.grandcentrix.thirtyinch.TiPresenter;
 
-import android.os.Bundle;
 import android.support.annotation.NonNull;
 
+/**
+ * Provides access to a new instance of a {@link TiPresenter} which will be attached to
+ * {@link net.grandcentrix.thirtyinch.TiActivity} or
+ * {@link net.grandcentrix.thirtyinch.TiFragment}
+ */
 public interface TiPresenterProvider<P extends TiPresenter> {
 
     /**
-     * Function returning a {@link net.grandcentrix.thirtyinch.TiPresenter}
+     * Must return a new {@link net.grandcentrix.thirtyinch.TiPresenter} instance in {@link
+     * net.grandcentrix.thirtyinch.TiPresenter.State#INITIALIZED} state. Never return a {@link
+     * TiPresenter} which was already instantiated or is already destroyed.
+     * <p>
+     * Called only once per Activity when the presenter should be retained. One call per Activity
+     * instance is expected when the retain is disabled
+     * </p>
      * <p>
-     * called only once when the Activity got initiated. Doesn't get called when the Activity gets
-     * recreated. The old presenter will be recovered in {@link android.app.Activity#onCreate(Bundle)}.
+     * Can be called multiple times per Fragment. The Presenter gets destroyed when the Fragment is
+     * removed from the {@link android.support.v4.app.FragmentManager}. When the {@link
+     * android.support.v4.app.Fragment} gets added again this method is called to create a new
+     * presenter.
+     * </p>
      */
     @NonNull
     P providePresenter();
diff --git a/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/internal/TiPresenterSavior.java b/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/internal/TiPresenterSavior.java
index 16a3a6c0..b3983034 100644
--- a/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/internal/TiPresenterSavior.java
+++ b/thirtyinch/src/main/java/net/grandcentrix/thirtyinch/internal/TiPresenterSavior.java
@@ -18,6 +18,7 @@
 
 import net.grandcentrix.thirtyinch.TiPresenter;
 
+import android.app.Activity;
 import android.support.annotation.NonNull;
 import android.support.annotation.Nullable;
 
@@ -32,7 +33,7 @@ public interface TiPresenterSavior {
      *
      * @param presenterId the id of the presenter
      */
-    void free(String presenterId);
+    void free(String presenterId, @NonNull Activity activity);
 
     /**
      * Gets a presenter from the store.
@@ -41,7 +42,7 @@ public interface TiPresenterSavior {
      * @return the presenter of {@code null} if no presenter could be found
      */
     @Nullable
-    TiPresenter recover(String presenterId);
+    TiPresenter recover(String presenterId, @NonNull Activity activity);
 
     /**
      * Stores a presenter in the store.
@@ -49,5 +50,5 @@ public interface TiPresenterSavior {
      * @param presenter the presenter that should be stored
      * @return the id of the stored presenter
      */
-    String save(@NonNull TiPresenter presenter);
+    String save(@NonNull TiPresenter presenter, @NonNull Activity activity);
 }
diff --git a/thirtyinch/src/test/java/net/grandcentrix/thirtyinch/internal/AbstractPresenterDestroyTest.java b/thirtyinch/src/test/java/net/grandcentrix/thirtyinch/internal/AbstractPresenterDestroyTest.java
new file mode 100644
index 00000000..4637db39
--- /dev/null
+++ b/thirtyinch/src/test/java/net/grandcentrix/thirtyinch/internal/AbstractPresenterDestroyTest.java
@@ -0,0 +1,96 @@
+/*
+ * Copyright (C) 2017 grandcentrix GmbH
+ * 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.
+ */
+
+package net.grandcentrix.thirtyinch.internal;
+
+import net.grandcentrix.thirtyinch.TiConfiguration;
+import net.grandcentrix.thirtyinch.TiPresenter;
+import net.grandcentrix.thirtyinch.TiView;
+
+import org.junit.After;
+import org.junit.Before;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+
+import android.os.Bundle;
+import android.support.annotation.NonNull;
+
+import java.util.HashMap;
+
+import static org.mockito.Matchers.anyString;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.mock;
+
+public abstract class AbstractPresenterDestroyTest {
+
+    class TestPresenter extends TiPresenter<TiView> {
+
+        TestPresenter(TiConfiguration config) {
+            super(config);
+        }
+    }
+
+    Bundle mActivitySavedState;
+
+    Bundle mFragmentSavedState;
+
+    TestPresenterSavior mSavior;
+
+    private final HashMap<String, String> activityHostBundle = new HashMap<>();
+
+    private final HashMap<String, String> fakeBundle = new HashMap<>();
+
+    @Before
+    public void setUp() throws Exception {
+        mSavior = new TestPresenterSavior();
+        mFragmentSavedState = mock(Bundle.class);
+        doAnswer(saveInMap(fakeBundle)).when(mFragmentSavedState).putString(anyString(), anyString());
+        doAnswer(getFromMap(fakeBundle)).when(mFragmentSavedState).getString(anyString());
+
+        mActivitySavedState = mock(Bundle.class);
+        doAnswer(saveInMap(activityHostBundle)).when(mActivitySavedState)
+                .putString(anyString(), anyString());
+        doAnswer(getFromMap(activityHostBundle)).when(mActivitySavedState).getString(anyString());
+    }
+
+    @After
+    public void tearDown() throws Exception {
+        mFragmentSavedState = null;
+    }
+
+    @NonNull
+    private Answer getFromMap(final HashMap<String, String> store) {
+        return new Answer() {
+            @Override
+            public String answer(final InvocationOnMock invocation) throws Throwable {
+                final Object[] args = invocation.getArguments();
+                //noinspection RedundantCast
+                return store.get((String) args[0]);
+            }
+        };
+    }
+
+    @NonNull
+    private Answer saveInMap(final HashMap<String, String> store) {
+        return new Answer() {
+            @Override
+            public Object answer(final InvocationOnMock invocation) throws Throwable {
+                final Object[] args = invocation.getArguments();
+                store.put((String) args[0], (String) args[1]);
+                return null;
+            }
+        };
+    }
+}
diff --git a/thirtyinch/src/test/java/net/grandcentrix/thirtyinch/internal/HostingActivity.java b/thirtyinch/src/test/java/net/grandcentrix/thirtyinch/internal/HostingActivity.java
new file mode 100644
index 00000000..9d824560
--- /dev/null
+++ b/thirtyinch/src/test/java/net/grandcentrix/thirtyinch/internal/HostingActivity.java
@@ -0,0 +1,65 @@
+/*
+ * Copyright (C) 2017 grandcentrix GmbH
+ * 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.
+ */
+
+package net.grandcentrix.thirtyinch.internal;
+
+
+import android.app.Activity;
+import android.app.Application;
+
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+/**
+ * mutable object mocking the hosting activity and their state
+ */
+public class HostingActivity {
+
+    private static Application mApplication = mock(Application.class);
+
+    private final Activity mActivityMock;
+
+    private boolean mIsChangingConfiguration;
+
+    private boolean mIsFinishing;
+
+    public HostingActivity() {
+        mActivityMock = mock(Activity.class);
+        when(mActivityMock.getApplication()).thenReturn(mApplication);
+    }
+
+    public Activity getMockActivityInstance() {
+        // always update with latest data
+        when(mActivityMock.isChangingConfigurations()).thenReturn(mIsChangingConfiguration);
+        when(mActivityMock.isFinishing()).thenReturn(mIsFinishing);
+        return mActivityMock;
+    }
+
+    public boolean isChangingConfiguration() {
+        return mIsChangingConfiguration;
+    }
+
+    public boolean isFinishing() {
+        return mIsFinishing;
+    }
+
+    public void setChangingConfiguration(final boolean changingConfiguration) {
+        mIsChangingConfiguration = changingConfiguration;
+    }
+
+    public void setFinishing(final boolean finishing) {
+        mIsFinishing = finishing;
+    }
+}
diff --git a/thirtyinch/src/test/java/net/grandcentrix/thirtyinch/internal/MockSavior.java b/thirtyinch/src/test/java/net/grandcentrix/thirtyinch/internal/MockSavior.java
deleted file mode 100644
index 7cd09f67..00000000
--- a/thirtyinch/src/test/java/net/grandcentrix/thirtyinch/internal/MockSavior.java
+++ /dev/null
@@ -1,57 +0,0 @@
-/*
- * Copyright (C) 2017 grandcentrix GmbH
- * 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.
- */
-
-package net.grandcentrix.thirtyinch.internal;
-
-
-import net.grandcentrix.thirtyinch.TiPresenter;
-
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
-
-import java.util.HashMap;
-
-public class MockSavior implements TiPresenterSavior {
-
-    private HashMap<String, TiPresenter> mPresenters = new HashMap<>();
-
-    public void clear() {
-        mPresenters.clear();
-    }
-
-    @Override
-    public void free(final String presenterId) {
-        mPresenters.remove(presenterId);
-    }
-
-    public int presenterCount() {
-        return mPresenters.size();
-    }
-
-    @Nullable
-    @Override
-    public TiPresenter recover(final String presenterId) {
-        return mPresenters.get(presenterId);
-    }
-
-    @Override
-    public String save(@NonNull final TiPresenter presenter) {
-        final String id = presenter.getClass().getSimpleName()
-                + ":" + presenter.hashCode()
-                + ":" + System.nanoTime();
-        mPresenters.put(id, presenter);
-        return id;
-    }
-}
diff --git a/thirtyinch/src/test/java/net/grandcentrix/thirtyinch/internal/MultipleTiFragmentPresenterDestroyTest.java b/thirtyinch/src/test/java/net/grandcentrix/thirtyinch/internal/MultipleTiFragmentPresenterDestroyTest.java
new file mode 100644
index 00000000..c14385b3
--- /dev/null
+++ b/thirtyinch/src/test/java/net/grandcentrix/thirtyinch/internal/MultipleTiFragmentPresenterDestroyTest.java
@@ -0,0 +1,636 @@
+/*
+ * Copyright (C) 2017 grandcentrix GmbH
+ * 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.
+ */
+
+package net.grandcentrix.thirtyinch.internal;
+
+import net.grandcentrix.thirtyinch.TiConfiguration;
+
+import org.junit.Test;
+
+import android.view.LayoutInflater;
+
+import static org.assertj.core.api.Java6Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+
+public class MultipleTiFragmentPresenterDestroyTest extends AbstractPresenterDestroyTest {
+
+    @Test
+    public void activityChangingConfiguration_retainFalse_backstackFalse() {
+
+        final HostingActivity hostingActivity = new HostingActivity();
+
+        // Given a Presenter that does not retain itself.
+        final TestPresenter presenter = new TestPresenter(new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(false)
+                .build());
+
+        // And given a Fragment.
+        final TestTiFragment fragment = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(false)
+                .setHostingActivity(hostingActivity)
+                .setSavior(mSavior)
+                .setPresenter(presenter)
+                .build();
+
+        // When the Fragment is added to the Activity.
+        fragment.onCreate(null);
+        fragment.setAdded(true);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // And when the Fragment is replaced by another Fragment
+        fragment.setAdded(false);
+        fragment.setRemoving(true);
+        fragment.onStop();
+        fragment.onDestroyView();
+        fragment.onDestroy();
+
+        // The Presenter is destroyed and not saved in the savior
+        assertThat(fragment.getPresenter().isDestroyed()).isTrue();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+
+        // When the Activity is changing its configuration.
+        hostingActivity.setChangingConfiguration(true);
+
+        // Then nothing happens with the fragment, not managed anymore
+        assertThat(fragment.getPresenter().isDestroyed()).isTrue();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+    }
+
+    @Test
+    public void activityChangingConfiguration_retainFalse_backstackTrue() {
+
+        final HostingActivity hostingActivity = new HostingActivity();
+
+        // Given a Presenter that does not retain itself.
+        final TestPresenter presenter = new TestPresenter(new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(false)
+                .build());
+
+        // And given a Fragment.
+        final TestTiFragment fragment = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(false)
+                .setHostingActivity(hostingActivity)
+                .setSavior(mSavior)
+                .setPresenter(presenter)
+                .build();
+
+        // When the Fragment is added to the Activity.
+        fragment.setInBackstack(true);
+        fragment.onCreate(null);
+        fragment.setAdded(true);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // And when the Fragment is replaced by another Fragment.
+        fragment.setAdded(false);
+        fragment.setRemoving(true);
+        fragment.onStop();
+        fragment.onDestroyView();
+
+        // The presenter is not destroyed and not saved in the savior
+        assertThat(fragment.getPresenter().isDestroyed()).isFalse();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+
+        // When the Activity is changing its configuration.
+        hostingActivity.setChangingConfiguration(true);
+        fragment.onSaveInstanceState(mFragmentSavedState);
+        fragment.onDestroy();
+
+        // Then assert that the Presenter is destroyed and not saved in the savior.
+        assertThat(fragment.getPresenter().isDestroyed()).isTrue();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+    }
+
+    /**
+     * Default config
+     */
+    @Test
+    public void activityChangingConfiguration_retainTrue_backstackFalse() {
+
+        final HostingActivity hostingActivity = new HostingActivity();
+
+        // Given a Presenter that does use a static savior and does retain itself.
+        final TestPresenter presenter = new TestPresenter(new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(true)
+                .build());
+
+        // And given a Fragment.
+        final TestTiFragment fragment = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(false)
+                .setHostingActivity(hostingActivity)
+                .setSavior(mSavior)
+                .setPresenter(presenter)
+                .build();
+
+        // When the Fragment is added to the Activity.
+        fragment.onCreate(null);
+        fragment.setAdded(true);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // And when the Fragment is replaced by another Fragment.
+        fragment.setAdded(false);
+        fragment.setRemoving(true);
+        fragment.onStop();
+        fragment.onDestroyView();
+        fragment.onDestroy();
+
+        // The Presenter is destroyed and not saved in the savior
+        assertThat(fragment.getPresenter().isDestroyed()).isTrue();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+
+        // When the Activity is changing its configuration.
+        hostingActivity.setChangingConfiguration(true);
+
+        // Then nothing happens with the fragment, not managed anymore
+        assertThat(fragment.getPresenter().isDestroyed()).isTrue();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+    }
+
+    /**
+     * Default config
+     */
+    @Test
+    public void activityChangingConfiguration_retainTrue_backstackTrue() {
+
+        final HostingActivity hostingActivity = new HostingActivity();
+
+        // Given a Presenter that uses a static savior to retain itself.
+        final TestPresenter presenter = new TestPresenter(new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(true)
+                .build());
+
+        // And given a Fragment.
+        final TestTiFragment fragment = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(false)
+                .setHostingActivity(hostingActivity)
+                .setSavior(mSavior)
+                .setPresenter(presenter)
+                .build();
+
+        // When the Fragment is added to the Activity.
+        fragment.setInBackstack(true);
+        fragment.onCreate(null);
+        fragment.setAdded(true);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // And when the Fragment is replaced by another Fragment.
+        fragment.setAdded(false);
+        fragment.setRemoving(true);
+        fragment.onStop();
+        fragment.onDestroyView();
+
+        // Then the presenter is not destroyed and saved in the savior
+        assertThat(fragment.getPresenter().isDestroyed()).isFalse();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(1);
+
+        // When the Activity is changing its configuration.
+        hostingActivity.setChangingConfiguration(true);
+        mSavior.mActivityInstanceObserver.onActivitySaveInstanceState(
+                hostingActivity.getMockActivityInstance(), mActivitySavedState);
+        fragment.onSaveInstanceState(mFragmentSavedState);
+        fragment.onDestroy();
+
+        // Then a new Activity is recreated.
+        final HostingActivity hostingActivity2 = new HostingActivity();
+        mSavior.mActivityInstanceObserver.onActivityCreated(
+                hostingActivity2.getMockActivityInstance(), mActivitySavedState);
+
+        // Then the Presenter is not destroyed and saved in the savior.
+        assertThat(fragment.getPresenter().isDestroyed()).isFalse();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(1);
+
+        // When the back stack is popped a new Fragment instance is created.
+        final TestPresenter presenter2 = new TestPresenter(new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(true)
+                .build());
+
+        final TestTiFragment fragment2 = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(false)
+                .setHostingActivity(hostingActivity2)
+                .setSavior(mSavior)
+                .setPresenter(presenter2)
+                .build();
+
+        // And the instance will be created with the saved instance state
+        fragment2.setInBackstack(true);
+        fragment2.onCreate(mFragmentSavedState);
+        fragment2.setAdded(true);
+        fragment2.onCreateView(mock(LayoutInflater.class), null, mFragmentSavedState);
+        fragment2.onStart();
+
+        // Then the same presenter gets recovered
+        assertThat(fragment2.getPresenter()).isEqualTo(presenter);
+        assertThat(fragment2.getPresenter().isDestroyed()).isFalse();
+    }
+
+    @Test
+    public void activityChangingConfiguration_thenFinish_retainFalse_backstackTrue() {
+
+        final HostingActivity hostingActivity = new HostingActivity();
+
+        // Given a Presenter that uses a static savior to retain itself.
+        final TestPresenter presenter = new TestPresenter(new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(false)
+                .build());
+
+        // And given a Fragment.
+        final TestTiFragment fragment = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(false)
+                .setHostingActivity(hostingActivity)
+                .setSavior(mSavior)
+                .setPresenter(presenter)
+                .build();
+
+        // When the Fragment is added to the Activity.
+        fragment.setInBackstack(true);
+        fragment.onCreate(null);
+        fragment.setAdded(true);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // And when the Fragment is replaced by another Fragment.
+        fragment.setAdded(false);
+        fragment.setRemoving(true);
+        fragment.onStop();
+        fragment.onDestroyView();
+
+        // Then the presenter is not destroyed
+        assertThat(fragment.getPresenter().isDestroyed()).isFalse();
+
+        // Then the presenter is not saved in the savior
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+
+        // When the Activity is changing its configuration.
+        hostingActivity.setChangingConfiguration(true);
+        assertThat(mSavior.mActivityInstanceObserver).isNull();
+        fragment.onSaveInstanceState(mFragmentSavedState);
+        fragment.onDestroy();
+
+        // Then the Presenter is destroyed and not saved in the savior.
+        assertThat(fragment.getPresenter().isDestroyed()).isTrue();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+
+        // Then a new Activity is recreated.
+        final HostingActivity hostingActivity2 = new HostingActivity();
+        assertThat(mSavior.mActivityInstanceObserver).isNull();
+
+        // When the Activity gets finished
+        hostingActivity2.setFinishing(true);
+        assertThat(mSavior.mActivityInstanceObserver).isNull();
+
+        // Then nothing happens, the presenter is already destroyed
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+        assertThat(presenter.isDestroyed()).isTrue();
+    }
+
+    /**
+     * Default config
+     */
+    @Test
+    public void activityChangingConfiguration_thenFinish_retainTrue_backstackTrue() {
+
+        final HostingActivity hostingActivity = new HostingActivity();
+
+        // Given a Presenter that uses a static savior to retain itself.
+        final TestPresenter presenter = new TestPresenter(new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(true)
+                .build());
+
+        // And given a Fragment.
+        final TestTiFragment fragment = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(false)
+                .setHostingActivity(hostingActivity)
+                .setSavior(mSavior)
+                .setPresenter(presenter)
+                .build();
+
+        // When the Fragment is added to the Activity.
+        fragment.setInBackstack(true);
+        fragment.onCreate(null);
+        fragment.setAdded(true);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // And when the Fragment is replaced by another Fragment.
+        fragment.setAdded(false);
+        fragment.setRemoving(true);
+        fragment.onStop();
+        fragment.onDestroyView();
+
+        // Then the presenter is not destroyed and saved in the savior
+        assertThat(fragment.getPresenter().isDestroyed()).isFalse();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(1);
+
+        // When the Activity is changing its configuration.
+        hostingActivity.setChangingConfiguration(true);
+        mSavior.mActivityInstanceObserver.onActivitySaveInstanceState(
+                hostingActivity.getMockActivityInstance(), mActivitySavedState);
+        fragment.onSaveInstanceState(mFragmentSavedState);
+        fragment.onDestroy();
+
+        // Then a new Activity is recreated.
+        final HostingActivity hostingActivity2 = new HostingActivity();
+        mSavior.mActivityInstanceObserver.onActivityCreated(
+                hostingActivity2.getMockActivityInstance(), mActivitySavedState);
+
+        // Then the Presenter is not destroyed and saved in the savior.
+        assertThat(fragment.getPresenter().isDestroyed()).isFalse();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(1);
+
+        // When the Activity gets finished
+        hostingActivity2.setFinishing(true);
+        mSavior.mActivityInstanceObserver.onActivityDestroyed(
+                hostingActivity2.getMockActivityInstance());
+
+        // Then the same presenter is destroyed
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+        assertThat(presenter.isDestroyed()).isTrue();
+    }
+
+    @Test
+    public void activityFinishing_retainFalse_backstackFalse() {
+
+        final HostingActivity hostingActivity = new HostingActivity();
+
+        // Given a Presenter that does use a static savior but does not retain itself.
+        final TestPresenter presenter = new TestPresenter(new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(false)
+                .build());
+
+        // And given a Fragment.
+        final TestTiFragment fragment = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(false)
+                .setHostingActivity(hostingActivity)
+                .setSavior(mSavior)
+                .setPresenter(presenter)
+                .build();
+
+        // When the Fragment is added to the Activity.
+        fragment.onCreate(null);
+        fragment.setAdded(true);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // Then the presenter is not saved in the savior
+        assertThat(fragment.getPresenter().isDestroyed()).isFalse();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+
+        // And when the Fragment is replaced by another Fragment.
+        fragment.setAdded(false);
+        fragment.setRemoving(true);
+        fragment.onStop();
+        fragment.onDestroyView();
+        fragment.onDestroy();
+
+        // Then assert that the Presenter is destroyed and not saved in the savior
+        // because there is no way to bring the Fragment back.
+        assertThat(fragment.getPresenter().isDestroyed()).isTrue();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+
+        // When the activity finishes
+        // nothing happens because the presenter is already destroyed
+        hostingActivity.setFinishing(true);
+    }
+
+    @Test
+    public void activityFinishing_retainFalse_backstackTrue() {
+
+        final HostingActivity hostingActivity = new HostingActivity();
+
+        // Given a Presenter that does use a static savior but does not retain itself.
+        final TestPresenter presenter = new TestPresenter(new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(false)
+                .build());
+
+        // And given a Fragment.
+        final TestTiFragment fragment = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(false)
+                .setHostingActivity(hostingActivity)
+                .setSavior(mSavior)
+                .setPresenter(presenter)
+                .build();
+
+        // When the Fragment is added to the Activity.
+        fragment.setInBackstack(true);
+        fragment.onCreate(null);
+        fragment.setAdded(true);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // Then the presenter is not saved in the savior
+        assertThat(fragment.getPresenter().isDestroyed()).isFalse();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+
+        // And when the Fragment is replaced by another Fragment.
+        fragment.setAdded(false);
+        fragment.setRemoving(true);
+        fragment.onStop();
+        fragment.onDestroyView();
+
+        // When the Activity is finishing.
+        hostingActivity.setFinishing(true);
+        fragment.onDestroy();
+
+        // Then the Presenter is destroyed and not saved in the savior.
+        assertThat(fragment.getPresenter().isDestroyed()).isTrue();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+    }
+
+    /**
+     * Default config
+     */
+    @Test
+    public void activityFinishing_retainTrue_backstackFalse() {
+
+        final HostingActivity hostingActivity = new HostingActivity();
+
+        // Given a Presenter that does use a static savior and does retain itself.
+        final TestPresenter presenter = new TestPresenter(new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(true)
+                .build());
+
+        // And given a Fragment.
+        final TestTiFragment fragment = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(false)
+                .setHostingActivity(hostingActivity)
+                .setSavior(mSavior)
+                .setPresenter(presenter)
+                .build();
+
+        // When the Fragment is added to the Activity.
+        fragment.onCreate(null);
+        fragment.setAdded(true);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // Then the presenter is saved in the savior
+        assertThat(fragment.getPresenter().isDestroyed()).isFalse();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(1);
+
+        // And when the Fragment is replaced by another Fragment.
+        fragment.setAdded(false);
+        fragment.setRemoving(true);
+        fragment.onStop();
+        fragment.onDestroyView();
+        fragment.onDestroy();
+
+        // Then assert that the Presenter is destroyed and not saved in the savior
+        // because there is no way the Fragment can be brought back.
+        assertThat(fragment.getPresenter().isDestroyed()).isTrue();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+
+        // When the activity finishes
+        // nothing happens because the presenter is already destroyed
+        hostingActivity.setFinishing(true);
+    }
+
+    /**
+     * Default config
+     */
+    @Test
+    public void activityFinishing_retainTrue_backstackTrue() {
+
+        final HostingActivity hostingActivity = new HostingActivity();
+
+        // Given a Presenter that uses a static savior to retain itself.
+        final TestPresenter presenter = new TestPresenter(new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(true)
+                .build());
+
+        // And given a Fragment.
+        final TestTiFragment fragment = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(false)
+                .setHostingActivity(hostingActivity)
+                .setSavior(mSavior)
+                .setPresenter(presenter)
+                .build();
+
+        // When the Fragment is added to the Activity.
+        fragment.setInBackstack(true);
+        fragment.onCreate(null);
+        fragment.setAdded(true);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // Then the presenter is saved in the savior
+        assertThat(fragment.getPresenter().isDestroyed()).isFalse();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(1);
+
+        // And when it is replaced by another Fragment.
+        fragment.setAdded(false);
+        fragment.setRemoving(true);
+        fragment.onStop();
+        fragment.onDestroyView();
+
+        // And when the Activity is finishing.
+        hostingActivity.setFinishing(true);
+        fragment.onDestroy();
+
+        // Then assert that the Presenter is destroyed and not saved in the savior.
+        assertThat(fragment.getPresenter().isDestroyed()).isTrue();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+    }
+
+    @Test
+    public void popBackstack_retainFalse() {
+
+        final HostingActivity hostingActivity = new HostingActivity();
+
+        // Given a Presenter that does use a static savior but does not retain itself.
+        final TestPresenter presenter = new TestPresenter(new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(false)
+                .build());
+
+        // And given a Fragment.
+        final TestTiFragment fragment = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(false)
+                .setHostingActivity(hostingActivity)
+                .setSavior(mSavior)
+                .setPresenter(presenter)
+                .build();
+
+        // When the Fragment is added to the Activity.
+        fragment.setInBackstack(true);
+        fragment.onCreate(null);
+        fragment.setAdded(true);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // And when the Fragment is replaced by another Fragment.
+        fragment.setAdded(false);
+        fragment.setRemoving(true);
+        fragment.onStop();
+        fragment.onDestroyView();
+
+        // And when the back stack is popped.
+        fragment.setAdded(true);
+        fragment.setRemoving(false);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // Then assert that the Presenter is not destroyed and not saved in the savior.
+        assertThat(fragment.getPresenter().isDestroyed()).isFalse();
+        assertThat(fragment.getPresenter()).isEqualTo(presenter);
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+    }
+
+    /**
+     * Default config
+     */
+    @Test
+    public void popBackstack_retainTrue() {
+
+        final HostingActivity hostingActivity = new HostingActivity();
+
+        // Given a Presenter that uses a static savior to retain itself.
+        final TestPresenter presenter = new TestPresenter(new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(true)
+                .build());
+
+        // And given a Fragment.
+        final TestTiFragment fragment = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(false)
+                .setHostingActivity(hostingActivity)
+                .setSavior(mSavior)
+                .setPresenter(presenter)
+                .build();
+
+        // When the Fragment is added to the Activity.
+        fragment.setInBackstack(true);
+        fragment.onCreate(null);
+        fragment.setAdded(true);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // And when the Fragment is replaced by another Fragment.
+        fragment.setAdded(true);
+        fragment.setRemoving(false);
+        fragment.onStop();
+        fragment.onDestroyView();
+
+        // And when the back stack is popped.
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // Then assert that the Presenter is not destroyed and saved in the savior.
+        assertThat(fragment.getPresenter().isDestroyed()).isFalse();
+        assertThat(fragment.getPresenter()).isEqualTo(presenter);
+        assertThat(mSavior.getPresenterCount()).isEqualTo(1);
+    }
+
+}
diff --git a/thirtyinch/src/test/java/net/grandcentrix/thirtyinch/internal/MultipleTiFragmentPresenterDestroyTestIgnoreDontKeepActivities.java b/thirtyinch/src/test/java/net/grandcentrix/thirtyinch/internal/MultipleTiFragmentPresenterDestroyTestIgnoreDontKeepActivities.java
new file mode 100644
index 00000000..816a70a5
--- /dev/null
+++ b/thirtyinch/src/test/java/net/grandcentrix/thirtyinch/internal/MultipleTiFragmentPresenterDestroyTestIgnoreDontKeepActivities.java
@@ -0,0 +1,601 @@
+/*
+ * Copyright (C) 2017 grandcentrix GmbH
+ * 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.
+ */
+
+package net.grandcentrix.thirtyinch.internal;
+
+import net.grandcentrix.thirtyinch.TiConfiguration;
+
+import org.junit.Test;
+
+import android.view.LayoutInflater;
+
+import static org.assertj.core.api.Java6Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+
+/**
+ * Same test cases as {@link MultipleTiFragmentPresenterDestroyTest} but with the "don't keep
+ * Activities option enabled". This means that the lifecycle may be different but the final
+ * assertions must be identical
+ */
+public class MultipleTiFragmentPresenterDestroyTestIgnoreDontKeepActivities
+        extends AbstractPresenterDestroyTest {
+
+    @Test
+    public void activityChangingConfiguration_retainFalse_backstackFalse_dkATrue() {
+
+        final HostingActivity hostingActivity = new HostingActivity();
+
+        // Given a Presenter that does use a static savior but does not retain itself.
+        final TestPresenter presenter = new TestPresenter(new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(false)
+                .build());
+
+        // And given a Fragment.
+        final TestTiFragment fragment = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(true)
+                .setHostingActivity(hostingActivity)
+                .setSavior(mSavior)
+                .setPresenter(presenter)
+                .build();
+
+        // When the Fragment is added to the Activity.
+        fragment.onCreate(null);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // And when the Fragment is replaced by another Fragment.
+        fragment.onStop();
+        fragment.onDestroyView();
+        fragment.onDestroy();
+
+        // Then assert that the Presenter is destroyed and not saved in the savior
+        // because there is no way to bring the Fragment back.
+        assertThat(fragment.getPresenter().isDestroyed()).isTrue();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+    }
+
+    @Test
+    public void activityChangingConfiguration_retainFalse_backstackTrue_dkATrue() {
+
+        final HostingActivity hostingActivity = new HostingActivity();
+
+        // Given a Presenter that does use a static savior but does not retain itself.
+        final TestPresenter presenter = new TestPresenter(new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(false)
+                .build());
+
+        // And given a Fragment.
+        final TestTiFragment fragment = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(true)
+                .setHostingActivity(hostingActivity)
+                .setSavior(mSavior)
+                .setPresenter(presenter)
+                .build();
+
+        // When the Fragment is added to the Activity.
+        fragment.setInBackstack(true);
+        fragment.onCreate(null);
+        fragment.setAdded(true);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // And when the Fragment is replaced by another Fragment.
+        fragment.setAdded(false);
+        fragment.setRemoving(true);
+        fragment.onStop();
+        fragment.onDestroyView();
+
+        // And when the Activity is changing its configuration.
+        hostingActivity.setChangingConfiguration(true);
+        fragment.onSaveInstanceState(mFragmentSavedState);
+        fragment.onDestroy();
+
+        // Then assert that the Presenter is destroyed and not saved in the savior.
+        assertThat(fragment.getPresenter().isDestroyed()).isTrue();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+    }
+
+    @Test
+    public void activityChangingConfiguration_retainTrue_backstackFalse_dkATrue() {
+
+        final HostingActivity hostingActivity = new HostingActivity();
+
+        // Given a Presenter that does use a static savior and does retain itself.
+        final TestPresenter presenter = new TestPresenter(new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(true)
+                .build());
+
+        // And given a Fragment.
+        final TestTiFragment fragment = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(true)
+                .setHostingActivity(hostingActivity)
+                .setSavior(mSavior)
+                .setPresenter(presenter)
+                .build();
+
+        // When the Fragment is added to the Activity.
+        fragment.onCreate(null);
+        fragment.setAdded(true);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // And when the Fragment is replaced by another Fragment.
+        fragment.setAdded(false);
+        fragment.setRemoving(true);
+        fragment.onStop();
+        fragment.onDestroyView();
+        fragment.onDestroy();
+
+        // The Presenter is destroyed and not saved in the savior
+        assertThat(fragment.getPresenter().isDestroyed()).isTrue();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+
+        // When the Activity is changing its configuration.
+        hostingActivity.setChangingConfiguration(true);
+
+        // Then nothing happens with the fragment, not managed anymore
+        assertThat(fragment.getPresenter().isDestroyed()).isTrue();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+    }
+
+    @Test
+    public void activityChangingConfiguration_retainTrue_backstackTrue_dkATrue() {
+
+        final HostingActivity hostingActivity = new HostingActivity();
+
+        // Given a Presenter that uses a static savior to retain itself.
+        final TestPresenter presenter = new TestPresenter(new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(true)
+                .build());
+
+        // And given a Fragment.
+        final TestTiFragment fragment = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(true)
+                .setHostingActivity(hostingActivity)
+                .setSavior(mSavior)
+                .setPresenter(presenter)
+                .build();
+
+        // When the Fragment is added to the Activity.
+        fragment.setInBackstack(true);
+        fragment.onCreate(null);
+        fragment.setAdded(true);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // And when the Fragment is replaced by another Fragment.
+        fragment.setAdded(false);
+        fragment.setRemoving(true);
+        fragment.onStop();
+        fragment.onDestroyView();
+
+        // Then the presenter is not destroyed and saved in the savior
+        assertThat(fragment.getPresenter().isDestroyed()).isFalse();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(1);
+
+        // When the Activity is changing its configuration.
+        hostingActivity.setChangingConfiguration(true);
+        mSavior.mActivityInstanceObserver.onActivitySaveInstanceState(
+                hostingActivity.getMockActivityInstance(), mActivitySavedState);
+        fragment.onSaveInstanceState(mFragmentSavedState);
+        fragment.onDestroy();
+
+        // Then a new Activity is recreated.
+        final HostingActivity hostingActivity2 = new HostingActivity();
+        mSavior.mActivityInstanceObserver.onActivityCreated(
+                hostingActivity2.getMockActivityInstance(), mActivitySavedState);
+
+        // Then the Presenter is not destroyed and saved in the savior.
+        assertThat(fragment.getPresenter().isDestroyed()).isFalse();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(1);
+
+        // When the back stack is popped a new Fragment instance is created.
+        final TestPresenter presenter2 = new TestPresenter(new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(true)
+                .build());
+
+        final TestTiFragment fragment2 = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(true)
+                .setHostingActivity(hostingActivity2)
+                .setSavior(mSavior)
+                .setPresenter(presenter2)
+                .build();
+
+        // And the instance will be created with the saved instance state
+        fragment2.setInBackstack(true);
+        fragment2.onCreate(mFragmentSavedState);
+        fragment2.setAdded(true);
+        fragment2.onCreateView(mock(LayoutInflater.class), null, mFragmentSavedState);
+        fragment2.onStart();
+
+        // Then the same presenter gets recovered
+        assertThat(fragment2.getPresenter()).isEqualTo(presenter);
+        assertThat(fragment2.getPresenter().isDestroyed()).isFalse();
+    }
+
+    @Test
+    public void activityChangingConfiguration_thenFinish_retainTrue_backstackTrue_dkATrue() {
+
+        final HostingActivity hostingActivity = new HostingActivity();
+
+        // Given a Presenter that uses a static savior to retain itself.
+        final TestPresenter presenter = new TestPresenter(new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(true)
+                .build());
+
+        // And given a Fragment.
+        final TestTiFragment fragment = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(true)
+                .setHostingActivity(hostingActivity)
+                .setSavior(mSavior)
+                .setPresenter(presenter)
+                .build();
+
+        // When the Fragment is added to the Activity.
+        fragment.setInBackstack(true);
+        fragment.onCreate(null);
+        fragment.setAdded(true);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // And when the Fragment is replaced by another Fragment.
+        fragment.setAdded(false);
+        fragment.setRemoving(true);
+        fragment.onStop();
+        fragment.onDestroyView();
+
+        // Then the presenter is not destroyed and saved in the savior
+        assertThat(fragment.getPresenter().isDestroyed()).isFalse();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(1);
+
+        // When the Activity is changing its configuration.
+        hostingActivity.setChangingConfiguration(true);
+        mSavior.mActivityInstanceObserver.onActivitySaveInstanceState(
+                hostingActivity.getMockActivityInstance(), mActivitySavedState);
+        fragment.onSaveInstanceState(mFragmentSavedState);
+        fragment.onDestroy();
+
+        // Then a new Activity is recreated.
+        final HostingActivity hostingActivity2 = new HostingActivity();
+        mSavior.mActivityInstanceObserver.onActivityCreated(
+                hostingActivity2.getMockActivityInstance(), mActivitySavedState);
+
+        // Then the Presenter is not destroyed and saved in the savior.
+        assertThat(fragment.getPresenter().isDestroyed()).isFalse();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(1);
+
+        // When the Activity gets finished
+        hostingActivity2.setFinishing(true);
+        mSavior.mActivityInstanceObserver.onActivityDestroyed(
+                hostingActivity2.getMockActivityInstance());
+
+        // Then the same presenter is destroyed
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+        assertThat(presenter.isDestroyed()).isTrue();
+    }
+
+
+    @Test
+    public void activityChangingConfiguration_thenFinish_retainFalse_backstackTrue_dkATrue() {
+
+        final HostingActivity hostingActivity = new HostingActivity();
+
+        // Given a Presenter that uses a static savior to retain itself.
+        final TestPresenter presenter = new TestPresenter(new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(false)
+                .build());
+
+        // And given a Fragment.
+        final TestTiFragment fragment = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(true)
+                .setHostingActivity(hostingActivity)
+                .setSavior(mSavior)
+                .setPresenter(presenter)
+                .build();
+
+        // When the Fragment is added to the Activity.
+        fragment.setInBackstack(true);
+        fragment.onCreate(null);
+        fragment.setAdded(true);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // And when the Fragment is replaced by another Fragment.
+        fragment.setAdded(false);
+        fragment.setRemoving(true);
+        fragment.onStop();
+        fragment.onDestroyView();
+
+        // Then the presenter is not destroyed, onDestroy wasn't called
+        assertThat(fragment.getPresenter().isDestroyed()).isFalse();
+
+        // Then the presenter is not saved in the savior
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+
+        // When the Activity is changing its configuration.
+        hostingActivity.setChangingConfiguration(true);
+        assertThat(mSavior.mActivityInstanceObserver).isNull();
+        fragment.onSaveInstanceState(mFragmentSavedState);
+        fragment.onDestroy();
+
+        // Then the Presenter is destroyed and not saved in the savior.
+        assertThat(fragment.getPresenter().isDestroyed()).isTrue();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+
+        // Then a new Activity is recreated.
+        final HostingActivity hostingActivity2 = new HostingActivity();
+        assertThat(mSavior.mActivityInstanceObserver).isNull();
+
+        // When the Activity gets finished
+        hostingActivity2.setFinishing(true);
+        assertThat(mSavior.mActivityInstanceObserver).isNull();
+
+        // Then nothing happens, the presenter is already destroyed
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+        assertThat(presenter.isDestroyed()).isTrue();
+    }
+
+    @Test
+    public void activityFinishing_retainFalse_backstackFalse_dkATrue() {
+
+        final HostingActivity hostingActivity = new HostingActivity();
+
+        // Given a Presenter that does use a static savior but does not retain itself.
+        final TestPresenter presenter = new TestPresenter(new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(false)
+                .build());
+
+        // And given a Fragment.
+        final TestTiFragment fragment = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(true)
+                .setHostingActivity(hostingActivity)
+                .setSavior(mSavior)
+                .setPresenter(presenter)
+                .build();
+
+        // When the Fragment is added to the Activity.
+        fragment.onCreate(null);
+        fragment.setAdded(true);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // Then the presenter is not saved in the savior
+        assertThat(fragment.getPresenter().isDestroyed()).isFalse();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+
+        // And when the Fragment is replaced by another Fragment.
+        fragment.setAdded(false);
+        fragment.setRemoving(true);
+        fragment.onStop();
+        fragment.onDestroyView();
+        fragment.onDestroy();
+
+        // Then assert that the Presenter is destroyed and not saved in the savior
+        // because there is no way to bring the Fragment back.
+        assertThat(fragment.getPresenter().isDestroyed()).isTrue();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+
+        // When the activity finishes
+        // nothing happens because the presenter is already destroyed
+        hostingActivity.setFinishing(true);
+    }
+
+    @Test
+    public void activityFinishing_retainFalse_backstackTrue_dkATrue() {
+
+        final HostingActivity hostingActivity = new HostingActivity();
+
+        // Given a Presenter that does use a static savior but does not retain itself.
+        final TestPresenter presenter = new TestPresenter(new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(false)
+                .build());
+
+        // And given a Fragment.
+        final TestTiFragment fragment = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(true)
+                .setHostingActivity(hostingActivity)
+                .setSavior(mSavior)
+                .setPresenter(presenter)
+                .build();
+
+        // When the Fragment is added to the Activity.
+        fragment.setInBackstack(true);
+        fragment.onCreate(null);
+        fragment.setAdded(true);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // And when the Fragment is replaced by another Fragment.
+        fragment.setAdded(false);
+        fragment.setRemoving(true);
+        fragment.onStop();
+        fragment.onDestroyView();
+
+        // And when the Activity is finishing.
+        hostingActivity.setFinishing(true);
+        fragment.onDestroy();
+
+        // Then assert that the Presenter is destroyed and not saved in the savior.
+        assertThat(fragment.getPresenter().isDestroyed()).isTrue();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+    }
+
+    @Test
+    public void activityFinishing_retainTrue_backstackFalse_dkATrue() {
+
+        final HostingActivity hostingActivity = new HostingActivity();
+
+        // Given a Presenter that does use a static savior and does retain itself.
+        final TestPresenter presenter = new TestPresenter(new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(true)
+                .build());
+
+        // And given a Fragment.
+        final TestTiFragment fragment = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(true)
+                .setHostingActivity(hostingActivity)
+                .setSavior(mSavior)
+                .setPresenter(presenter)
+                .build();
+
+        // When the Fragment is added to the Activity.
+        fragment.onCreate(null);
+        fragment.setAdded(true);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // And when the Fragment is replaced by another Fragment.
+        fragment.setAdded(true);
+        fragment.setRemoving(true);
+        fragment.onStop();
+        fragment.onDestroyView();
+        fragment.onDestroy();
+
+        // Then assert that the Presenter is destroyed and not saved in the savior
+        // because there is no way the Fragment can be brought back.
+        assertThat(fragment.getPresenter().isDestroyed()).isTrue();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+
+        // When the activity finishes
+        // nothing happens because the presenter is already destroyed
+        hostingActivity.setFinishing(true);
+    }
+
+    @Test
+    public void activityFinishing_retainTrue_backstackTrue_dkATrue() {
+
+        final HostingActivity hostingActivity = new HostingActivity();
+
+        // Given a Presenter that uses a static savior to retain itself.
+        final TestPresenter presenter = new TestPresenter(new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(true)
+                .build());
+
+        // And given a Fragment.
+        final TestTiFragment fragment = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(true)
+                .setHostingActivity(hostingActivity)
+                .setSavior(mSavior)
+                .setPresenter(presenter)
+                .build();
+
+        // When the Fragment is added to the Activity.
+        fragment.setInBackstack(true);
+        fragment.onCreate(null);
+        fragment.setAdded(true);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // And when the Fragment is replaced by another Fragment.
+        fragment.setAdded(false);
+        fragment.setRemoving(true);
+        fragment.onStop();
+        fragment.onDestroyView();
+
+        // And when the Activity is finishing.
+        hostingActivity.setFinishing(true);
+        fragment.onDestroy();
+
+        // Then assert that the Presenter is destroyed and not saved in the savior.
+        assertThat(fragment.getPresenter().isDestroyed()).isTrue();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+    }
+
+    @Test
+    public void popBackstack_retainFalse_backstackTrue_dkATrue() {
+
+        final HostingActivity hostingActivity = new HostingActivity();
+
+        // Given a Presenter that does use a static savior but does not retain itself.
+        final TestPresenter presenter = new TestPresenter(new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(false)
+                .build());
+
+        // And given a Fragment.
+        final TestTiFragment fragment = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(true)
+                .setHostingActivity(hostingActivity)
+                .setSavior(mSavior)
+                .setPresenter(presenter)
+                .build();
+
+        // When the Fragment is added to the Activity.
+        fragment.setInBackstack(true);
+        fragment.onCreate(null);
+        fragment.setAdded(true);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // And when the Fragment is replaced by another Fragment.
+        fragment.setAdded(false);
+        fragment.setRemoving(true);
+        fragment.onStop();
+        fragment.onDestroyView();
+
+        // And when the back stack is popped.
+        fragment.setAdded(true);
+        fragment.setRemoving(false);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // Then assert that the Presenter is not destroyed and not saved in the savior.
+        assertThat(fragment.getPresenter().isDestroyed()).isFalse();
+        assertThat(fragment.getPresenter()).isEqualTo(presenter);
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+    }
+
+    @Test
+    public void popBackstack_retainTrue_backstackTrue_dkATrue() {
+
+        final HostingActivity hostingActivity = new HostingActivity();
+
+        // Given a Presenter that uses a static savior to retain itself.
+        final TestPresenter presenter = new TestPresenter(new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(true)
+                .build());
+
+        // And given a Fragment.
+        final TestTiFragment fragment = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(true)
+                .setHostingActivity(hostingActivity)
+                .setSavior(mSavior)
+                .setPresenter(presenter)
+                .build();
+
+        // When the Fragment is added to the Activity.
+        fragment.setInBackstack(true);
+        fragment.onCreate(null);
+        fragment.setAdded(true);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // And when the Fragment is replaced by another Fragment.
+        fragment.setAdded(false);
+        fragment.setRemoving(true);
+        fragment.onStop();
+        fragment.onDestroyView();
+
+        // And whent the back stack is popped.
+        fragment.setAdded(true);
+        fragment.setRemoving(false);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // Then assert that the Presenter is not destroyed and saved in the savior.
+        assertThat(fragment.getPresenter().isDestroyed()).isFalse();
+        assertThat(fragment.getPresenter()).isEqualTo(presenter);
+        assertThat(mSavior.getPresenterCount()).isEqualTo(1);
+    }
+}
diff --git a/thirtyinch/src/test/java/net/grandcentrix/thirtyinch/internal/PresenterSaviorTest.java b/thirtyinch/src/test/java/net/grandcentrix/thirtyinch/internal/PresenterSaviorTest.java
new file mode 100644
index 00000000..936c7f6e
--- /dev/null
+++ b/thirtyinch/src/test/java/net/grandcentrix/thirtyinch/internal/PresenterSaviorTest.java
@@ -0,0 +1,371 @@
+/*
+ * Copyright (C) 2017 grandcentrix GmbH
+ * 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.
+ */
+
+package net.grandcentrix.thirtyinch.internal;
+
+import net.grandcentrix.thirtyinch.TiPresenter;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.mockito.invocation.InvocationOnMock;
+import org.mockito.stubbing.Answer;
+
+import android.os.Bundle;
+import android.support.annotation.NonNull;
+
+import java.util.HashMap;
+
+import static org.assertj.core.api.Java6Assertions.assertThat;
+import static org.mockito.Matchers.anyString;
+import static org.mockito.Mockito.doAnswer;
+import static org.mockito.Mockito.mock;
+
+public class PresenterSaviorTest {
+
+    private final HashMap<String, String> fakeBundle = new HashMap<>();
+
+    private Bundle mSavedState;
+
+    @Test
+    public void activityAddedWithoutPresenters() throws Exception {
+
+        final TestPresenterSavior savior = new TestPresenterSavior();
+        final HostingActivity hostingActivity = new HostingActivity();
+
+        // create lifecycle callbacks with different scope
+        final TiPresenter presenter = new TiPresenter() {
+        };
+        final String id = savior.save(presenter, hostingActivity.getMockActivityInstance());
+        assertThat(id).isNotNull();
+        assertThat(savior.getPresenterCount()).isEqualTo(1);
+        assertThat(savior.mScopes).hasSize(1);
+
+        // some random Activity was created
+        final HostingActivity hostingActivity2 = new HostingActivity();
+        savior.mActivityInstanceObserver.onActivityCreated(
+                hostingActivity2.getMockActivityInstance(), mSavedState);
+
+        // no second scope was created
+        assertThat(savior.mScopes).hasSize(1);
+    }
+
+    @Test
+    public void cleanupAfterActivityFinish() throws Exception {
+        final TestPresenterSavior savior = new TestPresenterSavior();
+
+        final HostingActivity hostingActivity = new HostingActivity();
+
+        // Given two presenters saved in savior
+        final TiPresenter presenter = new TiPresenter() {
+        };
+        final TiPresenter presenter2 = new TiPresenter() {
+        };
+
+        // When both are saved in savior
+        final String id = savior.save(presenter, hostingActivity.getMockActivityInstance());
+        assertThat(savior.getPresenterCount()).isEqualTo(1);
+
+        final String id2 = savior.save(presenter2, hostingActivity.getMockActivityInstance());
+
+        // Then the ids are different
+        assertThat(id2).isNotEqualTo(id);
+        assertThat(savior.getPresenterCount()).isEqualTo(2);
+
+        // and both share the same scope
+        assertThat(savior.mScopes).hasSize(1);
+
+        // When the Activity finishes
+        hostingActivity.setFinishing(true);
+
+        // fragments are in backstack and can't report Activity finish
+        // ActivityLifecycleCallbacks observe activity finish
+        savior.mActivityInstanceObserver.onActivityDestroyed(
+                hostingActivity.getMockActivityInstance());
+
+        assertThat(savior.getPresenterCount()).isEqualTo(0);
+        assertThat(savior.mScopes).isEmpty();
+    }
+
+    @Test
+    public void clearScopeWhenActivityFinishes() throws Exception {
+        final TestPresenterSavior savior = new TestPresenterSavior();
+
+        // Save two presenters in two activities in savior
+        final HostingActivity hostingActivity = new HostingActivity();
+        final TiPresenter presenter = new TiPresenter() {
+        };
+        final String id = savior.save(presenter, hostingActivity.getMockActivityInstance());
+        assertThat(savior.getPresenterCount()).isEqualTo(1);
+        assertThat(savior.mScopes).hasSize(1);
+
+        // save second
+        final HostingActivity hostingActivity2 = new HostingActivity();
+        final TiPresenter presenter2 = new TiPresenter() {
+        };
+        final String id2 = savior.save(presenter2, hostingActivity2.getMockActivityInstance());
+        assertThat(savior.getPresenterCount()).isEqualTo(2);
+        assertThat(savior.mScopes).hasSize(2);
+
+        // When removing the first
+        savior.free(id, hostingActivity.getMockActivityInstance());
+        assertThat(savior.getPresenterCount()).isEqualTo(1);
+
+        // Then only 1 scope is left, the other got removed
+        assertThat(savior.mScopes).hasSize(1);
+
+        // When removing the second
+        savior.free(id2, hostingActivity2.getMockActivityInstance());
+
+        // Then no scopes are left
+        assertThat(savior.getPresenterCount()).isEqualTo(0);
+        assertThat(savior.mScopes).isEmpty();
+
+        // the observer is also cleaned up
+        assertThat(savior.mActivityInstanceObserver).isNull();
+    }
+
+    @Test
+    public void detectFinishingActivity() throws Exception {
+        final TestPresenterSavior savior = new TestPresenterSavior();
+
+        final HostingActivity hostingActivity = new HostingActivity();
+        final TiPresenter presenter = new TiPresenter() {
+        };
+        final String id = savior.save(presenter, hostingActivity.getMockActivityInstance());
+        assertThat(savior.getPresenterCount()).isEqualTo(1);
+        assertThat(id).isNotEmpty().isNotNull();
+
+        hostingActivity.setFinishing(true);
+        savior.mActivityInstanceObserver
+                .onActivityDestroyed(hostingActivity.getMockActivityInstance());
+
+        assertThat(savior.getPresenterCount()).isEqualTo(0);
+        assertThat(savior.mScopes).isEmpty();
+    }
+
+    @Test
+    public void freePresenter() throws Exception {
+
+        final TestPresenterSavior savior = new TestPresenterSavior();
+
+        final HostingActivity hostingActivity = new HostingActivity();
+        final TiPresenter presenter = new TiPresenter() {
+        };
+        final String id = savior.save(presenter, hostingActivity.getMockActivityInstance());
+        assertThat(savior.getPresenterCount()).isEqualTo(1);
+
+        savior.free(id, hostingActivity.getMockActivityInstance());
+        assertThat(savior.getPresenterCount()).isEqualTo(0);
+    }
+
+    @Test
+    public void freePresenterSaveAgain() throws Exception {
+
+        final TestPresenterSavior savior = new TestPresenterSavior();
+
+        final HostingActivity hostingActivity = new HostingActivity();
+        final TiPresenter presenter = new TiPresenter() {
+        };
+        final String id = savior.save(presenter, hostingActivity.getMockActivityInstance());
+        assertThat(savior.getPresenterCount()).isEqualTo(1);
+
+        savior.free(id, hostingActivity.getMockActivityInstance());
+        assertThat(savior.getPresenterCount()).isEqualTo(0);
+
+        final String id2 = savior.save(presenter, hostingActivity.getMockActivityInstance());
+        assertThat(id2).isNotEqualTo(id);
+
+        assertThat(savior.getPresenterCount()).isEqualTo(1);
+    }
+
+    @Test
+    public void freePresenterTwice() throws Exception {
+
+        final TestPresenterSavior savior = new TestPresenterSavior();
+
+        final HostingActivity hostingActivity = new HostingActivity();
+        final TiPresenter presenter = new TiPresenter() {
+        };
+        final String id = savior.save(presenter, hostingActivity.getMockActivityInstance());
+        assertThat(savior.getPresenterCount()).isEqualTo(1);
+
+        savior.free(id, hostingActivity.getMockActivityInstance());
+        assertThat(savior.getPresenterCount()).isEqualTo(0);
+        assertThat(savior.mScopes).isEmpty();
+
+        // free again should do nothing
+        savior.free(id, hostingActivity.getMockActivityInstance());
+        assertThat(savior.getPresenterCount()).isEqualTo(0);
+        assertThat(savior.mScopes).isEmpty();
+    }
+
+    @Test
+    public void freePresenterWithDifferentActivity() throws Exception {
+
+        final TestPresenterSavior savior = new TestPresenterSavior();
+
+        final HostingActivity hostingActivity = new HostingActivity();
+        final TiPresenter presenter = new TiPresenter() {
+        };
+        final String id = savior.save(presenter, hostingActivity.getMockActivityInstance());
+        assertThat(savior.getPresenterCount()).isEqualTo(1);
+
+        final HostingActivity hostingActivity2 = new HostingActivity();
+        savior.free(id, hostingActivity2.getMockActivityInstance());
+        assertThat(savior.getPresenterCount()).isEqualTo(1);
+    }
+
+    @Test
+    public void ignoreWhenActivityChangesConfiguration() throws Exception {
+        final TestPresenterSavior savior = new TestPresenterSavior();
+
+        final HostingActivity hostingActivity = new HostingActivity();
+        final TiPresenter presenter = new TiPresenter() {
+        };
+        final String id = savior.save(presenter, hostingActivity.getMockActivityInstance());
+        assertThat(savior.getPresenterCount()).isEqualTo(1);
+        assertThat(id).isNotEmpty().isNotNull();
+
+        hostingActivity.setChangingConfiguration(true);
+        savior.mActivityInstanceObserver
+                .onActivityDestroyed(hostingActivity.getMockActivityInstance());
+
+        assertThat(savior.getPresenterCount()).isEqualTo(1);
+    }
+
+    @Test
+    public void ignoreWhenActivityRecreates() throws Exception {
+        final TestPresenterSavior savior = new TestPresenterSavior();
+
+        final HostingActivity hostingActivity = new HostingActivity();
+        final TiPresenter presenter = new TiPresenter() {
+        };
+        final String id = savior.save(presenter, hostingActivity.getMockActivityInstance());
+        assertThat(savior.getPresenterCount()).isEqualTo(1);
+        assertThat(id).isNotEmpty().isNotNull();
+
+        savior.mActivityInstanceObserver
+                .onActivityDestroyed(hostingActivity.getMockActivityInstance());
+
+        assertThat(savior.getPresenterCount()).isEqualTo(1);
+    }
+
+    @Test
+    public void recoverKeyWithNewActivity() throws Exception {
+        final TestPresenterSavior savior = new TestPresenterSavior();
+
+        final HostingActivity hostingActivity = new HostingActivity();
+        final TiPresenter presenter = new TiPresenter() {
+        };
+        final String id = savior.save(presenter, hostingActivity.getMockActivityInstance());
+
+        // Activity changes configuration
+        hostingActivity.isChangingConfiguration();
+        savior.mActivityInstanceObserver.onActivitySaveInstanceState(
+                hostingActivity.getMockActivityInstance(), mSavedState);
+        final String scopeId = fakeBundle.get(ActivityInstanceObserver.TI_ACTIVITY_ID_KEY);
+        assertThat(scopeId).isNotNull();
+        savior.mActivityInstanceObserver
+                .onActivityDestroyed(hostingActivity.getMockActivityInstance());
+        assertThat(savior.getPresenterCount()).isEqualTo(1);
+
+        // new Activity instance gets created
+        final HostingActivity hostingActivity2 = new HostingActivity();
+        savior.mActivityInstanceObserver.onActivityCreated(
+                hostingActivity2.getMockActivityInstance(), mSavedState);
+
+        // recover with new Activity
+        final TiPresenter recover = savior.recover(id, hostingActivity2.getMockActivityInstance());
+        assertThat(recover).isEqualTo(presenter);
+    }
+
+    @Test
+    public void restoreFailWithDifferentActivity() throws Exception {
+
+        final TestPresenterSavior savior = new TestPresenterSavior();
+
+        final HostingActivity hostingActivity = new HostingActivity();
+        final TiPresenter presenter = new TiPresenter() {
+        };
+        final String id = savior.save(presenter, hostingActivity.getMockActivityInstance());
+        assertThat(savior.getPresenterCount()).isEqualTo(1);
+
+        final HostingActivity hostingActivity2 = new HostingActivity();
+        final TiPresenter recovered = savior
+                .recover(id, hostingActivity2.getMockActivityInstance());
+        assertThat(recovered).isNull();
+        assertThat(savior.getPresenterCount()).isEqualTo(1);
+    }
+
+    @Test
+    public void restoreFromSavior() throws Exception {
+
+        final TestPresenterSavior savior = new TestPresenterSavior();
+
+        final HostingActivity hostingActivity = new HostingActivity();
+        final TiPresenter presenter = new TiPresenter() {
+        };
+        final String id = savior.save(presenter, hostingActivity.getMockActivityInstance());
+        assertThat(savior.getPresenterCount()).isEqualTo(1);
+
+        final TiPresenter recovered = savior.recover(id, hostingActivity.getMockActivityInstance());
+        assertThat(recovered).isEqualTo(presenter);
+        assertThat(savior.getPresenterCount()).isEqualTo(1);
+    }
+
+    @Test
+    public void saveToSavior() throws Exception {
+
+        final TestPresenterSavior savior = new TestPresenterSavior();
+
+        final HostingActivity hostingActivity = new HostingActivity();
+        final TiPresenter presenter = new TiPresenter() {
+        };
+        final String id = savior.save(presenter, hostingActivity.getMockActivityInstance());
+        assertThat(savior.getPresenterCount()).isEqualTo(1);
+        assertThat(id).isNotEmpty().isNotNull();
+    }
+
+    @Before
+    public void setUp() throws Exception {
+        mSavedState = mock(Bundle.class);
+        doAnswer(saveInMap()).when(mSavedState).putString(anyString(), anyString());
+        doAnswer(getFromMap()).when(mSavedState).getString(anyString());
+    }
+
+    @NonNull
+    private Answer getFromMap() {
+        return new Answer() {
+            @Override
+            public String answer(final InvocationOnMock invocation) throws Throwable {
+                final Object[] args = invocation.getArguments();
+                //noinspection RedundantCast
+                return fakeBundle.get((String) args[0]);
+            }
+        };
+    }
+
+    @NonNull
+    private Answer saveInMap() {
+        return new Answer() {
+            @Override
+            public Object answer(final InvocationOnMock invocation) throws Throwable {
+                final Object[] args = invocation.getArguments();
+                fakeBundle.put((String) args[0], (String) args[1]);
+                return null;
+            }
+        };
+    }
+}
\ No newline at end of file
diff --git a/thirtyinch/src/test/java/net/grandcentrix/thirtyinch/internal/SingleTiFragmentPresenterDestroyTest.java b/thirtyinch/src/test/java/net/grandcentrix/thirtyinch/internal/SingleTiFragmentPresenterDestroyTest.java
new file mode 100644
index 00000000..a6f35dce
--- /dev/null
+++ b/thirtyinch/src/test/java/net/grandcentrix/thirtyinch/internal/SingleTiFragmentPresenterDestroyTest.java
@@ -0,0 +1,665 @@
+/*
+ * Copyright (C) 2017 grandcentrix GmbH
+ * 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.
+ */
+
+package net.grandcentrix.thirtyinch.internal;
+
+import net.grandcentrix.thirtyinch.TiConfiguration;
+import net.grandcentrix.thirtyinch.TiPresenter;
+import net.grandcentrix.thirtyinch.TiView;
+
+import org.junit.Test;
+
+import android.support.annotation.NonNull;
+import android.view.LayoutInflater;
+
+import static org.assertj.core.api.Java6Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+
+public class SingleTiFragmentPresenterDestroyTest extends AbstractPresenterDestroyTest {
+
+    /**
+     * Activity changing configuration without retain
+     */
+    @Test
+    public void activityChangingConfiguration_retainFalse() {
+
+        final HostingActivity hostingActivity = new HostingActivity();
+
+        // Given a Presenter that does not retain itself.
+        final TestPresenter presenter = new TestPresenter(new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(false)
+                .build());
+
+        // And given a Fragment.
+        final TestTiFragment fragment = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(false)
+                .setHostingActivity(hostingActivity)
+                .setSavior(mSavior)
+                .setPresenter(presenter)
+                .build();
+
+        // When the Fragment is added to the Activity.
+        fragment.onCreate(null);
+        fragment.setAdded(true);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // Then the presenter will *not* be stored in the savior
+        // and the savior has no detector initialized
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+        assertThat(mSavior.mActivityInstanceObserver).isNull();
+
+        // And when the Activity is changing its configuration.
+        hostingActivity.setChangingConfiguration(true);
+        fragment.onSaveInstanceState(mFragmentSavedState);
+        fragment.onStop();
+        fragment.onDestroyView();
+        fragment.onDestroy();
+
+        // Then assert that the presenter is destroyed and not saved in the savior.
+        assertThat(fragment.getPresenter().isDestroyed()).isTrue();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+        assertThat(mSavior.mActivityInstanceObserver).isNull();
+
+        // When the Activity is recreated.
+        final HostingActivity hostingActivity2 = new HostingActivity();
+
+        // And generates a new Fragment instance.
+        final TestPresenter presenter2 = new TestPresenter(new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(false)
+                .build());
+        final TestTiFragment fragment2 = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(false)
+                .setHostingActivity(hostingActivity2)
+                .setSavior(mSavior)
+                .setPresenter(presenter2)
+                .build();
+
+        // And the fragment will be resumed
+        fragment2.setAdded(true);
+        fragment2.onCreate(mFragmentSavedState);
+        fragment2.onCreateView(mock(LayoutInflater.class), null, mFragmentSavedState);
+        fragment2.onStart();
+
+        // Then a new Presenter instance will be generated and the old presenter isn't used
+        assertThat(fragment2.getPresenter()).isNotEqualTo(presenter).isEqualTo(presenter2);
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+    }
+
+    /**
+     * Activity changing configuration
+     * Default config
+     */
+    @Test
+    public void activityChangingConfiguration_retainTrue() {
+
+        final HostingActivity hostingActivity = new HostingActivity();
+
+        // Check that the default config matches this test case
+        final TiConfiguration config = new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(true)
+                .build();
+        assertThat(TiConfiguration.DEFAULT).isEqualTo(config);
+
+        // Given a Presenter that uses a static savior to retain itself (default config).
+        final TestPresenter presenter = new TestPresenter(config);
+
+        // And given a Fragment.
+        final TestTiFragment fragment = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(false)
+                .setHostingActivity(hostingActivity)
+                .setSavior(mSavior)
+                .setPresenter(presenter)
+                .build();
+
+        // When the Fragment is added to the Activity.
+        fragment.onCreate(null);
+        fragment.setAdded(true);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // Then the presenter will be stored in the savior
+        assertThat(mSavior.getPresenterCount()).isEqualTo(1);
+
+        // And when the Activity is changing its configurations.
+        hostingActivity.setChangingConfiguration(true);
+        mSavior.mActivityInstanceObserver.onActivitySaveInstanceState(
+                hostingActivity.getMockActivityInstance(), mActivitySavedState);
+        fragment.onSaveInstanceState(mFragmentSavedState);
+        fragment.onStop();
+        fragment.onDestroyView();
+        fragment.onDestroy();
+
+        // Then the presenter will be retained and saved in the savior.
+        assertThat(fragment.getPresenter().isDestroyed()).isFalse();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(1);
+
+        // When the Activity is recreated.
+        final HostingActivity hostingActivity2 = new HostingActivity();
+        mSavior.mActivityInstanceObserver.onActivityCreated(
+                hostingActivity2.getMockActivityInstance(), mActivitySavedState);
+
+        // And generates a new Fragment instance.
+        final TestPresenter presenter2 = new TestPresenter(new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(false)
+                .build());
+        final TestTiFragment fragment2 = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(false)
+                .setHostingActivity(hostingActivity2)
+                .setSavior(mSavior)
+                .setPresenter(presenter2)
+                .build();
+
+        // And the fragment will be resumed
+        fragment2.setAdded(true);
+        fragment2.onCreate(mFragmentSavedState);
+        fragment2.onCreateView(mock(LayoutInflater.class), null, mFragmentSavedState);
+        fragment2.onStart();
+
+        // Then the Presenter is the same
+        assertThat(fragment.getPresenter().isDestroyed()).isFalse();
+        assertThat(fragment.getPresenter()).isEqualTo(presenter);
+        assertThat(mSavior.getPresenterCount()).isEqualTo(1);
+    }
+
+    /**
+     * Activity finishing without retain
+     */
+    @Test
+    public void activityFinishing_retainFalse() {
+
+        final HostingActivity hostingActivity = new HostingActivity();
+
+        // Given a Presenter without retain.
+        final TestPresenter presenter = new TestPresenter(new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(false)
+                .build());
+
+        // And given a Fragment.
+        final TestTiFragment fragment = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(false)
+                .setHostingActivity(hostingActivity)
+                .setSavior(mSavior)
+                .setPresenter(presenter)
+                .build();
+
+        // When the Fragment is added to the Activity.
+        fragment.onCreate(null);
+        fragment.setAdded(true);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // Then the presenter will *not* be stored in the savior
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+
+        // And when the Activity is finishing.
+        hostingActivity.setFinishing(true);
+        fragment.onStop();
+        fragment.onDestroyView();
+        fragment.onDestroy();
+
+        // Then assert that the Presenter is destroyed and not saved in the savior.
+        assertThat(fragment.getPresenter().isDestroyed()).isTrue();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+    }
+
+    /**
+     * Activity finish
+     * Default config
+     */
+    @Test
+    public void activityFinishing_retainTrue() {
+
+        final HostingActivity hostingActivity = new HostingActivity();
+
+        // Check that the default config matches this test case
+        final TiConfiguration config = new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(true)
+                .build();
+        assertThat(TiConfiguration.DEFAULT).isEqualTo(config);
+
+        // Given a Presenter that uses a static savior to retain itself (default config).
+        final TestPresenter presenter = new TestPresenter(config);
+
+        // And given a Fragment.
+        final TestTiFragment fragment = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(false)
+                .setHostingActivity(hostingActivity)
+                .setSavior(mSavior)
+                .setPresenter(presenter)
+                .build();
+
+        // When the Fragment is added to the Activity.
+        fragment.onCreate(null);
+        fragment.setAdded(true);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // Then the presenter will be stored in the savior
+        assertThat(mSavior.getPresenterCount()).isEqualTo(1);
+
+        // And when the Activity is finishing.
+        hostingActivity.setFinishing(true);
+        fragment.onStop();
+        fragment.onDestroyView();
+        fragment.onDestroy();
+
+        // Then the presenter is destroyed and not saved in the savior.
+        assertThat(fragment.getPresenter().isDestroyed()).isTrue();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+    }
+
+    /**
+     * Activity move to background -> move to foreground without retain
+     */
+    @Test
+    public void moveToBackground_moveToForeground_retainFalse() {
+
+        final HostingActivity hostingActivity = new HostingActivity();
+
+        // Given a Presenter that does not retain itself.
+        final TestPresenter presenter = new TestPresenter(new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(false)
+                .build());
+
+        // And given a Fragment.
+        final TestTiFragment fragment = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(false)
+                .setHostingActivity(hostingActivity)
+                .setSavior(mSavior)
+                .setPresenter(presenter)
+                .build();
+
+        // When the Fragment is added to the Activity.
+        fragment.onCreate(null);
+        fragment.setAdded(true);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // Then the Presenter will *not* be stored in the savior
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+
+        // And when the Activity is moved to background
+        fragment.onSaveInstanceState(mFragmentSavedState);
+        fragment.onStop();
+
+        // Then the Presenter is not destroyed
+        assertThat(fragment.getPresenter().isDestroyed()).isFalse();
+
+        // And when the Activity moves to foreground again
+        fragment.onStart();
+
+        // Then the Presenter is still alive and not saved in savior
+        assertThat(fragment.getPresenter().isDestroyed()).isFalse();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+    }
+
+    /**
+     * Activity move to background -> move to foreground
+     * Default config
+     */
+    @Test
+    public void moveToBackground_moveToForeground_retainTrue() {
+
+        final HostingActivity hostingActivity = new HostingActivity();
+
+        // Check that the default config matches this test case
+        final TiConfiguration config = new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(true)
+                .build();
+        assertThat(TiConfiguration.DEFAULT).isEqualTo(config);
+
+        // Given a Presenter that uses a static savior to retain itself (default config).
+        final TestPresenter presenter = new TestPresenter(config);
+
+        // And given a Fragment.
+        final TestTiFragment fragment = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(false)
+                .setHostingActivity(hostingActivity)
+                .setSavior(mSavior)
+                .setPresenter(presenter)
+                .build();
+
+        // When the Fragment is added to the Activity.
+        fragment.onCreate(null);
+        fragment.setAdded(true);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // Then the presenter will be stored in the savior
+        assertThat(mSavior.getPresenterCount()).isEqualTo(1);
+
+        // And when the Activity is moved to background
+        fragment.onSaveInstanceState(mFragmentSavedState);
+        fragment.onStop();
+
+        // Then the presenter stays alive and is saved in the savior.
+        assertThat(fragment.getPresenter().isDestroyed()).isFalse();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(1);
+
+        // And the Fragment gets automatically retained.
+        fragment.onStart();
+
+        // Then the Presenter is the same
+        assertThat(fragment.getPresenter()).isEqualTo(presenter);
+        assertThat(fragment.getPresenter().isDestroyed()).isFalse();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(1);
+    }
+
+    /**
+     * removed the added fragment from the Activity without retain
+     */
+    @Test
+    public void remove_fragment_retainFalse() {
+
+        final HostingActivity hostingActivity = new HostingActivity();
+
+        // Given a Presenter does not retain itself.
+        final TestPresenter presenter = new TestPresenter(new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(false)
+                .build());
+
+        // And given a Fragment.
+        final TestTiFragment fragment = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(false)
+                .setHostingActivity(hostingActivity)
+                .setSavior(mSavior)
+                .setPresenter(presenter)
+                .build();
+
+        // When the Fragment is added to the Activity.
+        fragment.onCreate(null);
+        fragment.setAdded(true);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // Then the presenter will not be stored in the savior
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+
+        // When the fragment will be removed
+        fragment.setRemoving(true);
+        fragment.onStop();
+        fragment.onDestroyView();
+        fragment.onDestroy();
+
+        // Then the presenter is destroyed and not saved
+        assertThat(fragment.getPresenter().isDestroyed()).isTrue();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+    }
+
+    /**
+     * add fragment (with backstack) press back button to pop the back stack and the remove it
+     * without retain
+     */
+    @Test
+    public void remove_fragment_retainFalse_backstackTrue() {
+
+        final HostingActivity hostingActivity = new HostingActivity();
+
+        // Given a Presenter does not retain itself.
+        final TestPresenter presenter = new TestPresenter(new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(false)
+                .build());
+
+        // And given a Fragment.
+        final TestTiFragment fragment = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(false)
+                .setHostingActivity(hostingActivity)
+                .setSavior(mSavior)
+                .setPresenter(presenter)
+                .build();
+
+        // When the Fragment is added to the Activity.
+        fragment.setInBackstack(true);
+        fragment.onCreate(null);
+        fragment.setAdded(true);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // Then the presenter will not be stored in the savior
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+
+        // When the back button is pressed and the fragment will be removed
+        fragment.setRemoving(true);
+        fragment.onStop();
+        fragment.onDestroyView();
+
+        // Then the presenter is destroyed and not saved
+        assertThat(fragment.getPresenter().isDestroyed()).isFalse();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+
+        // When the back button is pressed again the fragment will be removed from the backstack
+        // and destroyed
+        fragment.setInBackstack(false);
+        fragment.onDestroy();
+
+        // Then the presenter is destroyed and not saved
+        assertThat(fragment.getPresenter().isDestroyed()).isTrue();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+    }
+
+    /**
+     * removed the added fragment from the Activity
+     * Default config
+     */
+    @Test
+    public void remove_fragment_retainTrue() {
+
+        final HostingActivity hostingActivity = new HostingActivity();
+
+        // Given a Presenter does not retain itself.
+        final TestPresenter presenter = new TestPresenter(new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(true)
+                .build());
+
+        // And given a Fragment.
+        final TestTiFragment fragment = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(false)
+                .setHostingActivity(hostingActivity)
+                .setSavior(mSavior)
+                .setPresenter(presenter)
+                .build();
+
+        // When the Fragment is added to the Activity.
+        fragment.onCreate(null);
+        fragment.setAdded(true);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // Then the presenter will be stored in the savior
+        assertThat(mSavior.getPresenterCount()).isEqualTo(1);
+
+        // When the fragment will be removed
+        fragment.setRemoving(true);
+        fragment.onStop();
+        fragment.onDestroyView();
+        fragment.onDestroy();
+
+        // Then the presenter is destroyed and not saved
+        assertThat(fragment.getPresenter().isDestroyed()).isTrue();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+    }
+
+    /**
+     * add fragment (with backstack) press back button to pop the back stack and the remove it
+     * Default config
+     */
+    @Test
+    public void remove_fragment_retainTrue_backstackTrue() {
+
+        final HostingActivity hostingActivity = new HostingActivity();
+
+        // Given a Presenter does not retain itself.
+        final TestPresenter presenter = new TestPresenter(new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(true)
+                .build());
+
+        // And given a Fragment.
+        final TestTiFragment fragment = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(false)
+                .setHostingActivity(hostingActivity)
+                .setSavior(mSavior)
+                .setPresenter(presenter)
+                .build();
+
+        // When the Fragment is added to the Activity.
+        fragment.setInBackstack(true);
+        fragment.onCreate(null);
+        fragment.setAdded(true);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // Then the presenter will be stored in the savior
+        assertThat(mSavior.getPresenterCount()).isEqualTo(1);
+
+        // When the back button is pressed and the fragment will be removed
+        fragment.setRemoving(true);
+        fragment.onStop();
+        fragment.onDestroyView();
+
+        // Then the presenter kept alive as long as the fragment is managed by the FragmentManager
+        assertThat(fragment.getPresenter().isDestroyed()).isFalse();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(1);
+
+        // When the back button is pressed again the fragment will be removed from the backstack
+        // and destroyed
+        fragment.setInBackstack(false);
+        fragment.onDestroy();
+
+        // Then the presenter is destroyed and not saved
+        assertThat(fragment.getPresenter().isDestroyed()).isTrue();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+    }
+
+    /**
+     * A fragment will be added to UI, then removed and added again resulting in two provideView
+     * calls
+     */
+    @Test
+    public void reuse_fragment_retainFalse() throws Exception {
+
+        final HostingActivity hostingActivity = new HostingActivity();
+
+        // Check that the default config matches this test case
+        final TiConfiguration config = new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(false)
+                .build();
+
+        // And given a Fragment.
+        final TestTiFragment fragment = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(false)
+                .setHostingActivity(hostingActivity)
+                .setSavior(mSavior)
+                .setPresenterProvider(new TiPresenterProvider<TiPresenter<TiView>>() {
+                    @NonNull
+                    @Override
+                    public TiPresenter<TiView> providePresenter() {
+                        return new TestPresenter(config);
+                    }
+                })
+                .build();
+
+        // When the Fragment is added to the Activity.
+        fragment.onCreate(null);
+        fragment.setAdded(true);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // Then the presenter will not stored in the savior
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+        final TiPresenter<TiView> firstPresenter = fragment.getPresenter();
+
+        // When the fragment will be removed from the Activity.
+        fragment.setAdded(false);
+        fragment.setRemoving(true);
+        fragment.onStop();
+        fragment.onDestroyView();
+        fragment.onDestroy();
+
+        // Then the presenter is removed from the savior and the presenter gets destroyed
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+        assertThat(fragment.getPresenter().isDestroyed()).isTrue();
+
+        // When the same fragment instance is added again
+        fragment.onCreate(null);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // A new presenter is generated.
+        assertThat(fragment.getPresenter().isDestroyed()).isFalse();
+        assertThat(fragment.getPresenter()).isNotEqualTo(firstPresenter);
+    }
+
+    /**
+     * A fragment will be added to UI, then removed and added again resulting in two provideView
+     * calls
+     * Default config
+     */
+    @Test
+    public void reuse_fragment_retainTrue() throws Exception {
+
+        final HostingActivity hostingActivity = new HostingActivity();
+
+        // Check that the default config matches this test case
+        final TiConfiguration config = new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(true)
+                .build();
+        assertThat(TiConfiguration.DEFAULT).isEqualTo(config);
+
+        // And given a Fragment.
+        final TestTiFragment fragment = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(false)
+                .setHostingActivity(hostingActivity)
+                .setSavior(mSavior)
+                .setPresenterProvider(new TiPresenterProvider<TiPresenter<TiView>>() {
+                    @NonNull
+                    @Override
+                    public TiPresenter<TiView> providePresenter() {
+                        return new TestPresenter(config);
+                    }
+                })
+                .build();
+
+        // When the Fragment is added to the Activity.
+        fragment.onCreate(null);
+        fragment.setAdded(true);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // Then the presenter will be stored in the savior
+        assertThat(mSavior.getPresenterCount()).isEqualTo(1);
+        final TiPresenter<TiView> firstPresenter = fragment.getPresenter();
+
+        // When the fragment will be removed from the Activity.
+        fragment.setAdded(false);
+        fragment.setRemoving(true);
+        fragment.onStop();
+        fragment.onDestroyView();
+        fragment.onDestroy();
+
+        // Then the presenter is removed from the savior and the presenter gets destroyed
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+        assertThat(fragment.getPresenter().isDestroyed()).isTrue();
+
+        // When the same fragment instance is added again
+        fragment.onCreate(null);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // A new presenter is generated.
+        assertThat(fragment.getPresenter().isDestroyed()).isFalse();
+        assertThat(fragment.getPresenter()).isNotEqualTo(firstPresenter);
+    }
+}
diff --git a/thirtyinch/src/test/java/net/grandcentrix/thirtyinch/internal/SingleTiFragmentPresenterDestroyTestIgnoreKeepDontKeepActivities.java b/thirtyinch/src/test/java/net/grandcentrix/thirtyinch/internal/SingleTiFragmentPresenterDestroyTestIgnoreKeepDontKeepActivities.java
new file mode 100644
index 00000000..8ef62d9b
--- /dev/null
+++ b/thirtyinch/src/test/java/net/grandcentrix/thirtyinch/internal/SingleTiFragmentPresenterDestroyTestIgnoreKeepDontKeepActivities.java
@@ -0,0 +1,602 @@
+/*
+ * Copyright (C) 2017 grandcentrix GmbH
+ * 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.
+ */
+
+package net.grandcentrix.thirtyinch.internal;
+
+import net.grandcentrix.thirtyinch.TiConfiguration;
+import net.grandcentrix.thirtyinch.TiPresenter;
+import net.grandcentrix.thirtyinch.TiView;
+
+import org.junit.Test;
+
+import android.support.annotation.NonNull;
+import android.view.LayoutInflater;
+
+import static org.assertj.core.api.Java6Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+
+/**
+ * Same test cases as {@link SingleTiFragmentPresenterDestroyTest} but with the "don't keep
+ * Activities option enabled". This means that the lifecycle may be different but the final
+ * assertions must be identical
+ */
+public class SingleTiFragmentPresenterDestroyTestIgnoreKeepDontKeepActivities
+        extends AbstractPresenterDestroyTest {
+
+    /**
+     * Activity changing configuration without retain (don't keep Activities enabled)
+     */
+    @Test
+    public void activityChangingConfiguration_retainFalse_dkATrue() {
+
+        final HostingActivity hostingActivity = new HostingActivity();
+
+        // Given a Presenter that does use a static savior but does not retain itself.
+        final TestPresenter presenter = new TestPresenter(new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(false)
+                .build());
+
+        // And given a Fragment.
+        final TestTiFragment fragment = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(true)
+                .setHostingActivity(hostingActivity)
+                .setSavior(mSavior)
+                .setPresenter(presenter)
+                .build();
+
+        // When the Fragment is added to the Activity.
+        fragment.onCreate(null);
+        fragment.setAdded(true);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // Then the presenter will *not* be stored in the savior
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+        assertThat(mSavior.mActivityInstanceObserver).isNull();
+
+        // And when the Activity is changing its configuration.
+        hostingActivity.setChangingConfiguration(true);
+        fragment.onSaveInstanceState(mFragmentSavedState);
+        fragment.onStop();
+        fragment.onDestroyView();
+        fragment.onDestroy();
+
+        // Then assert that the presenter is destroyed and not saved in the savior.
+        assertThat(fragment.getPresenter().isDestroyed()).isTrue();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+        assertThat(mSavior.mActivityInstanceObserver).isNull();
+
+        // When the Activity is recreated.
+        final HostingActivity hostingActivity2 = new HostingActivity();
+
+        // And generates a new Fragment instance.
+        final TestPresenter presenter2 = new TestPresenter(new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(false)
+                .build());
+        final TestTiFragment fragment2 = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(true)
+                .setHostingActivity(hostingActivity2)
+                .setSavior(mSavior)
+                .setPresenter(presenter2)
+                .build();
+
+        // And the fragment will be resumed
+        fragment2.setAdded(true);
+        fragment2.onCreate(mFragmentSavedState);
+        fragment2.onCreateView(mock(LayoutInflater.class), null, mFragmentSavedState);
+        fragment2.onStart();
+
+        // Then a new Presenter instance will be generated and the old presenter isn't used
+        assertThat(fragment2.getPresenter()).isNotEqualTo(presenter).isEqualTo(presenter2);
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+    }
+
+    /**
+     * Activity changing configuration Default config (don't keep Activities enabled)
+     */
+    @Test
+    public void activityChangingConfiguration_retainTrue_dkATrue() {
+
+        final HostingActivity hostingActivity = new HostingActivity();
+
+        // Given a Presenter that uses a static savior to retain itself.
+        final TestPresenter presenter = new TestPresenter(new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(true)
+                .build());
+
+        // And given a Fragment.
+        final TestTiFragment fragment = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(true)
+                .setHostingActivity(hostingActivity)
+                .setSavior(mSavior)
+                .setPresenter(presenter)
+                .build();
+
+        // When the fragment is added to the activity.
+        fragment.onCreate(null);
+        fragment.setAdded(true);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // Then the presenter will be stored in the savior
+        assertThat(mSavior.getPresenterCount()).isEqualTo(1);
+
+        // And when the Activity is changing its configuration.
+        hostingActivity.setChangingConfiguration(true);
+        mSavior.mActivityInstanceObserver.onActivitySaveInstanceState(
+                hostingActivity.getMockActivityInstance(), mActivitySavedState);
+        fragment.onSaveInstanceState(mFragmentSavedState);
+        fragment.onStop();
+        fragment.onDestroyView();
+        fragment.onDestroy();
+
+        // Then the presenter will be retained and saved in the savior.
+        assertThat(fragment.getPresenter().isDestroyed()).isFalse();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(1);
+
+        // When the Activity is recreated.
+        final HostingActivity hostingActivity2 = new HostingActivity();
+        mSavior.mActivityInstanceObserver.onActivityCreated(
+                hostingActivity2.getMockActivityInstance(), mActivitySavedState);
+
+        // And generates a new Fragment instance.
+        final TestPresenter presenter2 = new TestPresenter(new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(false)
+                .build());
+        final TestTiFragment fragment2 = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(true)
+                .setHostingActivity(hostingActivity2)
+                .setSavior(mSavior)
+                .setPresenter(presenter2)
+                .build();
+
+        // And the fragment will be resumed
+        fragment2.setAdded(true);
+        fragment2.onCreate(mFragmentSavedState);
+        fragment2.onCreateView(mock(LayoutInflater.class), null, mFragmentSavedState);
+        fragment2.onStart();
+
+        // Then the Presenter is the same
+        assertThat(fragment.getPresenter().isDestroyed()).isFalse();
+        assertThat(fragment.getPresenter()).isEqualTo(presenter);
+        assertThat(mSavior.getPresenterCount()).isEqualTo(1);
+    }
+
+    /**
+     * Activity finishing without retain (don't keep Activities enabled)
+     */
+    @Test
+    public void activityFinishing_retainFalse_dkATrue() {
+
+        final HostingActivity hostingActivity = new HostingActivity();
+
+        // Given a Presenter without retain.
+        final TestPresenter presenter = new TestPresenter(new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(false)
+                .build());
+
+        // And given a Fragment.
+        final TestTiFragment fragment = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(true)
+                .setHostingActivity(hostingActivity)
+                .setSavior(mSavior)
+                .setPresenter(presenter)
+                .build();
+
+        // When the Fragment is added to the Activity.
+        fragment.onCreate(null);
+        fragment.setAdded(true);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // Then the presenter will *not* be stored in the savior
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+
+        // And when the Activity is finishing.
+        hostingActivity.setFinishing(true);
+        fragment.onStop();
+        fragment.onDestroyView();
+        fragment.onDestroy();
+
+        // Then assert that the Presenter is destroyed and not saved in the savior.
+        assertThat(fragment.getPresenter().isDestroyed()).isTrue();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+    }
+
+    /**
+     * Activity finish Default config (don't keep Activities enabled)
+     */
+    @Test
+    public void activityFinishing_retainTrue_dkATrue() {
+        final HostingActivity hostingActivity = new HostingActivity();
+
+        // Check that the default config matches this test case
+        final TiConfiguration config = new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(true)
+                .build();
+        assertThat(TiConfiguration.DEFAULT).isEqualTo(config);
+
+        // Given a Presenter that uses a static savior to retain itself (default config).
+        final TestPresenter presenter = new TestPresenter(config);
+
+        // And given a Fragment.
+        final TestTiFragment fragment = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(true)
+                .setHostingActivity(hostingActivity)
+                .setSavior(mSavior)
+                .setPresenter(presenter)
+                .build();
+
+        // When the Fragment is added to the Activity.
+        fragment.onCreate(null);
+        fragment.setAdded(true);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // Then the presenter will be stored in the savior
+        assertThat(mSavior.getPresenterCount()).isEqualTo(1);
+
+        // And when the Activity is finishing.
+        hostingActivity.setFinishing(true);
+        fragment.onStop();
+        fragment.onDestroyView();
+        fragment.onDestroy();
+
+        // Then the presenter is destroyed and not saved in the savior.
+        assertThat(fragment.getPresenter().isDestroyed()).isTrue();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+    }
+
+    /**
+     * Activity move to background -> move to foreground without retain(don't keep Activities
+     * enabled)
+     */
+    @Test
+    public void moveToBackground_moveToForeground_retainFalse_dkATrue() {
+
+        final HostingActivity hostingActivity = new HostingActivity();
+
+        // Given a Presenter that does use a static savior but does not retain itself.
+        final TestPresenter presenter = new TestPresenter(new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(false)
+                .build());
+
+        // And given a Fragment.
+        final TestTiFragment fragment = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(true)
+                .setHostingActivity(hostingActivity)
+                .setSavior(mSavior)
+                .setPresenter(presenter)
+                .build();
+
+        // When the Fragment is added to the Activity.
+        fragment.onCreate(null);
+        fragment.setAdded(true);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // Then the Presenter will *not* be stored in the savior
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+        assertThat(mSavior.mActivityInstanceObserver).isNull();
+
+        // When the Activity is moved to background
+        fragment.onSaveInstanceState(mFragmentSavedState);
+        fragment.onStop();
+        fragment.onDestroyView();
+        fragment.onDestroy();
+
+        // Then the Presenter gets destroyed.
+        assertThat(fragment.getPresenter().isDestroyed()).isTrue();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+
+        // When the Activity is recreated.
+        final HostingActivity hostingActivity2 = new HostingActivity();
+
+        // And generates a new Fragment instance.
+        final TestPresenter presenter2 = new TestPresenter(new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(false)
+                .build());
+        final TestTiFragment fragment2 = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(true)
+                .setHostingActivity(hostingActivity2)
+                .setSavior(mSavior)
+                .setPresenter(presenter2)
+                .build();
+
+        fragment2.setAdded(true);
+        fragment2.onCreate(mFragmentSavedState);
+        fragment2.onCreateView(mock(LayoutInflater.class), null, mFragmentSavedState);
+        fragment2.onStart();
+
+        // Then the new Presenter does not equals the previous Presenter.
+        assertThat(fragment2.getPresenter()).isNotEqualTo(presenter).isEqualTo(presenter2);
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+    }
+
+    /**
+     * Activity move to background -> move to foreground Default config (don't keep Activities
+     * enabled)
+     */
+    @Test
+    public void moveToBackground_moveToForeground_retainTrue_dkATrue() {
+
+        final HostingActivity hostingActivity = new HostingActivity();
+
+        // Given a Presenter that does use a static savior but does not retain itself.
+        final TestPresenter presenter = new TestPresenter(new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(true)
+                .build());
+
+        // And given a Fragment.
+        final TestTiFragment fragment = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(true)
+                .setHostingActivity(hostingActivity)
+                .setSavior(mSavior)
+                .setPresenter(presenter)
+                .build();
+
+        // When the Fragment is added to the Activity.
+        fragment.onCreate(null);
+        fragment.setAdded(true);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // Then the presenter will be stored in the savior
+        assertThat(mSavior.getPresenterCount()).isEqualTo(1);
+
+        // When the Activity gets moved to background
+        mSavior.mActivityInstanceObserver.onActivitySaveInstanceState(
+                hostingActivity.getMockActivityInstance(), mActivitySavedState);
+        fragment.onSaveInstanceState(mFragmentSavedState);
+        fragment.onStop();
+        fragment.onDestroyView();
+        fragment.onDestroy();
+
+        // Then the presenter stays alive and is saved in the savior.
+        assertThat(fragment.getPresenter().isDestroyed()).isFalse();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(1);
+
+        // When the Activity moves to foreground again
+        // A new Activity gets created by the Android Framework.
+        final HostingActivity hostingActivity2 = new HostingActivity();
+        mSavior.mActivityInstanceObserver.onActivityCreated(
+                hostingActivity2.getMockActivityInstance(), mActivitySavedState);
+
+        // And generates a new Fragment instance.
+        final TestPresenter presenter2 = new TestPresenter(new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(false)
+                .build());
+        final TestTiFragment fragment2 = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(true)
+                .setHostingActivity(hostingActivity2)
+                .setSavior(mSavior)
+                .setPresenter(presenter2)
+                .build();
+
+        fragment2.setAdded(true);
+        fragment2.onCreate(mFragmentSavedState);
+        fragment2.onCreateView(mock(LayoutInflater.class), null, mFragmentSavedState);
+        fragment2.onStart();
+
+        // Then the Presenter is the same as in the previous fragment instance
+        assertThat(fragment2.getPresenter()).isNotEqualTo(presenter2).isEqualTo(presenter);
+        assertThat(fragment2.getPresenter().isDestroyed()).isFalse();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(1);
+    }
+
+
+    /**
+     * removed the added fragment from the Activity without retain (don't keep Activities enabled)
+     */
+    @Test
+    public void remove_fragment_retainFalse_dkATrue() {
+
+        final HostingActivity hostingActivity = new HostingActivity();
+
+        // Given a Presenter does not retain itself.
+        final TestPresenter presenter = new TestPresenter(new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(false)
+                .build());
+
+        // And given a Fragment.
+        final TestTiFragment fragment = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(true)
+                .setHostingActivity(hostingActivity)
+                .setSavior(mSavior)
+                .setPresenter(presenter)
+                .build();
+
+        // When the Fragment is added to the Activity.
+        fragment.onCreate(null);
+        fragment.setAdded(true);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // Then the presenter will not be stored in the savior
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+
+        // When the fragment will be removed
+        fragment.setRemoving(true);
+        fragment.onStop();
+        fragment.onDestroyView();
+        fragment.onDestroy();
+
+        // Then the presenter is destroyed and not saved
+        assertThat(fragment.getPresenter().isDestroyed()).isTrue();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+    }
+
+
+    /**
+     * removed the added fragment from the Activity Default config (don't keep Activities enabled)
+     */
+    @Test
+    public void remove_fragment_retainTrue_dkATrue() {
+
+        final HostingActivity hostingActivity = new HostingActivity();
+
+        // Given a Presenter does not retain itself.
+        final TestPresenter presenter = new TestPresenter(new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(true)
+                .build());
+
+        // And given a Fragment.
+        final TestTiFragment fragment = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(true)
+                .setHostingActivity(hostingActivity)
+                .setSavior(mSavior)
+                .setPresenter(presenter)
+                .build();
+
+        // When the Fragment is added to the Activity.
+        fragment.onCreate(null);
+        fragment.setAdded(true);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // Then the presenter will be stored in the savior
+        assertThat(mSavior.getPresenterCount()).isEqualTo(1);
+
+        // When the fragment will be removed
+        fragment.setRemoving(true);
+        fragment.onStop();
+        fragment.onDestroyView();
+        fragment.onDestroy();
+
+        // Then the presenter is destroyed and not saved
+        assertThat(fragment.getPresenter().isDestroyed()).isTrue();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+    }
+
+    /**
+     * A fragment will be added to UI, then removed and added again resulting in two provideView
+     * calls
+     */
+    @Test
+    public void reuse_fragment_retainFalse() throws Exception {
+
+        final HostingActivity hostingActivity = new HostingActivity();
+
+        // Check that the default config matches this test case
+        final TiConfiguration config = new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(false)
+                .build();
+
+        // And given a Fragment.
+        final TestTiFragment fragment = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(true)
+                .setHostingActivity(hostingActivity)
+                .setSavior(mSavior)
+                .setPresenterProvider(new TiPresenterProvider<TiPresenter<TiView>>() {
+                    @NonNull
+                    @Override
+                    public TiPresenter<TiView> providePresenter() {
+                        return new TestPresenter(config);
+                    }
+                })
+                .build();
+
+        // When the Fragment is added to the Activity.
+        fragment.onCreate(null);
+        fragment.setAdded(true);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // Then the presenter will not stored in the savior
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+        final TiPresenter<TiView> firstPresenter = fragment.getPresenter();
+
+        // When the fragment will be removed from the Activity.
+        fragment.setAdded(false);
+        fragment.setRemoving(true);
+        fragment.onStop();
+        fragment.onDestroyView();
+        fragment.onDestroy();
+
+        // Then the presenter is removed from the savior and the presenter gets destroyed
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+        assertThat(fragment.getPresenter().isDestroyed()).isTrue();
+
+        // When the same fragment instance is added again
+        fragment.onCreate(null);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // A new presenter is generated.
+        assertThat(fragment.getPresenter().isDestroyed()).isFalse();
+        assertThat(fragment.getPresenter()).isNotEqualTo(firstPresenter);
+    }
+
+    /**
+     * A fragment will be added to UI, then removed and added again resulting in two provideView
+     * calls
+     * Default config
+     */
+    @Test
+    public void reuse_fragment_retainTrue() throws Exception {
+
+        final HostingActivity hostingActivity = new HostingActivity();
+
+        // Check that the default config matches this test case
+        final TiConfiguration config = new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(true)
+                .build();
+        assertThat(TiConfiguration.DEFAULT).isEqualTo(config);
+
+        // And given a Fragment.
+        final TestTiFragment fragment = new TestTiFragment.Builder()
+                .setDontKeepActivitiesEnabled(true)
+                .setHostingActivity(hostingActivity)
+                .setSavior(mSavior)
+                .setPresenterProvider(new TiPresenterProvider<TiPresenter<TiView>>() {
+                    @NonNull
+                    @Override
+                    public TiPresenter<TiView> providePresenter() {
+                        return new TestPresenter(config);
+                    }
+                })
+                .build();
+
+        // When the Fragment is added to the Activity.
+        fragment.onCreate(null);
+        fragment.setAdded(true);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // Then the presenter will be stored in the savior
+        assertThat(mSavior.getPresenterCount()).isEqualTo(1);
+        final TiPresenter<TiView> firstPresenter = fragment.getPresenter();
+
+        // When the fragment will be removed from the Activity.
+        fragment.setAdded(false);
+        fragment.setRemoving(true);
+        fragment.onStop();
+        fragment.onDestroyView();
+        fragment.onDestroy();
+
+        // Then the presenter is removed from the savior and the presenter gets destroyed
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+        assertThat(fragment.getPresenter().isDestroyed()).isTrue();
+
+        // When the same fragment instance is added again
+        fragment.onCreate(null);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // A new presenter is generated.
+        assertThat(fragment.getPresenter().isDestroyed()).isFalse();
+        assertThat(fragment.getPresenter()).isNotEqualTo(firstPresenter);
+    }
+}
diff --git a/thirtyinch/src/test/java/net/grandcentrix/thirtyinch/internal/TestPresenterSavior.java b/thirtyinch/src/test/java/net/grandcentrix/thirtyinch/internal/TestPresenterSavior.java
new file mode 100644
index 00000000..01011a1f
--- /dev/null
+++ b/thirtyinch/src/test/java/net/grandcentrix/thirtyinch/internal/TestPresenterSavior.java
@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2017 grandcentrix GmbH
+ * 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.
+ */
+
+package net.grandcentrix.thirtyinch.internal;
+
+
+/**
+ * adds some functions for testing
+ */
+public class TestPresenterSavior extends PresenterSavior {
+
+    public int getPresenterCount() {
+        if (mScopes.isEmpty()) {
+            return 0;
+        }
+
+        int size = 0;
+        for (final ActivityScopedPresenters scope : mScopes.values()) {
+            size += scope.size();
+        }
+        return size;
+    }
+}
diff --git a/thirtyinch/src/test/java/net/grandcentrix/thirtyinch/internal/TestTiActivity.java b/thirtyinch/src/test/java/net/grandcentrix/thirtyinch/internal/TestTiActivity.java
new file mode 100644
index 00000000..3c2056b0
--- /dev/null
+++ b/thirtyinch/src/test/java/net/grandcentrix/thirtyinch/internal/TestTiActivity.java
@@ -0,0 +1,166 @@
+/*
+ * Copyright (C) 2017 grandcentrix GmbH
+ * 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.
+ */
+
+package net.grandcentrix.thirtyinch.internal;
+
+
+import net.grandcentrix.thirtyinch.TiPresenter;
+import net.grandcentrix.thirtyinch.TiView;
+
+import android.app.Activity;
+import android.content.res.Configuration;
+import android.os.Bundle;
+import android.support.annotation.NonNull;
+
+import java.util.concurrent.Executor;
+
+import static org.mockito.Mockito.mock;
+
+/**
+ * mock implementation of a {@link Activity} with all relevant lifecycle methods instructing the
+ * {@link TiActivityDelegate} for testing
+ */
+public class TestTiActivity
+        implements DelegatedTiActivity<TiPresenter<TiView>>, TiViewProvider<TiView>,
+        PresenterAccessor<TiPresenter<TiView>, TiView> {
+
+    public static final class Builder {
+
+        private TiPresenter<TiView> mPresenter;
+
+        private TiPresenterProvider<TiPresenter<TiView>> mPresenterProvider;
+
+        private TiPresenterSavior mSavior = new PresenterSavior();
+
+        public Builder() {
+        }
+
+        public TestTiActivity build() {
+            TiPresenterProvider<TiPresenter<TiView>> presenterProvider = mPresenterProvider;
+            if (presenterProvider == null) {
+                presenterProvider = new TiPresenterProvider<TiPresenter<TiView>>() {
+                    @NonNull
+                    @Override
+                    public TiPresenter<TiView> providePresenter() {
+                        return mPresenter;
+                    }
+                };
+            }
+            return new TestTiActivity(presenterProvider, mSavior);
+        }
+
+        public Builder setPresenter(TiPresenter<TiView> presenter) {
+            mPresenter = presenter;
+            return this;
+        }
+
+        public Builder setPresenterProvider(
+                TiPresenterProvider<TiPresenter<TiView>> provider) {
+            mPresenterProvider = provider;
+            return this;
+        }
+
+        public Builder setSavior(final TiPresenterSavior savior) {
+            mSavior = savior;
+            return this;
+        }
+    }
+
+    private final TiActivityDelegate<TiPresenter<TiView>, TiView> mDelegate;
+
+    private final HostingActivity mHostingActivity = new HostingActivity();
+
+
+    private TestTiActivity(final TiPresenterProvider<TiPresenter<TiView>> presenterProvider,
+            final TiPresenterSavior savior) {
+        mDelegate = new TiActivityDelegate<>(this, this, presenterProvider,
+                new TiLoggingTagProvider() {
+                    @Override
+                    public String getLoggingTag() {
+                        return "Test";
+                    }
+                }, savior);
+    }
+
+    @Override
+    public Activity getHostingActivity() {
+        return mHostingActivity.getMockActivityInstance();
+    }
+
+    @Override
+    public TiPresenter<TiView> getPresenter() {
+        return mDelegate.getPresenter();
+    }
+
+    @Override
+    public Executor getUiThreadExecutor() {
+        return new Executor() {
+            @Override
+            public void execute(@NonNull final Runnable action) {
+                action.run();
+            }
+        };
+    }
+
+    @Override
+    public boolean isActivityChangingConfigurations() {
+        return mHostingActivity.isChangingConfiguration();
+    }
+
+    @Override
+    public boolean isActivityFinishing() {
+        return mHostingActivity.isFinishing();
+    }
+
+    public void onConfigurationChanged() {
+        mDelegate.onConfigurationChanged_afterSuper(mock(Configuration.class));
+    }
+
+    public void onCreate(final Bundle saveInstanceState) {
+        mDelegate.onCreate_afterSuper(saveInstanceState);
+    }
+
+    public void onDestroy() {
+        mDelegate.onDestroy_afterSuper();
+    }
+
+    public void onSaveInstanceState(final Bundle outState) {
+        mDelegate.onSaveInstanceState_afterSuper(outState);
+    }
+
+    public void onStart() {
+        mDelegate.onStart_afterSuper();
+    }
+
+    public void onStop() {
+        mDelegate.onStop_beforeSuper();
+        mDelegate.onStop_afterSuper();
+    }
+
+    @NonNull
+    @Override
+    public TiView provideView() {
+        return mock(TiView.class);
+    }
+
+    public void setChangingConfiguration(final boolean changingConfiguration) {
+        mHostingActivity.setChangingConfiguration(changingConfiguration);
+    }
+
+    public void setFinishing(final boolean finishing) {
+        mHostingActivity.setFinishing(finishing);
+    }
+
+}
diff --git a/thirtyinch/src/test/java/net/grandcentrix/thirtyinch/internal/TestTiFragment.java b/thirtyinch/src/test/java/net/grandcentrix/thirtyinch/internal/TestTiFragment.java
new file mode 100644
index 00000000..b086de24
--- /dev/null
+++ b/thirtyinch/src/test/java/net/grandcentrix/thirtyinch/internal/TestTiFragment.java
@@ -0,0 +1,227 @@
+/*
+ * Copyright (C) 2017 grandcentrix GmbH
+ * 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.
+ */
+
+package net.grandcentrix.thirtyinch.internal;
+
+
+import net.grandcentrix.thirtyinch.TiPresenter;
+import net.grandcentrix.thirtyinch.TiView;
+
+import android.app.Activity;
+import android.os.Bundle;
+import android.support.annotation.NonNull;
+import android.view.LayoutInflater;
+import android.view.ViewGroup;
+
+import java.util.concurrent.Executor;
+
+import static org.mockito.Mockito.mock;
+
+
+/**
+ * mock implementation of a {@link android.support.v4.app.Fragment} with all relevant lifecycle
+ * methods instructing the {@link TiFragmentDelegate} for testing
+ */
+public class TestTiFragment
+        implements DelegatedTiFragment, TiViewProvider<TiView>,
+        PresenterAccessor<TiPresenter<TiView>, TiView> {
+
+    public static class Builder {
+
+        private HostingActivity mHostingActivity = new HostingActivity();
+
+        private boolean mIsDontKeepActivitiesEnabled = false;
+
+        private TiPresenter<TiView> mPresenter;
+
+        private TiPresenterProvider<TiPresenter<TiView>> mPresenterProvider;
+
+        private TiPresenterSavior mSavior = new PresenterSavior();
+
+        public TestTiFragment build() {
+            TiPresenterProvider<TiPresenter<TiView>> presenterProvider = mPresenterProvider;
+            if (presenterProvider == null) {
+                presenterProvider = new TiPresenterProvider<TiPresenter<TiView>>() {
+                    @NonNull
+                    @Override
+                    public TiPresenter<TiView> providePresenter() {
+                        return mPresenter;
+                    }
+                };
+            }
+
+            return new TestTiFragment(presenterProvider, mIsDontKeepActivitiesEnabled, mSavior,
+                    mHostingActivity);
+        }
+
+        public Builder setDontKeepActivitiesEnabled(final boolean enabled) {
+            mIsDontKeepActivitiesEnabled = enabled;
+            return this;
+        }
+
+        public Builder setHostingActivity(final HostingActivity hostingActivity) {
+            mHostingActivity = hostingActivity;
+            return this;
+        }
+
+        public Builder setPresenter(TiPresenter<TiView> presenter) {
+            mPresenter = presenter;
+            return this;
+        }
+
+        public Builder setPresenterProvider(
+                TiPresenterProvider<TiPresenter<TiView>> provider) {
+            mPresenterProvider = provider;
+            return this;
+        }
+
+        public Builder setSavior(final TiPresenterSavior savior) {
+            mSavior = savior;
+            return this;
+        }
+    }
+
+    private boolean mAdded = false;
+
+    private final TiFragmentDelegate mDelegate;
+
+    private boolean mDetached = false;
+
+    private final HostingActivity mHostingActivity;
+
+    private boolean mInBackstack;
+
+    private boolean mIsDontKeepActivitiesEnabled;
+
+    private boolean mRemoving;
+
+    private TestTiFragment(final TiPresenterProvider<TiPresenter<TiView>> presenterProvider,
+            final boolean isDontKeepActivitiesEnabled,
+            final TiPresenterSavior savior,
+            final HostingActivity hostingActivity) {
+
+        mDelegate = new TiFragmentDelegate<>(this, this, presenterProvider,
+                new TiLoggingTagProvider() {
+                    @Override
+                    public String getLoggingTag() {
+                        return "Test";
+                    }
+                }, savior);
+
+        mIsDontKeepActivitiesEnabled = isDontKeepActivitiesEnabled;
+        mHostingActivity = hostingActivity;
+    }
+
+    @Override
+    public Activity getHostingActivity() {
+        return mHostingActivity.getMockActivityInstance();
+    }
+
+    @Override
+    public TiPresenter<TiView> getPresenter() {
+        return mDelegate.getPresenter();
+    }
+
+    @Override
+    public Executor getUiThreadExecutor() {
+        return new Executor() {
+            @Override
+            public void execute(@NonNull final Runnable action) {
+                action.run();
+            }
+        };
+    }
+
+    @Override
+    public boolean isFragmentAdded() {
+        return mAdded;
+    }
+
+    @Override
+    public boolean isFragmentDetached() {
+        return mDetached;
+    }
+
+    @Override
+    public boolean isFragmentRemoving() {
+        return mRemoving;
+    }
+
+    @Override
+    public boolean isHostingActivityChangingConfigurations() {
+        return mHostingActivity.isChangingConfiguration();
+    }
+
+    @Override
+    public boolean isHostingActivityFinishing() {
+        return mHostingActivity.isFinishing();
+    }
+
+    @Override
+    public boolean isFragmentInBackstack() {
+        return mInBackstack;
+    }
+
+    public void onCreate(final Bundle saveInstanceState) {
+        mDelegate.onCreate_afterSuper(saveInstanceState);
+    }
+
+    public void onCreateView(final LayoutInflater inflater, final ViewGroup container,
+            final Bundle savedInstanceState) {
+        mDelegate.onCreateView_beforeSuper(inflater, container, savedInstanceState);
+    }
+
+    public void onDestroy() {
+        mDelegate.onDestroy_afterSuper();
+    }
+
+    public void onDestroyView() {
+        mDelegate.onDestroyView_beforeSuper();
+    }
+
+    public void onSaveInstanceState(final Bundle outState) {
+        mDelegate.onSaveInstanceState_afterSuper(outState);
+    }
+
+    public void onStart() {
+        mDelegate.onStart_afterSuper();
+    }
+
+    public void onStop() {
+        mDelegate.onStop_beforeSuper();
+    }
+
+    @NonNull
+    @Override
+    public TiView provideView() {
+        return mock(TiView.class);
+    }
+
+    public void setAdded(final boolean added) {
+        mAdded = added;
+    }
+
+    public void setDetached(final boolean detached) {
+        mDetached = detached;
+    }
+
+    public void setInBackstack(final boolean inBackstack) {
+        mInBackstack = inBackstack;
+    }
+
+    public void setRemoving(final boolean removing) {
+        mRemoving = removing;
+    }
+}
diff --git a/thirtyinch/src/test/java/net/grandcentrix/thirtyinch/internal/TiActivityDelegateBuilder.java b/thirtyinch/src/test/java/net/grandcentrix/thirtyinch/internal/TiActivityDelegateBuilder.java
deleted file mode 100644
index 878a08dc..00000000
--- a/thirtyinch/src/test/java/net/grandcentrix/thirtyinch/internal/TiActivityDelegateBuilder.java
+++ /dev/null
@@ -1,141 +0,0 @@
-/*
- * Copyright (C) 2017 grandcentrix GmbH
- * 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.
- */
-
-package net.grandcentrix.thirtyinch.internal;
-
-import net.grandcentrix.thirtyinch.TiPresenter;
-import net.grandcentrix.thirtyinch.TiView;
-
-import android.support.annotation.NonNull;
-import android.support.annotation.Nullable;
-
-import java.util.concurrent.Executor;
-
-import static org.mockito.Mockito.mock;
-
-public class TiActivityDelegateBuilder {
-
-    private boolean mIsChangingConfigurations = false;
-
-    private boolean mIsDontKeepActivitiesEnabled = false;
-
-    private boolean mIsFinishing = false;
-
-    private TiPresenter<TiView> mPresenter;
-
-    private TiPresenterProvider<TiPresenter<TiView>> mPresenterProvider;
-
-    private TiPresenterProvider<TiPresenter<TiView>> mRetainedPresenterProvider;
-
-    private TiPresenterSavior mSavior = new MockSavior();
-
-    public TiActivityDelegate<TiPresenter<TiView>, TiView> build() {
-        TiPresenterProvider<TiPresenter<TiView>> presenterProvider = mPresenterProvider;
-        if (presenterProvider == null) {
-            presenterProvider = new TiPresenterProvider<TiPresenter<TiView>>() {
-                @NonNull
-                @Override
-                public TiPresenter<TiView> providePresenter() {
-                    return mPresenter;
-                }
-            };
-        }
-
-        return new TiActivityDelegate<>(new DelegatedTiActivity<TiPresenter<TiView>>() {
-            @Nullable
-            @Override
-            public TiPresenter<TiView> getRetainedPresenter() {
-                if (mRetainedPresenterProvider == null) {
-                    return null;
-                }
-                return mRetainedPresenterProvider.providePresenter();
-            }
-
-            @Override
-            public Executor getUiThreadExecutor() {
-                return new Executor() {
-                    @Override
-                    public void execute(@NonNull final Runnable action) {
-                        action.run();
-                    }
-                };
-            }
-
-            @Override
-            public boolean isActivityChangingConfigurations() {
-                return mIsChangingConfigurations;
-            }
-
-            @Override
-            public boolean isActivityFinishing() {
-                return mIsFinishing;
-            }
-
-            @Override
-            public boolean isDontKeepActivitiesEnabled() {
-                return mIsDontKeepActivitiesEnabled;
-            }
-
-        }, new TiViewProvider<TiView>() {
-            @NonNull
-            @Override
-            public TiView provideView() {
-                return mock(TiView.class);
-            }
-        }, presenterProvider, new TiLoggingTagProvider() {
-            @Override
-            public String getLoggingTag() {
-                return "TestLogTag";
-            }
-        }, mSavior);
-    }
-
-    public TiActivityDelegateBuilder setDontKeepActivitiesEnabled(final boolean enabled) {
-        mIsDontKeepActivitiesEnabled = enabled;
-        return this;
-    }
-
-    public TiActivityDelegateBuilder setIsChangingConfigurations(final boolean changing) {
-        mIsChangingConfigurations = changing;
-        return this;
-    }
-
-    public TiActivityDelegateBuilder setIsFinishing(final boolean finishing) {
-        mIsFinishing = finishing;
-        return this;
-    }
-
-    public TiActivityDelegateBuilder setPresenter(TiPresenter<TiView> presenter) {
-        mPresenter = presenter;
-        return this;
-    }
-
-    public TiActivityDelegateBuilder setPresenterProvider(
-            TiPresenterProvider<TiPresenter<TiView>> provider) {
-        mPresenterProvider = provider;
-        return this;
-    }
-
-    public TiActivityDelegateBuilder setRetainedPresenterProvider(
-            TiPresenterProvider<TiPresenter<TiView>> retainedPresenterProvider) {
-        mRetainedPresenterProvider = retainedPresenterProvider;
-        return this;
-    }
-
-    public TiActivityDelegateBuilder setSavior(final TiPresenterSavior savior) {
-        mSavior = savior;
-        return this;
-    }
-}
diff --git a/thirtyinch/src/test/java/net/grandcentrix/thirtyinch/internal/TiActivityDelegateTest.java b/thirtyinch/src/test/java/net/grandcentrix/thirtyinch/internal/TiActivityDelegateTest.java
new file mode 100644
index 00000000..a9b8e5a6
--- /dev/null
+++ b/thirtyinch/src/test/java/net/grandcentrix/thirtyinch/internal/TiActivityDelegateTest.java
@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2017 grandcentrix GmbH
+ * 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.
+ */
+
+package net.grandcentrix.thirtyinch.internal;
+
+import net.grandcentrix.thirtyinch.TiConfiguration;
+
+import org.junit.Test;
+
+import static junit.framework.Assert.fail;
+import static org.assertj.core.api.Java6Assertions.assertThat;
+
+public class TiActivityDelegateTest extends AbstractPresenterDestroyTest {
+
+    @Test
+    public void provideReusedPresenter() throws Exception {
+
+        final TestPresenter reusedPresenter = new TestPresenter(TiConfiguration.DEFAULT);
+        // create the instance once, the presenter is now not in INITIALIZED state
+        reusedPresenter.create();
+
+        final TestTiActivity activity = new TestTiActivity.Builder()
+                .setPresenter(reusedPresenter)
+                .build();
+        try {
+            activity.onCreate(null);
+            fail("did not throw");
+        } catch (IllegalStateException e) {
+            assertThat(e).hasMessageContaining("Presenter not in initialized state")
+                    .hasMessageContaining("providePresenter");
+        }
+    }
+
+    @Test
+    public void provideDestroyedPresenter() throws Exception {
+        final TestPresenter destroyedPresenter = new TestPresenter(TiConfiguration.DEFAULT);
+        // make presenter destroyed
+        destroyedPresenter.create();
+        destroyedPresenter.destroy();
+
+        final TestTiActivity activity = new TestTiActivity.Builder()
+                .setPresenter(destroyedPresenter)
+                .build();
+        try {
+            activity.onCreate(null);
+            fail("did not throw");
+        } catch (IllegalStateException e) {
+            assertThat(e).hasMessageContaining("Presenter not in initialized state")
+                    .hasMessageContaining("providePresenter");
+        }
+    }
+}
\ No newline at end of file
diff --git a/thirtyinch/src/test/java/net/grandcentrix/thirtyinch/internal/TiActivityPresenterDestroyTest.java b/thirtyinch/src/test/java/net/grandcentrix/thirtyinch/internal/TiActivityPresenterDestroyTest.java
index bdf5a3dd..d6ba42ea 100644
--- a/thirtyinch/src/test/java/net/grandcentrix/thirtyinch/internal/TiActivityPresenterDestroyTest.java
+++ b/thirtyinch/src/test/java/net/grandcentrix/thirtyinch/internal/TiActivityPresenterDestroyTest.java
@@ -17,460 +17,526 @@
 
 
 import net.grandcentrix.thirtyinch.TiConfiguration;
-import net.grandcentrix.thirtyinch.TiPresenter;
-import net.grandcentrix.thirtyinch.TiView;
 
-import org.junit.After;
-import org.junit.Before;
 import org.junit.Test;
-import org.mockito.invocation.InvocationOnMock;
-import org.mockito.stubbing.Answer;
-
-import android.os.Bundle;
-import android.support.annotation.NonNull;
-
-import java.util.HashMap;
 
 import static org.assertj.core.api.Java6Assertions.assertThat;
-import static org.assertj.core.api.Java6Assertions.fail;
-import static org.mockito.Matchers.anyString;
-import static org.mockito.Mockito.doAnswer;
-import static org.mockito.Mockito.mock;
-
-public class TiActivityPresenterDestroyTest {
 
-    private class PutInMapAnswer implements Answer<Void> {
-
-        final HashMap<String, String> map = new HashMap<>();
-
-        @Override
-        public Void answer(InvocationOnMock invocation) throws Throwable {
-            final Object[] args = invocation.getArguments();
-            map.put((String) args[0], (String) args[1]);
-            return null;
-        }
-    }
-
-    private class TestPresenter extends TiPresenter<TiView> {
-
-        public TestPresenter(TiConfiguration config) {
-            super(config);
-        }
-    }
-
-    private MockSavior mSavior;
+public class TiActivityPresenterDestroyTest extends AbstractPresenterDestroyTest {
 
     @Test
-    public void saviorFalse_dontKeepActivitiesFalse_configurationChange() throws Exception {
+    public void configurationChange_retainFalse_dkAFalse() throws Exception {
         final TestPresenter presenter = new TestPresenter(new TiConfiguration.Builder()
-                .setUseStaticSaviorToRetain(false)
+                .setRetainPresenterEnabled(false)
                 .build());
 
-        final TiActivityDelegate<TiPresenter<TiView>, TiView> delegate = new TiActivityDelegateBuilder()
+        final TestTiActivity activity = new TestTiActivity.Builder()
                 .setPresenter(presenter)
-                .setIsFinishing(false)
-                .setIsChangingConfigurations(true)
-                .setDontKeepActivitiesEnabled(false)
                 .setSavior(mSavior)
                 .build();
 
-        final Bundle savedState = mock(Bundle.class);
-        final PutInMapAnswer putInMap = putInMap();
-        doAnswer(putInMap).when(savedState).putString(anyString(), anyString());
-
-        doFullLifecycleAndDestroy(delegate, savedState);
-
-        assertThat(putInMap.map).containsKey(TiActivityDelegate.SAVED_STATE_PRESENTER_ID);
-        assertThat(putInMap.map.get(TiActivityDelegate.SAVED_STATE_PRESENTER_ID)).isNull();
+        // When the Activity gets created
+        activity.onCreate(null);
+        assertThat(activity.getPresenter().isInitialized()).isTrue();
+        activity.onStart();
+        assertThat(activity.getPresenter().isDestroyed()).isFalse();
 
+        // Then the presenter is saved in savior
         assertThat(presenter.isDestroyed()).isFalse();
-        assertThat(mSavior.presenterCount()).isEqualTo(0);
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
 
-        delegate.onCreate_afterSuper(savedState);
-    }
+        // When the Activity changes configurations
+        activity.setFinishing(false);
+        activity.setChangingConfiguration(true);
+        activity.onStop();
+        assertThat(mSavior.mActivityInstanceObserver).isNull();
+        activity.onSaveInstanceState(mActivitySavedState);
+        activity.onDestroy();
 
-    @Test
-    public void saviorFalse_dontKeepActivitiesFalse_finish() throws Exception {
-        final TestPresenter presenter = new TestPresenter(new TiConfiguration.Builder()
-                .setUseStaticSaviorToRetain(false)
-                .build());
+        // Then the presenter is destroyed
+        assertThat(presenter.isDestroyed()).isTrue();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
 
-        final TiActivityDelegate<TiPresenter<TiView>, TiView> delegate = new TiActivityDelegateBuilder()
-                .setPresenter(presenter)
-                .setIsFinishing(true)
-                .setIsChangingConfigurations(false)
-                .setDontKeepActivitiesEnabled(false)
+        final TestPresenter presenter2 = new TestPresenter(new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(false)
+                .build());
+        // And recovered in the new instance
+        final TestTiActivity activity2 = new TestTiActivity.Builder()
                 .setSavior(mSavior)
+                .setPresenter(presenter2)
                 .build();
 
-        final Bundle savedState = mock(Bundle.class);
-        doFullLifecycleAndDestroy(delegate, savedState);
+        // When the new Activity instance gets created
+        assertThat(mSavior.mActivityInstanceObserver).isNull();
+        activity2.onCreate(mActivitySavedState);
+        activity2.onStart();
 
-        assertThat(presenter.isDestroyed()).isTrue();
-        assertThat(mSavior.presenterCount()).isEqualTo(0);
-
-        try {
-            // presenter is destroyed and cannot be recreated
-            delegate.onCreate_afterSuper(savedState);
-            fail("did not throw");
-        } catch (Exception e) {
-            assertThat(e).hasMessageContaining("destroyed");
-        }
+        // Then a new presenter gets created
+        assertThat(activity2.getPresenter()).isNotEqualTo(presenter);
     }
 
     @Test
-    public void saviorFalse_dontKeepActivitiesFalse_moveToBackground_moveToForeground()
-            throws Exception {
+    public void configurationChange_retainFalse_dkATrue() throws Exception {
         final TestPresenter presenter = new TestPresenter(new TiConfiguration.Builder()
-                .setUseStaticSaviorToRetain(false)
+                .setRetainPresenterEnabled(false)
                 .build());
 
-        final TiActivityDelegate<TiPresenter<TiView>, TiView> delegate = new TiActivityDelegateBuilder()
+        final TestTiActivity activity = new TestTiActivity.Builder()
                 .setPresenter(presenter)
-                .setIsFinishing(false)
-                .setIsChangingConfigurations(false)
-                .setDontKeepActivitiesEnabled(false)
                 .setSavior(mSavior)
                 .build();
 
-        final Bundle savedState = mock(Bundle.class);
-        delegate.onCreate_afterSuper(null);
-        // savior is disabled
-        assertThat(mSavior.presenterCount()).isEqualTo(0);
+        // When the Activity gets created
+        activity.onCreate(null);
+        assertThat(activity.getPresenter().isInitialized()).isTrue();
+        activity.onStart();
+        assertThat(activity.getPresenter().isDestroyed()).isFalse();
 
-        assertThat(delegate.getPresenter().isInitialized()).isTrue();
+        // Then the presenter is saved in savior
+        assertThat(presenter.isDestroyed()).isFalse();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
 
-        delegate.onStart_afterSuper();
+        // When the Activity changes configurations
+        activity.setFinishing(false);
+        activity.setChangingConfiguration(true);
+        activity.onStop();
+        assertThat(mSavior.mActivityInstanceObserver).isNull();
+        activity.onSaveInstanceState(mActivitySavedState);
+        activity.onDestroy();
 
-        assertThat(delegate.getPresenter().isDestroyed()).isFalse();
+        // Then the presenter is destroyed
+        assertThat(presenter.isDestroyed()).isTrue();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
 
-        delegate.onStop_beforeSuper();
-        delegate.onStop_afterSuper();
-        delegate.onSaveInstanceState_afterSuper(savedState);
+        final TestPresenter presenter2 = new TestPresenter(new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(false)
+                .build());
+        // And recovered in the new instance
+        final TestTiActivity activity2 = new TestTiActivity.Builder()
+                .setSavior(mSavior)
+                .setPresenter(presenter2)
+                .build();
 
-        delegate.onStart_afterSuper();
+        // When the new Activity instance gets created
+        assertThat(mSavior.mActivityInstanceObserver).isNull();
+        activity2.onCreate(mActivitySavedState);
+        activity2.onStart();
 
-        assertThat(presenter.isDestroyed()).isFalse();
-        assertThat(mSavior.presenterCount()).isEqualTo(0);
+        // Then a new presenter gets created
+        assertThat(activity2.getPresenter()).isNotEqualTo(presenter);
     }
 
     @Test
-    public void saviorFalse_dontKeepActivitiesTrue_configurationChange() throws Exception {
+    public void configurationChange_retainTrue_dkAFalse() throws Exception {
         final TestPresenter presenter = new TestPresenter(new TiConfiguration.Builder()
-                .setUseStaticSaviorToRetain(false)
+                .setRetainPresenterEnabled(true)
                 .build());
 
-        final TiActivityDelegate<TiPresenter<TiView>, TiView> delegate = new TiActivityDelegateBuilder()
+        final TestTiActivity activity = new TestTiActivity.Builder()
                 .setPresenter(presenter)
-                .setIsFinishing(false)
-                .setIsChangingConfigurations(true)
-                .setDontKeepActivitiesEnabled(true)
                 .setSavior(mSavior)
                 .build();
 
-        final Bundle savedState = mock(Bundle.class);
-        final PutInMapAnswer putInMap = putInMap();
-        doAnswer(putInMap).when(savedState).putString(anyString(), anyString());
+        // When the Activity gets created
+        activity.onCreate(null);
+        assertThat(activity.getPresenter().isInitialized()).isTrue();
+        activity.onStart();
+        assertThat(activity.getPresenter().isDestroyed()).isFalse();
 
-        doFullLifecycleAndDestroy(delegate, savedState);
+        // Then the presenter is saved in savior
+        assertThat(presenter.isDestroyed()).isFalse();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(1);
+
+        // When the Activity changes configurations
+        activity.setFinishing(false);
+        activity.setChangingConfiguration(true);
+        activity.onStop();
+        mSavior.mActivityInstanceObserver.onActivitySaveInstanceState(
+                activity.getHostingActivity(), mActivitySavedState);
+        activity.onSaveInstanceState(mActivitySavedState);
+        activity.onDestroy();
+
+        // Then the presenter is not destroyed
+        assertThat(presenter.isDestroyed()).isFalse();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(1);
 
-        assertThat(putInMap.map).containsKey(TiActivityDelegate.SAVED_STATE_PRESENTER_ID);
-        assertThat(putInMap.map.get(TiActivityDelegate.SAVED_STATE_PRESENTER_ID)).isNull();
+        // And recovered in the new instance
+        final TestTiActivity activity2 = new TestTiActivity.Builder()
+                .setSavior(mSavior)
+                .build();
 
-        assertThat(presenter.isDestroyed()).isFalse();
-        assertThat(mSavior.presenterCount()).isEqualTo(0);
+        // When the new Activity instance gets created
+        mSavior.mActivityInstanceObserver.onActivityCreated(
+                activity2.getHostingActivity(), mActivitySavedState);
+        activity2.onCreate(mActivitySavedState);
+        activity2.onStart();
 
-        delegate.onCreate_afterSuper(null);
+        // Then the same presenter gets recovered
+        assertThat(activity2.getPresenter()).isEqualTo(presenter);
     }
 
     @Test
-    public void saviorFalse_dontKeepActivitiesTrue_finish() throws Exception {
+    public void configurationChange_retainTrue_dkATrue() throws Exception {
         final TestPresenter presenter = new TestPresenter(new TiConfiguration.Builder()
-                .setUseStaticSaviorToRetain(false)
+                .setRetainPresenterEnabled(true)
                 .build());
 
-        final TiActivityDelegate<TiPresenter<TiView>, TiView> delegate = new TiActivityDelegateBuilder()
+        final TestTiActivity activity = new TestTiActivity.Builder()
                 .setPresenter(presenter)
-                .setIsFinishing(true)
-                .setIsChangingConfigurations(false)
-                .setDontKeepActivitiesEnabled(true)
                 .setSavior(mSavior)
                 .build();
 
-        final Bundle savedState = mock(Bundle.class);
-        doFullLifecycleAndDestroy(delegate, savedState);
+        // When the Activity gets created
+        activity.onCreate(null);
+        assertThat(activity.getPresenter().isInitialized()).isTrue();
+        activity.onStart();
+        assertThat(activity.getPresenter().isDestroyed()).isFalse();
 
-        assertThat(presenter.isDestroyed()).isTrue();
-        assertThat(mSavior.presenterCount()).isEqualTo(0);
-
-        try {
-            // presenter is destroyed and cannot be recreated
-            delegate.onCreate_afterSuper(null);
-            fail("did not throw");
-        } catch (Exception e) {
-            assertThat(e).hasMessageContaining("destroyed");
-        }
+        // Then the presenter is saved in savior
+        assertThat(presenter.isDestroyed()).isFalse();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(1);
+
+        // When the Activity changes configurations
+        activity.setFinishing(false);
+        activity.setChangingConfiguration(true);
+        activity.onStop();
+        mSavior.mActivityInstanceObserver.onActivitySaveInstanceState(
+                activity.getHostingActivity(), mActivitySavedState);
+        activity.onSaveInstanceState(mActivitySavedState);
+        activity.onDestroy();
+
+        // Then the presenter is not destroyed
+        assertThat(presenter.isDestroyed()).isFalse();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(1);
+
+        // And recovered in the new instance
+        final TestTiActivity activity2 = new TestTiActivity.Builder()
+                .setSavior(mSavior)
+                .build();
+
+        // When the new Activity instance gets created
+        mSavior.mActivityInstanceObserver.onActivityCreated(
+                activity2.getHostingActivity(), mActivitySavedState);
+        activity2.onCreate(mActivitySavedState);
+        activity2.onStart();
+
+        // Then the same presenter gets recovered
+        assertThat(activity2.getPresenter()).isEqualTo(presenter);
     }
 
     @Test
-    public void saviorFalse_dontKeepActivitiesTrue_moveToBackground_moveToForeground()
-            throws Exception {
+    public void finish_retainFalse_dkAFalse() throws Exception {
         final TestPresenter presenter = new TestPresenter(new TiConfiguration.Builder()
-                .setUseStaticSaviorToRetain(false)
+                .setRetainPresenterEnabled(false)
                 .build());
 
-        final TiActivityDelegate<TiPresenter<TiView>, TiView> delegate = new TiActivityDelegateBuilder()
+        final TestTiActivity activity = new TestTiActivity.Builder()
                 .setPresenter(presenter)
-                .setIsFinishing(false)
-                .setIsChangingConfigurations(false)
-                .setDontKeepActivitiesEnabled(true)
                 .setSavior(mSavior)
                 .build();
 
-        final Bundle savedState = mock(Bundle.class);
-        delegate.onCreate_afterSuper(null);
-        // savior is disabled
-        assertThat(mSavior.presenterCount()).isEqualTo(0);
-
-        assertThat(delegate.getPresenter().isInitialized()).isTrue();
-
-        delegate.onStart_afterSuper();
-
-        assertThat(delegate.getPresenter().isDestroyed()).isFalse();
-
-        delegate.onStop_beforeSuper();
-        delegate.onStop_afterSuper();
-        delegate.onSaveInstanceState_afterSuper(savedState);
-
-        delegate.onStart_afterSuper();
+        // When the Activity gets created
+        activity.onCreate(null);
+        assertThat(activity.getPresenter().isInitialized()).isTrue();
+        activity.onStart();
+        assertThat(activity.getPresenter().isDestroyed()).isFalse();
 
+        // Then the presenter is saved in savior
         assertThat(presenter.isDestroyed()).isFalse();
-        assertThat(mSavior.presenterCount()).isEqualTo(0);
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+
+        // When the Activity gets finished
+        activity.setFinishing(true);
+        activity.setChangingConfiguration(false);
+        activity.onStop();
+        assertThat(mSavior.mActivityInstanceObserver).isNull();
+        activity.onSaveInstanceState(mActivitySavedState);
+        activity.onDestroy();
 
-        delegate.onCreate_afterSuper(null);
+        // Then the presenter is destroyed
+        assertThat(presenter.isDestroyed()).isTrue();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
     }
 
     @Test
-    public void saviorTrue_dontKeepActivitiesFalse_configurationChange() throws Exception {
+    public void finish_retainFalse_dkATrue() throws Exception {
         final TestPresenter presenter = new TestPresenter(new TiConfiguration.Builder()
-                .setUseStaticSaviorToRetain(true)
+                .setRetainPresenterEnabled(false)
                 .build());
 
-        final TestPresenter[] retainedPresenter = new TestPresenter[]{null};
-        final TiActivityDelegate<TiPresenter<TiView>, TiView> delegate = new TiActivityDelegateBuilder()
+        final TestTiActivity activity = new TestTiActivity.Builder()
                 .setPresenter(presenter)
-                .setIsFinishing(false)
-                .setIsChangingConfigurations(true)
-                .setDontKeepActivitiesEnabled(false)
                 .setSavior(mSavior)
-                .setRetainedPresenterProvider(new TiPresenterProvider<TiPresenter<TiView>>() {
-                    @NonNull
-                    @Override
-                    public TiPresenter<TiView> providePresenter() {
-                        return retainedPresenter[0];
-                    }
-                })
                 .build();
 
-        final Bundle savedState = mock(Bundle.class);
-        final PutInMapAnswer putInMap = putInMap();
-        doAnswer(putInMap).when(savedState).putString(anyString(), anyString());
+        // When the Activity gets created
+        activity.onCreate(null);
+        assertThat(activity.getPresenter().isInitialized()).isTrue();
+        activity.onStart();
+        assertThat(activity.getPresenter().isDestroyed()).isFalse();
 
-        doFullLifecycleAndDestroy(delegate, savedState);
+        // Then the presenter is saved in savior
+        assertThat(presenter.isDestroyed()).isFalse();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
 
-        assertThat(putInMap.map).containsKey(TiActivityDelegate.SAVED_STATE_PRESENTER_ID);
-        assertThat(putInMap.map.get(TiActivityDelegate.SAVED_STATE_PRESENTER_ID))
-                .contains("TestPresenter");
+        // When the Activity gets finished
+        activity.setFinishing(true);
+        activity.setChangingConfiguration(false);
+        activity.onStop();
+        assertThat(mSavior.mActivityInstanceObserver).isNull();
+        activity.onSaveInstanceState(mActivitySavedState);
+        activity.onDestroy();
 
-        assertThat(presenter.isDestroyed()).isFalse();
-        assertThat(mSavior.presenterCount()).isEqualTo(1);
+        // savior cleaned up
+        assertThat(mSavior.mActivityInstanceObserver).isNull();
 
-        retainedPresenter[0] = presenter;
-        delegate.onCreate_afterSuper(savedState);
+        // Then the presenter is destroyed
+        assertThat(presenter.isDestroyed()).isTrue();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
     }
 
     @Test
-    public void saviorTrue_dontKeepActivitiesFalse_finish() throws Exception {
+    public void finish_retainTrue_dkAFalse() throws Exception {
         final TestPresenter presenter = new TestPresenter(new TiConfiguration.Builder()
-                .setUseStaticSaviorToRetain(true)
+                .setRetainPresenterEnabled(true)
                 .build());
 
-        final TiActivityDelegate<TiPresenter<TiView>, TiView> delegate = new TiActivityDelegateBuilder()
+        final TestTiActivity activity = new TestTiActivity.Builder()
                 .setPresenter(presenter)
-                .setIsFinishing(true)
-                .setIsChangingConfigurations(false)
-                .setDontKeepActivitiesEnabled(false)
                 .setSavior(mSavior)
                 .build();
 
-        final Bundle savedState = mock(Bundle.class);
-        doFullLifecycleAndDestroy(delegate, savedState);
+        // When the Activity gets created
+        activity.onCreate(null);
+        assertThat(activity.getPresenter().isInitialized()).isTrue();
+        activity.onStart();
+        assertThat(activity.getPresenter().isDestroyed()).isFalse();
 
+        // Then the presenter is saved in savior
+        assertThat(presenter.isDestroyed()).isFalse();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(1);
+
+        // When the Activity gets finished
+        activity.setFinishing(true);
+        activity.setChangingConfiguration(false);
+        activity.onStop();
+        mSavior.mActivityInstanceObserver.onActivitySaveInstanceState(
+                activity.getHostingActivity(), mActivitySavedState);
+        activity.onSaveInstanceState(mActivitySavedState);
+        activity.onDestroy();
+
+        // Then the presenter is destroyed
         assertThat(presenter.isDestroyed()).isTrue();
-        assertThat(mSavior.presenterCount()).isEqualTo(0);
-
-        try {
-            // presenter is destroyed and cannot be recreated
-            delegate.onCreate_afterSuper(savedState);
-            fail("did not throw");
-        } catch (Exception e) {
-            assertThat(e).hasMessageContaining("destroyed");
-        }
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
     }
 
     @Test
-    public void saviorTrue_dontKeepActivitiesFalse_moveToBackground_moveToForeground()
-            throws Exception {
+    public void finish_retainTrue_dkATrue() throws Exception {
         final TestPresenter presenter = new TestPresenter(new TiConfiguration.Builder()
-                .setUseStaticSaviorToRetain(true)
+                .setRetainPresenterEnabled(true)
                 .build());
 
-        final TestPresenter[] retainedPresenter = new TestPresenter[]{null};
-        final TiActivityDelegate<TiPresenter<TiView>, TiView> delegate = new TiActivityDelegateBuilder()
+        final TestTiActivity activity = new TestTiActivity.Builder()
                 .setPresenter(presenter)
-                .setIsFinishing(false)
-                .setIsChangingConfigurations(false)
-                .setDontKeepActivitiesEnabled(false)
                 .setSavior(mSavior)
-                .setRetainedPresenterProvider(new TiPresenterProvider<TiPresenter<TiView>>() {
-                    @NonNull
-                    @Override
-                    public TiPresenter<TiView> providePresenter() {
-                        return retainedPresenter[0];
-                    }
-                })
                 .build();
 
-        final Bundle savedState = mock(Bundle.class);
-        delegate.onCreate_afterSuper(null);
-        assertThat(mSavior.presenterCount()).isEqualTo(1);
-
-        assertThat(delegate.getPresenter().isInitialized()).isTrue();
-
-        delegate.onStart_afterSuper();
-
-        assertThat(delegate.getPresenter().isDestroyed()).isFalse();
+        // When the Activity gets created
+        activity.onCreate(null);
+        assertThat(activity.getPresenter().isInitialized()).isTrue();
+        activity.onStart();
+        assertThat(activity.getPresenter().isDestroyed()).isFalse();
 
-        delegate.onStop_beforeSuper();
-        delegate.onStop_afterSuper();
-        delegate.onSaveInstanceState_afterSuper(savedState);
+        // Then the presenter is saved in savior
+        assertThat(presenter.isDestroyed()).isFalse();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(1);
 
-        delegate.onStart_afterSuper();
+        // When the Activity gets finished
+        activity.setFinishing(true);
+        activity.setChangingConfiguration(false);
+        activity.onStop();
+        mSavior.mActivityInstanceObserver.onActivitySaveInstanceState(
+                activity.getHostingActivity(), mActivitySavedState);
+        activity.onSaveInstanceState(mActivitySavedState);
+        activity.onDestroy();
 
-        assertThat(presenter.isDestroyed()).isFalse();
-        assertThat(mSavior.presenterCount()).isEqualTo(1);
+        // savior cleaned up
+        assertThat(mSavior.mActivityInstanceObserver).isNull();
 
-        retainedPresenter[0] = presenter;
-        delegate.onCreate_afterSuper(savedState);
+        // Then the presenter is destroyed
+        assertThat(presenter.isDestroyed()).isTrue();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
     }
 
     @Test
-    public void saviorTrue_dontKeepActivitiesTrue_configurationChange() throws Exception {
+    public void moveToBackground_moveToForeground_retainFalse_dkAFalse() throws Exception {
+
         final TestPresenter presenter = new TestPresenter(new TiConfiguration.Builder()
-                .setUseStaticSaviorToRetain(true)
+                .setRetainPresenterEnabled(false)
                 .build());
 
-        final TiActivityDelegate<TiPresenter<TiView>, TiView> delegate = new TiActivityDelegateBuilder()
+        final TestTiActivity activity = new TestTiActivity.Builder()
                 .setPresenter(presenter)
-                .setIsFinishing(false)
-                .setIsChangingConfigurations(true)
-                .setDontKeepActivitiesEnabled(true)
                 .setSavior(mSavior)
                 .build();
 
-        final Bundle savedState = mock(Bundle.class);
-        final PutInMapAnswer putInMap = putInMap();
-        doAnswer(putInMap).when(savedState).putString(anyString(), anyString());
-
-        doFullLifecycleAndDestroy(delegate, savedState);
+        // When the Activity gets created
+        activity.onCreate(null);
+        assertThat(activity.getPresenter().isInitialized()).isTrue();
+        activity.onStart();
+        assertThat(activity.getPresenter().isDestroyed()).isFalse();
 
-        assertThat(putInMap.map).containsKey(TiActivityDelegate.SAVED_STATE_PRESENTER_ID);
-        assertThat(putInMap.map.get(TiActivityDelegate.SAVED_STATE_PRESENTER_ID))
-                .contains("TestPresenter");
+        // When the Activity moves to background
+        activity.setFinishing(false);
+        activity.setChangingConfiguration(false);
+        activity.onStop();
+        assertThat(mSavior.mActivityInstanceObserver).isNull();
 
+        // Then the presenter is not destroyed
         assertThat(presenter.isDestroyed()).isFalse();
-        assertThat(mSavior.presenterCount()).isEqualTo(1);
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+
+        // When the Activity moves to foreground
+        activity.onStart();
+
+        // Then presenter not destroyed and the same
+        assertThat(activity.getPresenter().isDestroyed()).isFalse();
+        assertThat(activity.getPresenter()).isEqualTo(presenter);
     }
 
     @Test
-    public void saviorTrue_dontKeepActivitiesTrue_finish() throws Exception {
+    public void moveToBackground_moveToForeground_retainFalse_dkATrue() throws Exception {
         final TestPresenter presenter = new TestPresenter(new TiConfiguration.Builder()
-                .setUseStaticSaviorToRetain(true)
+                .setRetainPresenterEnabled(false)
                 .build());
 
-        final TiActivityDelegate<TiPresenter<TiView>, TiView> delegate = new TiActivityDelegateBuilder()
+        final TestTiActivity activity = new TestTiActivity.Builder()
                 .setPresenter(presenter)
-                .setIsFinishing(true)
-                .setIsChangingConfigurations(false)
-                .setDontKeepActivitiesEnabled(true)
                 .setSavior(mSavior)
                 .build();
 
-        final Bundle savedState = mock(Bundle.class);
-        doFullLifecycleAndDestroy(delegate, savedState);
-
+        // When the Activity gets created
+        activity.onCreate(null);
+        assertThat(activity.getPresenter().isInitialized()).isTrue();
+        activity.onStart();
+        assertThat(activity.getPresenter().isDestroyed()).isFalse();
+
+        // When the Activity moves to background
+        activity.setFinishing(false);
+        activity.setChangingConfiguration(false);
+        activity.onStop();
+        assertThat(mSavior.mActivityInstanceObserver).isNull();
+        activity.onSaveInstanceState(mActivitySavedState);
+        activity.onDestroy();
+
+        // Then the presenter is not destroyed
         assertThat(presenter.isDestroyed()).isTrue();
-        assertThat(mSavior.presenterCount()).isEqualTo(0);
-
-        try {
-            // presenter is destroyed and cannot be recreated
-            delegate.onCreate_afterSuper(savedState);
-            fail("did not throw");
-        } catch (Exception e) {
-            assertThat(e).hasMessageContaining("destroyed");
-        }
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+
+        final TestPresenter presenter2 = new TestPresenter(new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(false)
+                .build());
+
+        // When the Activity moves to foreground
+        final TestTiActivity activity2 = new TestTiActivity.Builder()
+                .setSavior(mSavior)
+                .setPresenter(presenter2)
+                .build();
+
+        // When the new Activity instance gets created
+        assertThat(mSavior.mActivityInstanceObserver).isNull();
+        activity2.onCreate(mActivitySavedState);
+        assertThat(activity2.getPresenter().isInitialized()).isTrue();
+        activity2.onStart();
+        assertThat(activity2.getPresenter().isDestroyed()).isFalse();
+
+        // Then a new presenter was created
+        assertThat(activity2.getPresenter()).isNotEqualTo(presenter);
+        assertThat(presenter2.isDestroyed()).isFalse();
     }
 
     @Test
-    public void saviorTrue_dontKeepActivitiesTrue_moveToBackground_moveToForeground()
-            throws Exception {
+    public void moveToBackground_moveToForeground_retainTrue_dkAFalse() throws Exception {
+
         final TestPresenter presenter = new TestPresenter(new TiConfiguration.Builder()
-                .setUseStaticSaviorToRetain(true)
+                .setRetainPresenterEnabled(true)
                 .build());
 
-        final TiActivityDelegate<TiPresenter<TiView>, TiView> delegate = new TiActivityDelegateBuilder()
+        final TestTiActivity activity = new TestTiActivity.Builder()
                 .setPresenter(presenter)
-                .setIsFinishing(false)
-                .setIsChangingConfigurations(false)
-                .setDontKeepActivitiesEnabled(true)
                 .setSavior(mSavior)
                 .build();
 
-        final Bundle savedState = mock(Bundle.class);
-        doFullLifecycleAndDestroy(delegate, savedState);
+        // When the Activity gets created
+        activity.onCreate(null);
+        assertThat(activity.getPresenter().isInitialized()).isTrue();
+        activity.onStart();
+        assertThat(activity.getPresenter().isDestroyed()).isFalse();
+
+        // When the Activity moves to background
+        activity.setFinishing(false);
+        activity.setChangingConfiguration(false);
+        activity.onStop();
+        mSavior.mActivityInstanceObserver.onActivitySaveInstanceState(
+                activity.getHostingActivity(), mActivitySavedState);
 
+        // Then the presenter is not destroyed
         assertThat(presenter.isDestroyed()).isFalse();
-        assertThat(mSavior.presenterCount()).isEqualTo(1);
-    }
+        assertThat(mSavior.getPresenterCount()).isEqualTo(1);
 
-    @Before
-    public void setUp() throws Exception {
-        mSavior = new MockSavior();
-    }
+        // When the Activity moves to foreground
+        activity.onStart();
 
-    @After
-    public void tearDown() throws Exception {
-        mSavior.clear();
+        // Then presenter not destroyed and the same
+        assertThat(activity.getPresenter().isDestroyed()).isFalse();
+        assertThat(activity.getPresenter()).isEqualTo(presenter);
     }
 
-    private void doFullLifecycleAndDestroy(final TiActivityDelegate<TiPresenter<TiView>, TiView> delegate,
-            final Bundle savedState) {
-        delegate.onCreate_afterSuper(null);
+    @Test
+    public void moveToBackground_moveToForeground_retainTrue_dkATrue() throws Exception {
+        final TestPresenter presenter = new TestPresenter(new TiConfiguration.Builder()
+                .setRetainPresenterEnabled(true)
+                .build());
+
+        final TestTiActivity activity = new TestTiActivity.Builder()
+                .setPresenter(presenter)
+                .setSavior(mSavior)
+                .build();
 
-        assertThat(delegate.getPresenter().isInitialized()).isTrue();
+        // When the Activity gets created
+        activity.onCreate(null);
+        assertThat(activity.getPresenter().isInitialized()).isTrue();
+        activity.onStart();
+        assertThat(activity.getPresenter().isDestroyed()).isFalse();
+
+        // When the Activity moves to background
+        activity.setFinishing(false);
+        activity.setChangingConfiguration(false);
+        activity.onStop();
+        mSavior.mActivityInstanceObserver.onActivitySaveInstanceState(
+                activity.getHostingActivity(), mActivitySavedState);
+        activity.onSaveInstanceState(mActivitySavedState);
+        activity.onDestroy();
+
+        // Then the presenter is not destroyed
+        assertThat(presenter.isDestroyed()).isFalse();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(1);
 
-        delegate.onStart_afterSuper();
+        // When the Activity moves to foreground
+        final TestTiActivity activity2 = new TestTiActivity.Builder()
+                .setSavior(mSavior)
+                .build();
 
-        assertThat(delegate.getPresenter().isDestroyed()).isFalse();
+        // When the new Activity instance gets created
+        mSavior.mActivityInstanceObserver.onActivityCreated(
+                activity2.getHostingActivity(), mActivitySavedState);
+        activity2.onCreate(mActivitySavedState);
+        assertThat(activity2.getPresenter().isInitialized()).isTrue();
+        activity2.onStart();
+        assertThat(activity2.getPresenter().isDestroyed()).isFalse();
 
-        delegate.onStop_beforeSuper();
-        delegate.onStop_afterSuper();
-        delegate.onSaveInstanceState_afterSuper(savedState);
-        delegate.onDestroy_afterSuper();
+        // Then the same presenter gets recovered
+        assertThat(activity2.getPresenter()).isEqualTo(presenter);
     }
 
-    @NonNull
-    private PutInMapAnswer putInMap() {
-        return new PutInMapAnswer();
-    }
 }
diff --git a/thirtyinch/src/test/java/net/grandcentrix/thirtyinch/internal/TiFragmentDelegateTest.java b/thirtyinch/src/test/java/net/grandcentrix/thirtyinch/internal/TiFragmentDelegateTest.java
new file mode 100644
index 00000000..ca7ac6ca
--- /dev/null
+++ b/thirtyinch/src/test/java/net/grandcentrix/thirtyinch/internal/TiFragmentDelegateTest.java
@@ -0,0 +1,130 @@
+/*
+ * Copyright (C) 2017 grandcentrix GmbH
+ * 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.
+ */
+
+package net.grandcentrix.thirtyinch.internal;
+
+import net.grandcentrix.thirtyinch.TiConfiguration;
+import net.grandcentrix.thirtyinch.TiPresenter;
+import net.grandcentrix.thirtyinch.TiView;
+
+import org.junit.Test;
+
+import android.support.annotation.NonNull;
+import android.view.LayoutInflater;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+import static junit.framework.Assert.fail;
+import static org.assertj.core.api.Java6Assertions.assertThat;
+import static org.mockito.Mockito.mock;
+
+public class TiFragmentDelegateTest extends AbstractPresenterDestroyTest {
+
+    @Test
+    public void provideDestroyedPresenter() throws Exception {
+        final TestPresenter destroyedPresenter = new TestPresenter(TiConfiguration.DEFAULT);
+        // make presenter destroyed
+        destroyedPresenter.create();
+        destroyedPresenter.destroy();
+
+        final TestTiFragment fragment = new TestTiFragment.Builder()
+                .setPresenter(destroyedPresenter)
+                .build();
+        try {
+            fragment.onCreate(null);
+            fail("did not throw");
+        } catch (IllegalStateException e) {
+            assertThat(e).hasMessageContaining("Presenter not in initialized state")
+                    .hasMessageContaining("providePresenter");
+        }
+    }
+
+    @Test
+    public void provideReusedPresenter() throws Exception {
+
+        final TestPresenter reusedPresenter = new TestPresenter(TiConfiguration.DEFAULT);
+        // create the instance once, the presenter is now not in INITIALIZED state
+        reusedPresenter.create();
+
+        final TestTiFragment fragment = new TestTiFragment.Builder()
+                .setPresenter(reusedPresenter)
+                .build();
+        try {
+            fragment.onCreate(null);
+            fail("did not throw");
+        } catch (IllegalStateException e) {
+            assertThat(e).hasMessageContaining("Presenter not in initialized state")
+                    .hasMessageContaining("providePresenter");
+        }
+    }
+
+    @Test
+    public void reuseSameFragmentCreateANewPresenterInstance() throws Exception {
+
+        final AtomicInteger providePresenterCalls = new AtomicInteger(0);
+
+        // Given a fragment which always return a new presenter instance in providePresenter()
+        final TestTiFragment fragment = new TestTiFragment.Builder()
+                .setPresenterProvider(new TiPresenterProvider<TiPresenter<TiView>>() {
+                    @NonNull
+                    @Override
+                    public TiPresenter<TiView> providePresenter() {
+                        providePresenterCalls.incrementAndGet();
+                        return new TestPresenter(TiConfiguration.DEFAULT);
+                    }
+                })
+                .setSavior(mSavior)
+                .build();
+
+        // When the Fragment is added to the Activity.
+        fragment.onCreate(null);
+        fragment.setAdded(true);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        final TiPresenter<TiView> presenter1 = fragment.getPresenter();
+        // Then the presenter is saved in the savior
+        assertThat(fragment.getPresenter().isDestroyed()).isFalse();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(1);
+
+        // And when the Fragment is removed from the Activity
+        fragment.setAdded(false);
+        fragment.setRemoving(true);
+        fragment.onStop();
+        fragment.onDestroyView();
+        fragment.onDestroy();
+
+        // Then providePresenter was called once
+        assertThat(providePresenterCalls.intValue()).isEqualTo(1);
+
+        // Then assert that the Presenter is destroyed and not saved in the savior
+        assertThat(fragment.getPresenter().isDestroyed()).isTrue();
+        assertThat(mSavior.getPresenterCount()).isEqualTo(0);
+
+        // When the Fragment is added again to the Activity, again
+        fragment.onCreate(null);
+        fragment.setAdded(true);
+        fragment.onCreateView(mock(LayoutInflater.class), null, null);
+        fragment.onStart();
+
+        // Then providePresenter was called again
+        assertThat(providePresenterCalls.intValue()).isEqualTo(2);
+
+        // Then the presenter is different
+        final TiPresenter<TiView> presenter2 = fragment.getPresenter();
+        assertThat(presenter2).isNotSameAs(presenter1);
+
+    }
+}
\ No newline at end of file