How to manage realm instance?

Question

I have an Activity that manage multiples fragments and nested fragment, like that :

Activity -> RootFragment1 -> NestedFragment1, NestedFragment2
             -> RootFragment2 -> NestedFragment3, NestedFragment4 ...

I use to get a realm instance and close it in each nested fragment in onStart, onStop methods but sometimes I meet this exception :

Fatal Exception: java.lang.IllegalStateException: This Realm instance has already been closed, making it unusable.

Is there a recommended way to get a Realm instance and close it ? In my case should I get an instance in Activity and pass it through my fragments ?

Answer 1

The docs say that you should open/close Realm in onCreateView()/onDestroyView(), but in my experience the fragment lifecycle is unusually erratic, so I can show you two other approaches.

1.) open/close the Realm in Activity.onCreate() and Activity.onDestroy(), then share it to the fragments (and even down the view hierarchy!) using getSystemService().

public class MyActivity extends AppCompatActivity {
    Realm realm;

    @Override
    protected void onCreate(Bundle bundle) {
        // ...
        realm = Realm.getDefaultInstance();
    }

    @Override
    protected void onDestroy() {
        realm.close();
        realm = null;
        // ...
    }

    // -----------------------------
    private static final String REALM_TAG = "__REALM__";

    public static Realm getRealm(Context context) {
        // noinspection ResourceType
        return (Realm)context.getSystemService(REALM_TAG);
    }

    @Override
    public Object getSystemService(@NonNull String name) {
        if(REALM_TAG.equals(name)) {
            return realm;
        }
        return super.getSystemService(name);
    }
}

Then in fragment you can do

Realm realm = MyActivity.getRealm(getActivity());

And in views you can do

Realm realm = MyActivity.getRealm(getContext());

---

2.) manage the Realm lifecycle globally for the UI thread using retained fragment as lifecycle listener / activity reference counter.

/**
 * Created by Zhuinden on 2016.08.16..
 */
public class RealmManager {
    private static final String TAG = "RealmManager";

    static Realm realm;

    static RealmConfiguration realmConfiguration;

    public static void init(Context context) {
        Realm.init(context);
    }

    public static void initializeRealmConfig(Context appContext) {
        if(realmConfiguration == null) {
            Log.d(TAG, "Initializing Realm configuration.");
            setRealmConfiguration(new RealmConfiguration.Builder(appContext).initialData(new RealmInitialData())
                    .deleteRealmIfMigrationNeeded()
                    .inMemory()
                    .build());
        }
    }

    public static void setRealmConfiguration(RealmConfiguration realmConfiguration) {
        RealmManager.realmConfiguration = realmConfiguration;
        Realm.setDefaultConfiguration(realmConfiguration);
    }

    private static int activityCount = 0;

    public static Realm getRealm() { // use on UI thread only!
        return realm;
    }

    public static void incrementCount() {
        if(activityCount == 0) {
            if(realm != null) {
                if(!realm.isClosed()) {
                    Log.w(TAG, "Unexpected open Realm found.");
                    realm.close();
                }
            }
            Log.d(TAG, "Incrementing Activity Count [0]: opening Realm.");
            realm = Realm.getDefaultInstance();
        }
        activityCount++;
        Log.d(TAG, "Increment: Count [" + activityCount + "]");
    }

    public static void decrementCount() {
        activityCount--;
        Log.d(TAG, "Decrement: Count [" + activityCount + "]");
        if(activityCount <= 0) {
            Log.d(TAG, "Decrementing Activity Count: closing Realm.");
            activityCount = 0;
            realm.close();
            if(Realm.compactRealm(realmConfiguration)) {
                Log.d(TAG, "Realm compacted successfully.");
            }
            realm = null;
        }
    }
}

In conjunction with

public class RealmScopeListener
        extends Fragment {
    public RealmScopeListener() {
        setRetainInstance(true);
        RealmManager.incrementCount();
    }

    @Override
    public void onDestroy() {
        RealmManager.decrementCount();
        super.onDestroy();
    }
}

And

/**
 * Created by Zhuinden on 2016.09.04..
 */
public class RealmActivity extends AppCompatActivity {
    protected Realm realm;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        RealmManager.init(this);
        RealmManager.initializeRealmConfig(getApplicationContext());

        super.onCreate(savedInstanceState);
        RealmScopeListener realmScopeListener = (RealmScopeListener)getSupportFragmentManager().findFragmentByTag("SCOPE_LISTENER");
        if(realmScopeListener == null) {
            realmScopeListener = new RealmScopeListener();
            getSupportFragmentManager().beginTransaction().add(realmScopeListener, "SCOPE_LISTENER").commit();
        }
        realm = RealmManager.getRealm();
    }
}

This allows you to call RealmManager.getRealm() for the UI thread, and its lifecycle is managed by retain fragments.